@math.gl/core 5.0.0-alpha.19 → 5.0.0-alpha.20

package/src/expressions/parse-expression-string.ts

@@ -14,9 +14,9 @@ import {get} from './get';
  */
 export type AccessorFunction = (row: Record<string, unknown>) => unknown;
 
-const cachedExpressionMap: Record<string, AccessorFunction> = {
-  '-': object => object
-};
+const cachedExpressionMap = Object.assign(Object.create(null) as Record<string, AccessorFunction>, {
+  '-': (object: Record<string, unknown>) => object
+});
 
 /**
  * Compiles a JSON-style expression string into an accessor function.

package/src/spheroid.ts

@@ -2,13 +2,15 @@
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
-// SPDX-FileComment: Forward geocentric equations and Hannover inverse moved/adapted from math.gl projection's proj4js 2.22.0 datumUtils.js port. See ../PROJ4-LICENSE.md. Safeguarded nearest-footpoint inverse and numeric output commit are original math.gl code.
+// SPDX-FileComment: Forward geocentric equations and Hannover inverse moved/adapted from math.gl projection's proj4js 2.22.0 datumUtils.js port. See ../PROJ4-LICENSE.md. Safeguarded compensated nearest-footpoint inverse, thin-exterior/pole fixes and numeric output commit are original math.gl code, qualified with independent mathematics and offline GeographicLib 2.7 (Charles Karney, MIT).
 
 /** Numeric leaf: angles in radians, distances in axis units; no CRS, global config or scratch. */
 import type {SpheroidParameters} from './types';
 export type SpheroidGeometry = SpheroidParameters & {readonly eccentricitySquared: number};
 export type SpheroidPoint = {x: number; y: number; z: number};
 
+const EPSILON = Number.EPSILON;
+
 /** Caller supplies validated positive finite axes and eccentricity. No latitude wrapping. */
 export function spheroidToCartesian(
   point: SpheroidPoint,
@@ -20,7 +22,7 @@ export function spheroidToCartesian(
     height = point.z;
   const {semiMajorAxis: a, semiMinorAxis: b, eccentricitySquared: es} = geometry;
   const sin = Math.sin(latitude),
-    cos = Math.cos(latitude);
+    cos = Math.abs(latitude) === Math.PI / 2 ? 0 : Math.cos(latitude);
   // Use the axis ratio for very flat shapes: 1 - es*sin² loses polar precision.
   const ratio = b / a;
   const radius = es < 0.9 ? a / Math.sqrt(1 - es * sin * sin) : a / Math.hypot(cos, ratio * sin);
@@ -32,7 +34,7 @@ export function spheroidToCartesian(
 
 /**
  * Bounded inverse. Sphere is analytic; ordinary spheroids use the retained Hannover
- * iteration on exterior points. Interiors use a safeguarded nearest-footpoint solve.
+ * iteration on exterior points. Interiors and thin-shape exteriors share a safeguarded nearest-footpoint solve.
  * Equatorial interiors below the evolute cusp have two nearest normals: reject.
  * false leaves output untouched, including the center and unresolved binary64 cases.
  * Only exact poles canonicalize longitude; adapters may retain other conventions.
@@ -46,16 +48,17 @@ export function cartesianToSpheroid(
     y = point.y,
     z = point.z;
   const {semiMajorAxis: a, semiMinorAxis: b, eccentricitySquared: es} = geometry;
+  const longitude = Math.atan2(y, x);
   const p = Math.hypot(x, y),
     rr = Math.hypot(x, y, z);
   if (!(rr > 0) || !Number.isFinite(rr)) return false;
-  if (es === 0) return commit(result, p === 0 ? 0 : Math.atan2(y, x), Math.atan2(z, p), rr - a);
+  if (es === 0) return commit(result, p === 0 ? 0 : longitude, Math.atan2(z, p), rr - a);
   if (p === 0) return commit(result, 0, (Math.sign(z) * Math.PI) / 2, Math.abs(z) - b);
   const horizontal = p / a,
     vertical = z / b;
-  if (horizontal * horizontal + vertical * vertical < 1 - 16 * Number.EPSILON)
+  if (horizontal * horizontal + vertical * vertical < 1 - 16 * EPSILON)
     return interiorInverse(x, y, z, p, a, b, result);
-  if (es >= 0.9) return exteriorInverse(x, y, z, p, a, b, result);
+  if (es >= 0.9) return interiorInverse(x, y, z, p, a, b, result);
   const ct = z / rr,
     st = p / rr;
   let rx = 1 / Math.sqrt(1 - es * (2 - es) * st * st);
@@ -69,16 +72,16 @@ export function cartesianToSpheroid(
     const nextCos = st * (1 - rk) * rx,
       nextSin = ct * rx;
     if (Math.abs(nextSin * cos - nextCos * sin) <= 1e-12) {
-      if (!Number.isFinite(height) || !Number.isFinite(nextSin) || !Number.isFinite(nextCos)) break;
-      return commit(result, Math.atan2(y, x), Math.atan2(nextSin, Math.abs(nextCos)), height);
+      if (!Number.isFinite(height)) break;
+      return commit(result, longitude, Math.atan2(nextSin, Math.abs(nextCos)), height);
     }
     cos = nextCos;
     sin = nextSin;
   }
-  return exteriorInverse(x, y, z, p, a, b, result);
+  return interiorInverse(x, y, z, p, a, b, result);
 }
 
-/** Original nearest-normal solve in t = (lambda + b²)/a², avoiding interior cancellation.
+/** Original nearest-normal solve in t = (lambda + b²)/a², avoiding interior cancellation and thin-exterior residual loss.
  * The positive interval selects the globally nearest branch, rather than a stationary normal.
  */
 function interiorInverse(
@@ -90,16 +93,13 @@ function interiorInverse(
   b: number,
   result: SpheroidPoint
 ): boolean {
+  const longitude = Math.atan2(y, x);
   const ratio = b / a,
     ratio2 = ratio * ratio;
   const horizontal = p / a,
     vertical = z / a,
     delta = 1 - ratio2;
   if (!(ratio2 > 0) || ratio > 1) return false;
-  if (z === 0) {
-    if (horizontal < delta) return false;
-    return commit(result, Math.atan2(y, x), 0, p - a);
-  }
   const aa = a * a,
     bb = b * b;
   const ratioError =
@@ -126,21 +126,44 @@ function interiorInverse(
         (2 * p)
       : 0;
   const shift = a * ratio2,
-    base = p - a + shift;
+    distance = p - a,
+    base = distance + shift;
   const correction =
-    radiusError + sumError(p - a, shift, base) + productError(a, ratio2, shift) + a * ratioError;
+    radiusError +
+    sumError(p, -a, distance) +
+    sumError(distance, shift, base) +
+    productError(a, ratio2, shift) +
+    a * ratioError;
+  if (z === 0) {
+    // A rounded hypot can equal the cusp for points just inside it. Include
+    // the radius/axis corrections before selecting a unique equatorial normal.
+    if (base + correction < 0) return false;
+    return commit(result, longitude, 0, distance);
+  }
   const weighted = Math.abs(vertical) * ratio;
-  if (!(weighted > 0)) return false;
   let lower = 0,
-    upper = ratio2;
+    upper = ratio2 + Math.hypot(horizontal, vertical * ratio);
+  if (!Number.isFinite(upper)) return false;
   // A lower bound near the short-axis singularity prevents thousands of bisections
   // for deep, nearly equatorial interiors. No subtraction of lambda and -b².
   let t = Math.max(weighted, horizontal - delta);
   if (!(t > lower && t < upper)) t = upper / 2;
-  for (let i = 0; i < 128; i++) {
+  // Below the cusp, a vanishing polar input can make t subnormal. The
+  // limiting vertical footpoint remains well conditioned. Use it only when
+  // its bound t <= abs(z)*ratio/(a*v) is negligible relative to the cusp gap.
+  const gap = -(base + correction) / a;
+  const limiting = Math.sqrt(gap * (horizontal + delta)) / delta;
+  let latitude: number | undefined =
+    gap > 0 && (Math.abs(z) / limiting / a) * ratio <= EPSILON * gap
+      ? Math.atan2((Math.sign(z) * limiting) / ratio, horizontal / delta)
+      : undefined;
+  for (let i = 0; i < 1024 && latitude === undefined; i++) {
     const equatorial = delta + t;
     const u = horizontal / equatorial,
-      v = weighted / t;
+      // Divide by t first: both z/a and a*t can lose precision in the
+      // subnormal range although the near-cusp latitude is representable.
+      verticalAt = z / t / a,
+      v = verticalAt * ratio;
     const at = a * t,
       difference = base - at;
     const offset =
@@ -148,40 +171,22 @@ function interiorInverse(
       (a * equatorial);
     const term = offset * (u + 1);
     const residual = term + v * v;
-    if (
-      Math.abs(residual) <= 4 * Number.EPSILON * (Math.abs(term) + v * v) ||
-      upper - lower <= 4 * Number.EPSILON * t
-    ) {
-      const latitude = Math.atan2(vertical / t, horizontal / equatorial);
-      const sin = Math.sin(latitude),
-        cos = Math.cos(latitude);
-      return commit(
-        result,
-        Math.atan2(y, x),
-        latitude,
-        p * cos + z * sin - a * Math.hypot(cos, ratio * sin)
-      );
-    }
+    if (!Number.isFinite(residual)) return false;
     if (residual > 0) lower = t;
     else upper = t;
     const derivative = -2 * ((u * u) / equatorial + (v * v) / t);
     const next = t - residual / derivative;
-    const candidate =
-      Number.isFinite(next) && next > lower && next < upper ? next : lower + (upper - lower) / 2;
-    if (candidate === t) {
-      const latitude = Math.atan2(vertical / t, horizontal / equatorial);
-      return commit(
-        result,
-        Math.atan2(y, x),
-        latitude,
-        p * Math.cos(latitude) +
-          z * Math.sin(latitude) -
-          a * Math.hypot(Math.cos(latitude), ratio * Math.sin(latitude))
-      );
+    const candidate = next > lower && next < upper ? next : lower + (upper - lower) / 2;
+    if (
+      Math.abs(residual) <= 4 * EPSILON * (Math.abs(term) + v * v) ||
+      upper - lower <= 4 * EPSILON * t
+    ) {
+      latitude = Math.atan2(verticalAt, u);
+      break;
     }
     t = candidate;
   }
-  return false;
+  return latitude !== undefined && commitNormal(result, longitude, latitude, p, z, a, ratio);
 }
 
 /** Error-free transforms on the finite squared-axis domain used by geometry adapters. */
@@ -200,47 +205,19 @@ function productError(x: number, y: number, product: number): number {
   return hx * hy - product + hx * ly + lx * hy + lx * ly;
 }
 
-/** Original dimensionless Lagrange-multiplier solve, restricted to surface/exterior. */
-function exteriorInverse(
-  x: number,
-  y: number,
-  z: number,
+/** Shared signed distance along the solved surface normal. */
+function commitNormal(
+  result: SpheroidPoint,
+  longitude: number,
+  latitude: number,
   p: number,
+  z: number,
   a: number,
-  b: number,
-  result: SpheroidPoint
+  ratio: number
 ): boolean {
-  const ratio = b / a,
-    ratio2 = ratio * ratio,
-    horizontal = p / a,
-    vertical = z / a;
-  const norm = Math.hypot(horizontal, z / b);
-  if (!Number.isFinite(norm) || norm < 1 - 8 * Number.EPSILON || !(ratio2 > 0)) return false;
-  let lower = 0,
-    upper = Math.hypot(horizontal, vertical * ratio);
-  if (!Number.isFinite(upper)) return false;
-  let multiplier = norm <= 1 + 8 * Number.EPSILON ? 0 : upper / 2;
-  for (let i = 0; i < 96; i++) {
-    const equatorial = 1 + multiplier,
-      polar = ratio2 + multiplier;
-    const u = horizontal / equatorial,
-      v = (vertical * ratio) / polar;
-    const length = Math.hypot(u, v);
-    const residual = length - 1;
-    if (Math.abs(residual) <= 4 * Number.EPSILON) {
-      const latitude = Math.atan2(vertical / polar, horizontal / equatorial);
-      const sin = Math.sin(latitude),
-        cos = Math.cos(latitude);
-      const height = p * cos + z * sin - a * Math.hypot(cos, ratio * sin);
-      return commit(result, Math.atan2(y, x), latitude, height);
-    }
-    if (residual > 0) lower = multiplier;
-    else upper = multiplier;
-    const derivative = -((u * u) / equatorial + (v * v) / polar) / length;
-    const next = multiplier - residual / derivative;
-    multiplier = Number.isFinite(next) && next > lower && next < upper ? next : (lower + upper) / 2;
-  }
-  return false;
+  const sin = Math.sin(latitude),
+    cos = Math.cos(latitude);
+  return commit(result, longitude, latitude, p * cos + z * sin - a * Math.hypot(cos, ratio * sin));
 }
 
 /** Values are captured before invoking application setters; recursive writes are safe. */

package/src/types/bigint.ts

@@ -1,10 +1,28 @@
 // math.gl
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: MIT AND Apache-2.0
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright 2016-2019 The Apache Software Foundation
+// SPDX-FileComment: BigInt availability/fallback structure adapted from Apache Arrow JS util/compat.ts; compared with apache-arrow-4.0.0. See ../../ARROW-NOTICE.txt and ../../APACHE-2.0-LICENSE.txt. Modified to separate availability flags, share errors and narrow exports.
+
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
 
 // BigInt compatibility layer
-// Inspired by ArrowJS (under Apache2 license)
-// https://github.com/apache/arrow/blob/master/js/src/util/compat.ts
+// Source comparison: https://github.com/apache/arrow/blob/apache-arrow-4.0.0/js/src/util/compat.ts
 // Requires tsconfig.json: target=esnext or (lib: esnext.bigint)
 // Requires eslint: env: {es2020: true}
 
@@ -48,7 +66,7 @@ const BigInt64ArrayCtor = (() => {
 })();
 
 const BigUint64ArrayCtor = (() => {
-  return BigUint64ArrayAvailable ? [BigUint64Array] : [BigInt64ArrayUnavailable];
+  return BigUint64ArrayAvailable ? BigUint64Array : BigInt64ArrayUnavailable;
 })();
 
 export {BigIntCtor as BigInt};

package/src/types/bounds-types.ts

@@ -15,7 +15,7 @@ export type Bounds =
 
 /** Checks if a `Bounds` is a `Bounds2D` */
 export function isBounds2D(bounds: Bounds): bounds is Bounds2D {
-  return bounds.length === 2;
+  return bounds.length === 2 && bounds[0].length === 2 && bounds[1].length === 2;
 }
 
 /** Accepts 2D and 3D bounds and returns a 2D bound, truncating 3D dimension if necessary */