gnss-js 1.23.0 → 1.24.0

package/dist/positioning.cjs

@@ -23,6 +23,8 @@ __export(positioning_exports, {
   RtkFloatEngine: () => RtkFloatEngine,
   ionoFree: () => ionoFree,
   klobucharDelay: () => klobucharDelay,
+  lambdaReduction: () => lambdaReduction,
+  lambdaSearch: () => lambdaSearch,
   satClockCorrection: () => satClockCorrection,
   solveDgnss: () => solveDgnss,
   solveSpp: () => solveSpp,
@@ -462,6 +464,207 @@ function klobucharDelay(coeffs, latRad, lonRad, azRad, elRad, gpsTowSec) {
   return F * (5e-9 + amp * (1 - x2 / 2 + x2 * x2 / 24));
 }
 
+// src/positioning/lambda.ts
+var LOOPMAX = 1e4;
+var ROUND = (x) => Math.floor(x + 0.5);
+var SGN = (x) => x <= 0 ? -1 : 1;
+function ldFactor(n, Q, L, D) {
+  const A = Float64Array.from(Q);
+  for (let i = n - 1; i >= 0; i--) {
+    D[i] = A[i + i * n];
+    if (D[i] <= 0) return false;
+    const a = Math.sqrt(D[i]);
+    for (let j = 0; j <= i; j++) L[i + j * n] = A[i + j * n] / a;
+    for (let j = 0; j <= i - 1; j++)
+      for (let k = 0; k <= j; k++) A[j + k * n] -= L[i + k * n] * L[i + j * n];
+    for (let j = 0; j <= i; j++) L[i + j * n] /= L[i + i * n];
+  }
+  return true;
+}
+function gauss(n, L, Z, i, j) {
+  const mu = ROUND(L[i + j * n]);
+  if (mu !== 0) {
+    for (let k = i; k < n; k++) L[k + n * j] -= mu * L[k + i * n];
+    for (let k = 0; k < n; k++) Z[k + n * j] -= mu * Z[k + i * n];
+  }
+}
+function perm(n, L, D, j, del, Z) {
+  const eta = D[j] / del;
+  const lam = D[j + 1] * L[j + 1 + j * n] / del;
+  D[j] = eta * D[j + 1];
+  D[j + 1] = del;
+  for (let k = 0; k <= j - 1; k++) {
+    const a0 = L[j + k * n];
+    const a1 = L[j + 1 + k * n];
+    L[j + k * n] = -L[j + 1 + j * n] * a0 + a1;
+    L[j + 1 + k * n] = eta * a0 + lam * a1;
+  }
+  L[j + 1 + j * n] = lam;
+  for (let k = j + 2; k < n; k++) {
+    const t = L[k + j * n];
+    L[k + j * n] = L[k + (j + 1) * n];
+    L[k + (j + 1) * n] = t;
+  }
+  for (let k = 0; k < n; k++) {
+    const t = Z[k + j * n];
+    Z[k + j * n] = Z[k + (j + 1) * n];
+    Z[k + (j + 1) * n] = t;
+  }
+}
+function reduction(n, L, D, Z) {
+  let j = n - 2;
+  let k = n - 2;
+  while (j >= 0) {
+    if (j <= k) for (let i = j + 1; i < n; i++) gauss(n, L, Z, i, j);
+    const del = D[j] + L[j + 1 + j * n] * L[j + 1 + j * n] * D[j + 1];
+    if (del + 1e-6 < D[j + 1]) {
+      perm(n, L, D, j, del, Z);
+      k = j;
+      j = n - 2;
+    } else j--;
+  }
+}
+function search(n, m, L, D, zs, zn, s) {
+  let nn = 0;
+  let imax = 0;
+  let maxdist = 1e99;
+  const S = new Float64Array(n * n);
+  const dist = new Float64Array(n);
+  const zb = new Float64Array(n);
+  const z = new Float64Array(n);
+  const step = new Float64Array(n);
+  let k = n - 1;
+  dist[k] = 0;
+  zb[k] = zs[k];
+  z[k] = ROUND(zb[k]);
+  let y = zb[k] - z[k];
+  step[k] = SGN(y);
+  let c = 0;
+  for (; c < LOOPMAX; c++) {
+    const newdist = dist[k] + y * y / D[k];
+    if (newdist < maxdist) {
+      if (k !== 0) {
+        dist[--k] = newdist;
+        for (let i = 0; i <= k; i++)
+          S[k + i * n] = S[k + 1 + i * n] + (z[k + 1] - zb[k + 1]) * L[k + 1 + i * n];
+        zb[k] = zs[k] + S[k + k * n];
+        z[k] = ROUND(zb[k]);
+        y = zb[k] - z[k];
+        step[k] = SGN(y);
+      } else {
+        if (nn < m) {
+          if (nn === 0 || newdist > s[imax]) imax = nn;
+          for (let i = 0; i < n; i++) zn[i + nn * n] = z[i];
+          s[nn++] = newdist;
+        } else {
+          if (newdist < s[imax]) {
+            for (let i = 0; i < n; i++) zn[i + imax * n] = z[i];
+            s[imax] = newdist;
+            imax = 0;
+            for (let i = 0; i < m; i++) if (s[imax] < s[i]) imax = i;
+          }
+          maxdist = s[imax];
+        }
+        z[0] += step[0];
+        y = zb[0] - z[0];
+        step[0] = -step[0] - SGN(step[0]);
+      }
+    } else {
+      if (k === n - 1) break;
+      k++;
+      z[k] += step[k];
+      y = zb[k] - z[k];
+      step[k] = -step[k] - SGN(step[k]);
+    }
+  }
+  for (let i = 0; i < m - 1; i++) {
+    for (let j = i + 1; j < m; j++) {
+      if (s[i] < s[j]) continue;
+      const t = s[i];
+      s[i] = s[j];
+      s[j] = t;
+      for (let l = 0; l < n; l++) {
+        const u = zn[l + i * n];
+        zn[l + i * n] = zn[l + j * n];
+        zn[l + j * n] = u;
+      }
+    }
+  }
+  return c < LOOPMAX;
+}
+function solveZt(n, m, Z, E) {
+  const w = n + m;
+  const M = new Float64Array(n * w);
+  for (let r = 0; r < n; r++) {
+    for (let cIdx = 0; cIdx < n; cIdx++) M[r * w + cIdx] = Z[cIdx + r * n];
+    for (let cIdx = 0; cIdx < m; cIdx++) M[r * w + n + cIdx] = E[r + cIdx * n];
+  }
+  for (let col = 0; col < n; col++) {
+    let piv = col;
+    for (let r = col + 1; r < n; r++)
+      if (Math.abs(M[r * w + col]) > Math.abs(M[piv * w + col])) piv = r;
+    if (Math.abs(M[piv * w + col]) < 1e-12) return null;
+    if (piv !== col) {
+      for (let cIdx = col; cIdx < w; cIdx++) {
+        const t = M[col * w + cIdx];
+        M[col * w + cIdx] = M[piv * w + cIdx];
+        M[piv * w + cIdx] = t;
+      }
+    }
+    const d = M[col * w + col];
+    for (let cIdx = col; cIdx < w; cIdx++) M[col * w + cIdx] /= d;
+    for (let r = 0; r < n; r++) {
+      if (r === col) continue;
+      const f = M[r * w + col];
+      if (f === 0) continue;
+      for (let cIdx = col; cIdx < w; cIdx++)
+        M[r * w + cIdx] -= f * M[col * w + cIdx];
+    }
+  }
+  const X = new Float64Array(n * m);
+  for (let r = 0; r < n; r++)
+    for (let cIdx = 0; cIdx < m; cIdx++) X[r + cIdx * n] = M[r * w + n + cIdx];
+  return X;
+}
+function lambdaSearch(a, Q, n, m = 2) {
+  if (n <= 0 || m <= 0 || a.length < n || Q.length < n * n) return null;
+  const L = new Float64Array(n * n);
+  const D = new Float64Array(n);
+  if (!ldFactor(n, Q, L, D)) return null;
+  const Z = new Float64Array(n * n);
+  for (let i = 0; i < n; i++) Z[i + i * n] = 1;
+  reduction(n, L, D, Z);
+  const z = new Float64Array(n);
+  for (let j = 0; j < n; j++) {
+    let sum = 0;
+    for (let k = 0; k < n; k++) sum += Z[k + j * n] * a[k];
+    z[j] = sum;
+  }
+  const E = new Float64Array(n * m);
+  const s = new Float64Array(m);
+  if (!search(n, m, L, D, z, E, s)) return null;
+  const F = solveZt(n, m, Z, E);
+  if (!F) return null;
+  const candidates = [];
+  for (let c = 0; c < m; c++) {
+    const v = new Float64Array(n);
+    for (let i = 0; i < n; i++) v[i] = ROUND(F[i + c * n]);
+    candidates.push(v);
+  }
+  const ratio = m >= 2 && s[0] > 0 ? s[1] / s[0] : Infinity;
+  return { candidates, residuals: s, ratio };
+}
+function lambdaReduction(Q, n) {
+  if (n <= 0 || Q.length < n * n) return null;
+  const L = new Float64Array(n * n);
+  const D = new Float64Array(n);
+  if (!ldFactor(n, Q, L, D)) return null;
+  const Z = new Float64Array(n * n);
+  for (let i = 0; i < n; i++) Z[i + i * n] = 1;
+  reduction(n, L, D, Z);
+  return Z;
+}
+
 // src/positioning/rtk.ts
 var L1_CODES = {
   G: ["1C"],
@@ -822,7 +1025,13 @@ var RtkFloatEngine = class {
       maxGapMs: opts.maxGapMs ?? 1e4,
       codeGateM: opts.codeGateM ?? 30,
       slipGateM: opts.slipGateM ?? 5,
-      updateIterations: opts.updateIterations ?? 2
+      updateIterations: opts.updateIterations ?? 2,
+      ambiguityResolution: opts.ambiguityResolution ?? "off",
+      ratioThreshold: opts.ratioThreshold ?? 3,
+      arElevationMaskDeg: opts.arElevationMaskDeg ?? 0,
+      glonassAr: opts.glonassAr ?? false,
+      partialFixing: opts.partialFixing ?? true,
+      minFixAmbiguities: opts.minFixAmbiguities ?? 4
     };
   }
   /** Clear all filter state (position, ambiguities, lock history). */
@@ -880,6 +1089,56 @@ var RtkFloatEngine = class {
     const entry = this.amb[newRefIdx];
     entry.prn = oldRef;
   }
+  /**
+   * Try to fix the ambiguity subset `idxs` (indices into `this.amb`):
+   * extract the float subvector b and covariance Q_b from the filter,
+   * run MLAMBDA and, without touching the filter state, condition the
+   * position on the best integer candidate,
+   *   xa = x − P_xb·Q_b⁻¹·(b − ǎ)
+   * (RTKLIB rtkpos.c `resamb_LAMBDA`). Returns null when Q_b is not
+   * positive definite / invertible or the search fails; ratio
+   * validation is the caller's job.
+   */
+  tryFix(idxs) {
+    const k = idxs.length;
+    const b = new Float64Array(k);
+    const Qb = new Float64Array(k * k);
+    const QbRows = [];
+    for (let i = 0; i < k; i++) {
+      const si = 3 + idxs[i];
+      b[i] = this.x[si];
+      const row = [];
+      for (let j = 0; j < k; j++) {
+        const sj = 3 + idxs[j];
+        const q = (this.P[si][sj] + this.P[sj][si]) / 2;
+        Qb[i + j * k] = q;
+        row.push(q);
+      }
+      QbRows.push(row);
+    }
+    const res = lambdaSearch(b, Qb, k, 2);
+    if (!res) return null;
+    const best = res.candidates[0];
+    const QbInv = matInv(QbRows);
+    if (!QbInv) return null;
+    const db = [];
+    for (let i = 0; i < k; i++) db.push(b[i] - best[i]);
+    const position = [
+      this.x[0],
+      this.x[1],
+      this.x[2]
+    ];
+    for (let r = 0; r < 3; r++) {
+      let dx = 0;
+      for (let i = 0; i < k; i++) {
+        let yi = 0;
+        for (let j = 0; j < k; j++) yi += QbInv[i][j] * db[j];
+        dx += this.P[r][3 + idxs[i]] * yi;
+      }
+      position[r] -= dx;
+    }
+    return { ratio: res.ratio, position, intAmb: [...best] };
+  }
   /**
    * Process one synchronized epoch (same nominal `timeMs` for both
    * receivers). Returns null until a first position can be
@@ -1130,6 +1389,47 @@ var RtkFloatEngine = class {
         Pnew[j][i] = s;
       }
     this.P = Pnew;
+    let status = rows.some(
+      (r) => r.kind === "phase"
+    ) ? "float" : "dgnss";
+    let ratio;
+    let nFixed;
+    let fixedPos = null;
+    let fixedAmbiguities;
+    if (o.ambiguityResolution === "instant") {
+      const cands = [];
+      for (const row of rows) {
+        if (row.kind !== "phase") continue;
+        if (row.g.prn[0] === "R" && !o.glonassAr) continue;
+        if (row.g.elB < o.arElevationMaskDeg * Math.PI / 180) continue;
+        cands.push({ idx: row.ambIdx, el: row.g.elB });
+      }
+      cands.sort((a, b) => b.el - a.el);
+      const floor = Math.max(
+        o.minFixAmbiguities,
+        Math.ceil(cands.length / 2),
+        1
+      );
+      while (cands.length >= floor) {
+        const fix = this.tryFix(cands.map((c) => c.idx));
+        if (!fix) break;
+        const capped = Math.min(fix.ratio, 999.9);
+        ratio ??= capped;
+        if (fix.ratio >= o.ratioThreshold) {
+          ratio = capped;
+          status = "fixed";
+          nFixed = cands.length;
+          fixedPos = fix.position;
+          fixedAmbiguities = {};
+          cands.forEach((c, i) => {
+            fixedAmbiguities[this.amb[c.idx].prn] = fix.intAmb[i];
+          });
+          break;
+        }
+        if (!o.partialFixing) break;
+        cands.pop();
+      }
+    }
     for (const g of geom) {
       if (g.cpR === null || g.cpB === null) continue;
       this.track.set(g.prn, { lockR: g.lockR, lockB: g.lockB, lastMs: timeMs });
@@ -1143,14 +1443,22 @@ var RtkFloatEngine = class {
     const nSats = new Set(rows.flatMap((r) => [r.g.prn, r.ref.prn])).size;
     return {
       timeMs,
-      position: [this.x[0], this.x[1], this.x[2]],
+      position: fixedPos ?? [this.x[0], this.x[1], this.x[2]],
       floatBaseline: [
         this.x[0] - this.basePos[0],
         this.x[1] - this.basePos[1],
         this.x[2] - this.basePos[2]
       ],
+      status,
       nSats,
-      ratio: void 0,
+      ratio,
+      nFixed,
+      fixedBaseline: fixedPos ? [
+        fixedPos[0] - this.basePos[0],
+        fixedPos[1] - this.basePos[1],
+        fixedPos[2] - this.basePos[2]
+      ] : void 0,
+      fixedAmbiguities,
       sigmas: [
         Math.sqrt(Math.max(this.P[0][0], 0)),
         Math.sqrt(Math.max(this.P[1][1], 0)),
@@ -1378,6 +1686,8 @@ function solveSpp(pseudoranges, ephemerides, timeMs, opts = {}) {
   RtkFloatEngine,
   ionoFree,
   klobucharDelay,
+  lambdaReduction,
+  lambdaSearch,
   satClockCorrection,
   solveDgnss,
   solveSpp,

package/dist/positioning.d.cts

@@ -54,7 +54,29 @@ declare function klobucharDelay(coeffs: KlobucharCoeffs, latRad: number, lonRad:
  *   (LAMBDA) needs the joint float ambiguity covariance — which the
  *   EKF maintains natively. This mirrors RTKLIB's float-filter
  *   structure (rtkpos.c), which the implementation was validated
- *   against; no integer fixing is attempted (`ratio` is reserved).
+ *   against.
+ *
+ * Stage 2 — integer ambiguity resolution (opt-in via
+ * `ambiguityResolution: 'instant'`): after each float update the
+ * engine extracts the DD ambiguity subvector and its joint covariance
+ * from the filter, runs MLAMBDA (`lambdaSearch`, a port of RTKLIB's
+ * lambda.c) and validates the best candidate with the ratio test
+ * (s₂/s₁ ≥ `ratioThreshold`, default 3.0 — RTKLIB's default). On
+ * acceptance the rover position is conditioned on the integer
+ * ambiguities (xa = x − P_xb·Q_b⁻¹·(b − ǎ), RTKLIB rtkpos.c
+ * `resamb_LAMBDA`) and reported as a FIXED solution; the filter state
+ * itself is *not* modified (instant, per-epoch fixing — RTKLIB's
+ * `armode=instantaneous`; continuous AR/fix-and-hold, which feed the
+ * fix back into the filter, are stage-3 continuity options). When the
+ * full set fails the ratio test, partial fixing retries after
+ * dropping the lowest-elevation ambiguity, one at a time, down to
+ * half the candidate set (and never below `minFixAmbiguities`) — an
+ * elevation-ordered subset walk in the spirit of RTKLIB demo5's
+ * satellite exclusion, floored so an unconverged float cannot buy a
+ * lucky ratio on a tiny subset. GLONASS ambiguities are excluded from
+ * fixing by
+ * default (DD IFB is only integer-safe across same-model receivers;
+ * enable with `glonassAr`).
  *
  * Differencing model: for satellites s and reference r observed by
  * rover R and base B, the DD pseudorange/phase cancels satellite
@@ -208,18 +230,65 @@ interface RtkFloatOptions {
     slipGateM?: number;
     /** Measurement-update relinearisations (IEKF). Default 2. */
     updateIterations?: number;
+    /**
+     * Integer ambiguity resolution: 'off' keeps the stage-1 float-only
+     * behaviour; 'instant' attempts a per-epoch LAMBDA fix after each
+     * float update (no state feedback — RTKLIB `armode=instantaneous`).
+     * Default 'off'.
+     */
+    ambiguityResolution?: 'off' | 'instant';
+    /** Ratio-test acceptance threshold (s₂/s₁). Default 3.0 (RTKLIB). */
+    ratioThreshold?: number;
+    /**
+     * Additional elevation mask (deg) for ambiguities entering the fix
+     * (RTKLIB `elmaskar`); 0 = use every measured ambiguity. Default 0.
+     */
+    arElevationMaskDeg?: number;
+    /**
+     * Include GLONASS FDMA ambiguities in the integer fix. Only sound
+     * across same-model receivers (differential IFB). Default false.
+     */
+    glonassAr?: boolean;
+    /**
+     * Partial fixing: when the full ambiguity set fails the ratio test,
+     * drop the lowest-elevation ambiguity and retry (elevation-ordered
+     * subset walk), never below half the candidates. Default true.
+     */
+    partialFixing?: boolean;
+    /** Minimum DD ambiguities to attempt/accept a fix. Default 4. */
+    minFixAmbiguities?: number;
 }
 interface RtkFloatSolution {
     /** Epoch, GPS-scale milliseconds. */
     timeMs: number;
-    /** Rover position, ECEF metres. */
+    /**
+     * Rover position, ECEF metres — the ambiguity-fixed position when
+     * `status === 'fixed'`, the float filter position otherwise.
+     */
     position: [number, number, number];
-    /** Float baseline rover − base, ECEF metres. */
+    /** Float baseline rover − base, ECEF metres (always the float). */
     floatBaseline: [number, number, number];
+    /**
+     * Solution quality: 'fixed' when LAMBDA passed the ratio test,
+     * 'float' when carrier ambiguities contributed but no (accepted)
+     * fix, 'dgnss' when the epoch was updated from code DDs only.
+     */
+    status: 'fixed' | 'float' | 'dgnss';
     /** Satellites contributing DD rows this epoch (incl. references). */
     nSats: number;
-    /** Ambiguity-validation ratio — undefined at stage 1 (no LAMBDA). */
+    /**
+     * Ambiguity-validation ratio (s₂/s₁ of the LAMBDA candidates,
+     * capped at 999.9 as RTKLIB): the accepted subset's ratio when
+     * fixed, the full-set ratio otherwise. Undefined when no fix was
+     * attempted (`ambiguityResolution: 'off'` or no eligible set).
+     */
     ratio?: number;
+    /** Number of integer-fixed DD ambiguities (when `status==='fixed'`). */
+    nFixed?: number;
+    /** Fixed baseline rover − base, ECEF metres (when fixed). */
+    fixedBaseline?: [number, number, number];
+    /** Integer DD ambiguity (cycles) per fixed PRN (when fixed). */
+    fixedAmbiguities?: Record<string, number>;
     /** Formal position sigmas (filter covariance), ECEF metres. */
     sigmas: [number, number, number];
     /** Float DD ambiguity (cycles) per non-reference PRN. */
@@ -262,6 +331,17 @@ declare class RtkFloatEngine {
      * transform of state and covariance (P' = T P Tᵀ).
      */
     private retarget;
+    /**
+     * Try to fix the ambiguity subset `idxs` (indices into `this.amb`):
+     * extract the float subvector b and covariance Q_b from the filter,
+     * run MLAMBDA and, without touching the filter state, condition the
+     * position on the best integer candidate,
+     *   xa = x − P_xb·Q_b⁻¹·(b − ǎ)
+     * (RTKLIB rtkpos.c `resamb_LAMBDA`). Returns null when Q_b is not
+     * positive definite / invertible or the search fails; ratio
+     * validation is the caller's job.
+     */
+    private tryFix;
     /**
      * Process one synchronized epoch (same nominal `timeMs` for both
      * receivers). Returns null until a first position can be
@@ -271,6 +351,88 @@ declare class RtkFloatEngine {
     process(rover: RtkEpochMeasurements, base: RtkEpochMeasurements, timeMs: number): RtkFloatSolution | null;
 }
 
+/**
+ * Integer ambiguity resolution: LAMBDA decorrelation + MLAMBDA
+ * integer least-squares search.
+ *
+ * Port of RTKLIB's `lambda.c` (demo5 / rtklibexplorer fork,
+ * src/lambda.c, Copyright (c) 2007-2008 T. Takasu, BSD-2-Clause),
+ * cross-checked against the reference papers where the C comments are
+ * thin:
+ *
+ * - [1] P.J.G. Teunissen, "The least-squares ambiguity decorrelation
+ *   adjustment: a method for fast GPS ambiguity estimation",
+ *   J. Geodesy 70, 65-82, 1995.
+ * - [2] X.-W. Chang, X. Yang, T. Zhou, "MLAMBDA: A modified LAMBDA
+ *   method for integer least-squares estimation", J. Geodesy 79,
+ *   552-565, 2005.
+ *
+ * Pipeline (identical to RTKLIB's `lambda()`):
+ * 1. LᵀDL factorization of the float covariance, Q = Lᵀ·diag(D)·L
+ *    with L unit lower triangular (RTKLIB's `LD`).
+ * 2. LAMBDA reduction [1]: integer Gauss transformations interleaved
+ *    with symmetric permutations until the transformed D is
+ *    (approximately) descending — producing a unimodular Z with
+ *    Qz = ZᵀQZ = Lᵀ·diag(D)·L far better conditioned than Q.
+ * 3. MLAMBDA search [2] in the decorrelated space: depth-first
+ *    enumeration over a shrinking ellipsoid, keeping the `m` smallest
+ *    residual quadratic forms (z−ž)ᵀQz⁻¹(z−ž).
+ * 4. Back-transform the candidates to the original space, a = Z⁻ᵀ·ž
+ *    (RTKLIB solves ZᵀF = E; Z is unimodular so F is exactly integer).
+ *
+ * Deviations from lambda.c:
+ * - matrices are `Float64Array` in the same column-major layout, with
+ *   allocation-failure paths dropped (JS throws instead),
+ * - failures (non-positive-definite Q, search loop overflow) return
+ *   `null` instead of a status code + stderr message,
+ * - back-transformed candidates are rounded to the nearest integer:
+ *   F = Z⁻ᵀ·ž is exactly integer in ℤ arithmetic and the rounding only
+ *   removes the ~1e-12 fuzz of the floating-point triangular solve,
+ * - the ratio s₂/s₁ used by the RTKLIB caller (`rtkpos.c`) is returned
+ *   alongside the candidates (∞ when s₁ = 0, i.e. noise-free input).
+ */
+/** Result of an integer least-squares search. */
+interface LambdaResult {
+    /**
+     * The `m` best integer candidate vectors (length n each), sorted by
+     * ascending residual quadratic form; `candidates[0]` is the integer
+     * least-squares minimizer.
+     */
+    candidates: Float64Array[];
+    /**
+     * Residual quadratic forms sᵢ = (a−ǎᵢ)ᵀQ⁻¹(a−ǎᵢ) matching
+     * `candidates`, ascending.
+     */
+    residuals: Float64Array;
+    /**
+     * Ratio-test statistic s₂/s₁ (second-best over best); `Infinity`
+     * when the best residual is exactly 0 (noise-free input). Callers
+     * typically cap it (RTKLIB uses 999.9) before thresholding.
+     */
+    ratio: number;
+}
+/**
+ * LAMBDA/MLAMBDA integer least-squares estimation (RTKLIB `lambda`):
+ * decorrelate the float ambiguities, search the `m` best integer
+ * vectors and back-transform them to the original space.
+ *
+ * @param a Float ambiguities (length ≥ n).
+ * @param Q Their covariance, n×n (symmetric — row/column-major agree).
+ * @param n Number of ambiguities.
+ * @param m Number of candidates to return (default 2: best +
+ *   second-best, what the ratio test needs).
+ * @returns Candidates + residuals + ratio, or null when Q is not
+ *   positive definite or the search does not terminate.
+ */
+declare function lambdaSearch(a: Float64Array, Q: Float64Array, n: number, m?: number): LambdaResult | null;
+/**
+ * LAMBDA reduction only (RTKLIB `lambda_reduction`): the unimodular
+ * decorrelation matrix Z (n×n, column-major) such that Qz = ZᵀQZ is
+ * (near-)diagonally dominant. Exposed for diagnostics/tests; returns
+ * null when Q is not positive definite.
+ */
+declare function lambdaReduction(Q: Float64Array, n: number): Float64Array | null;
+
 /**
  * Single-point positioning (SPP) from pseudoranges and broadcast
  * ephemerides.
@@ -351,4 +513,4 @@ declare function ionoFree(p1: number, p2: number, f1: number, f2: number): numbe
  */
 declare function solveSpp(pseudoranges: Map<string, number>, ephemerides: Map<string, Ephemeris>, timeMs: number, opts?: SppOptions): SppSolution | null;
 
-export { type DgnssOptions, type DgnssSolution, type EphemerisSource, type KlobucharCoeffs, type RawObservation, type RtkEpochMeasurements, RtkFloatEngine, type RtkFloatOptions, type RtkFloatSolution, type RtkMeasurement, type SppOptions, type SppSolution, ionoFree, klobucharDelay, satClockCorrection, solveDgnss, solveSpp, toRtkEpoch };
+export { type DgnssOptions, type DgnssSolution, type EphemerisSource, type KlobucharCoeffs, type LambdaResult, type RawObservation, type RtkEpochMeasurements, RtkFloatEngine, type RtkFloatOptions, type RtkFloatSolution, type RtkMeasurement, type SppOptions, type SppSolution, ionoFree, klobucharDelay, lambdaReduction, lambdaSearch, satClockCorrection, solveDgnss, solveSpp, toRtkEpoch };