@math.gl/geospatial 5.0.0-alpha.18 → 5.0.0-alpha.19

package/src/projection/experimental/kernels/poly.ts

@@ -0,0 +1,156 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {
+  temp: number;
+  e0: number;
+  e1: number;
+  e2: number;
+  e3: number;
+  ml0: number;
+};
+import e0fn from '../common/e0fn';
+import e1fn from '../common/e1fn';
+import e2fn from '../common/e2fn';
+import e3fn from '../common/e3fn';
+import adjust_lon from '../common/adjust_lon';
+import adjust_lat from '../common/adjust_lat';
+import mlfn from '../common/mlfn';
+import {EPSLN} from '../common/constants';
+
+import gN from '../common/gN';
+
+var MAX_ITER = 20;
+
+function initialize(state: State): void {
+  /* Place parameters in static storage for common use
+      ------------------------------------------------- */
+  state.temp = state.b / state.a;
+  state.es = 1 - Math.pow(state.temp, 2); // devait etre dans tmerc.js mais n y est pas donc je commente sinon retour de valeurs nulles
+  state.e = Math.sqrt(state.es);
+  state.e0 = e0fn(state.es);
+  state.e1 = e1fn(state.es);
+  state.e2 = e2fn(state.es);
+  state.e3 = e3fn(state.es);
+  state.ml0 = state.a * mlfn(state.e0, state.e1, state.e2, state.e3, state.lat0); // si que des zeros le calcul ne se fait pas
+}
+
+/* Polyconic forward equations--mapping lat,long to x,y
+    --------------------------------------------------- */
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var lon = p.x;
+  var lat = p.y;
+  var x, y, el;
+  var dlon = adjust_lon(lon - state.long0, state.over);
+  el = dlon * Math.sin(lat);
+  if (state.sphere) {
+    if (Math.abs(lat) <= EPSLN) {
+      x = state.a * dlon;
+      y = -1 * state.a * state.lat0;
+    } else {
+      x = (state.a * Math.sin(el)) / Math.tan(lat);
+      y = state.a * (adjust_lat(lat - state.lat0) + (1 - Math.cos(el)) / Math.tan(lat));
+    }
+  } else {
+    if (Math.abs(lat) <= EPSLN) {
+      x = state.a * dlon;
+      y = -1 * state.ml0;
+    } else {
+      var nl = gN(state.a, state.e, Math.sin(lat)) / Math.tan(lat);
+      x = nl * Math.sin(el);
+      y =
+        state.a * mlfn(state.e0, state.e1, state.e2, state.e3, lat) -
+        state.ml0 +
+        nl * (1 - Math.cos(el));
+    }
+  }
+  p.x = x + state.x0;
+  p.y = y + state.y0;
+  return p;
+}
+
+/* Inverse equations
+  ----------------- */
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var lon, lat, x, y, i;
+  var al, bl;
+  var phi, dphi;
+  x = p.x - state.x0;
+  y = p.y - state.y0;
+
+  if (state.sphere) {
+    if (Math.abs(y + state.a * state.lat0) <= EPSLN) {
+      lon = adjust_lon(x / state.a + state.long0, state.over);
+      lat = 0;
+    } else {
+      al = state.lat0 + y / state.a;
+      bl = (x * x) / state.a / state.a + al * al;
+      phi = al;
+      var tanphi;
+      for (i = MAX_ITER; i; --i) {
+        tanphi = Math.tan(phi);
+        dphi =
+          (-1 * (al * (phi * tanphi + 1) - phi - 0.5 * (phi * phi + bl) * tanphi)) /
+          ((phi - al) / tanphi - 1);
+        phi += dphi;
+        if (Math.abs(dphi) <= EPSLN) {
+          lat = phi;
+          break;
+        }
+      }
+      lon = adjust_lon(
+        state.long0 + Math.asin((x * Math.tan(phi)) / state.a) / Math.sin(lat),
+        state.over
+      );
+    }
+  } else {
+    if (Math.abs(y + state.ml0) <= EPSLN) {
+      lat = 0;
+      lon = adjust_lon(state.long0 + x / state.a, state.over);
+    } else {
+      al = (state.ml0 + y) / state.a;
+      bl = (x * x) / state.a / state.a + al * al;
+      phi = al;
+      var cl, mln, mlnp, ma;
+      var con;
+      for (i = MAX_ITER; i; --i) {
+        con = state.e * Math.sin(phi);
+        cl = Math.sqrt(1 - con * con) * Math.tan(phi);
+        mln = state.a * mlfn(state.e0, state.e1, state.e2, state.e3, phi);
+        mlnp =
+          state.e0 -
+          2 * state.e1 * Math.cos(2 * phi) +
+          4 * state.e2 * Math.cos(4 * phi) -
+          6 * state.e3 * Math.cos(6 * phi);
+        ma = mln / state.a;
+        dphi =
+          (al * (cl * ma + 1) - ma - 0.5 * cl * (ma * ma + bl)) /
+          ((state.es * Math.sin(2 * phi) * (ma * ma + bl - 2 * al * ma)) / (4 * cl) +
+            (al - ma) * (cl * mlnp - 2 / Math.sin(2 * phi)) -
+            mlnp);
+        phi -= dphi;
+        if (Math.abs(dphi) <= EPSLN) {
+          lat = phi;
+          break;
+        }
+      }
+
+      // lat=phi4z(state.e,state.e0,state.e1,state.e2,state.e3,al,bl,0,0);
+      cl = Math.sqrt(1 - state.es * Math.pow(Math.sin(lat), 2)) * Math.tan(lat);
+      lon = adjust_lon(state.long0 + Math.asin((x * cl) / state.a) / Math.sin(lat), state.over);
+    }
+  }
+
+  p.x = lon;
+  p.y = lat;
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {...base, temp: 0, e0: 0, e1: 0, e2: 0, e3: 0, ml0: 0, ...options};
+  initialize(state);
+  return state;
+}

package/src/projection/experimental/kernels/qsc.ts

@@ -0,0 +1,369 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0, modified to reuse the caller-owned point and represent area/temporary coordinates as local numbers. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {
+  face: number;
+  one_minus_f: number;
+  one_minus_f_squared: number;
+};
+// QSC projection rewritten from the original PROJ4
+// https://github.com/OSGeo/proj.4/blob/master/src/PJ_qsc.c
+
+import {EPSLN, TWO_PI, SPI, HALF_PI, FORTPI} from '../common/constants';
+
+/* constants */
+var FACE_ENUM = {
+  FRONT: 1,
+  RIGHT: 2,
+  BACK: 3,
+  LEFT: 4,
+  TOP: 5,
+  BOTTOM: 6
+};
+
+var AREA_ENUM = {
+  AREA_0: 1,
+  AREA_1: 2,
+  AREA_2: 3,
+  AREA_3: 4
+};
+
+function initialize(state: State): void {
+  state.x0 = state.x0 || 0;
+  state.y0 = state.y0 || 0;
+  state.lat0 = state.lat0 || 0;
+  state.long0 = state.long0 || 0;
+  state.lat_ts = state.lat_ts || 0;
+
+  /* Determine the cube face from the center of projection. */
+  if (state.lat0 >= HALF_PI - FORTPI / 2.0) {
+    state.face = FACE_ENUM.TOP;
+  } else if (state.lat0 <= -(HALF_PI - FORTPI / 2.0)) {
+    state.face = FACE_ENUM.BOTTOM;
+  } else if (Math.abs(state.long0) <= FORTPI) {
+    state.face = FACE_ENUM.FRONT;
+  } else if (Math.abs(state.long0) <= HALF_PI + FORTPI) {
+    state.face = state.long0 > 0.0 ? FACE_ENUM.RIGHT : FACE_ENUM.LEFT;
+  } else {
+    state.face = FACE_ENUM.BACK;
+  }
+
+  /* Fill in useful values for the ellipsoid <-> sphere shift
+   * described in [LK12]. */
+  if (state.es !== 0) {
+    state.one_minus_f = 1 - (state.a - state.b) / state.a;
+    state.one_minus_f_squared = state.one_minus_f * state.one_minus_f;
+  }
+}
+
+// QSC forward equations--mapping lat,long to x,y
+// -----------------------------------------------------------------
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var xy = p;
+  var lat, lon;
+  var theta, phi;
+  var t, mu;
+  /* nu; */
+  var area = 0;
+
+  // move lon according to projection's lon
+  p.x -= state.long0;
+
+  /* Convert the geodetic latitude to a geocentric latitude.
+   * This corresponds to the shift from the ellipsoid to the sphere
+   * described in [LK12]. */
+  if (state.es !== 0) {
+    // if (P->es != 0) {
+    lat = Math.atan(state.one_minus_f_squared * Math.tan(p.y));
+  } else {
+    lat = p.y;
+  }
+
+  /* Convert the input lat, lon into theta, phi as used by QSC.
+   * This depends on the cube face and the area on it.
+   * For the top and bottom face, we can compute theta and phi
+   * directly from phi, lam. For the other faces, we must use
+   * unit sphere cartesian coordinates as an intermediate step. */
+  lon = p.x; // lon = lam;
+  if (state.face === FACE_ENUM.TOP) {
+    phi = HALF_PI - lat;
+    if (lon >= FORTPI && lon <= HALF_PI + FORTPI) {
+      area = AREA_ENUM.AREA_0;
+      theta = lon - HALF_PI;
+    } else if (lon > HALF_PI + FORTPI || lon <= -(HALF_PI + FORTPI)) {
+      area = AREA_ENUM.AREA_1;
+      theta = lon > 0.0 ? lon - SPI : lon + SPI;
+    } else if (lon > -(HALF_PI + FORTPI) && lon <= -FORTPI) {
+      area = AREA_ENUM.AREA_2;
+      theta = lon + HALF_PI;
+    } else {
+      area = AREA_ENUM.AREA_3;
+      theta = lon;
+    }
+  } else if (state.face === FACE_ENUM.BOTTOM) {
+    phi = HALF_PI + lat;
+    if (lon >= FORTPI && lon <= HALF_PI + FORTPI) {
+      area = AREA_ENUM.AREA_0;
+      theta = -lon + HALF_PI;
+    } else if (lon < FORTPI && lon >= -FORTPI) {
+      area = AREA_ENUM.AREA_1;
+      theta = -lon;
+    } else if (lon < -FORTPI && lon >= -(HALF_PI + FORTPI)) {
+      area = AREA_ENUM.AREA_2;
+      theta = -lon - HALF_PI;
+    } else {
+      area = AREA_ENUM.AREA_3;
+      theta = lon > 0.0 ? -lon + SPI : -lon - SPI;
+    }
+  } else {
+    var q, r, s;
+    var sinlat, coslat;
+    var sinlon, coslon;
+
+    if (state.face === FACE_ENUM.RIGHT) {
+      lon = qsc_shift_lon_origin(lon, +HALF_PI);
+    } else if (state.face === FACE_ENUM.BACK) {
+      lon = qsc_shift_lon_origin(lon, +SPI);
+    } else if (state.face === FACE_ENUM.LEFT) {
+      lon = qsc_shift_lon_origin(lon, -HALF_PI);
+    }
+    sinlat = Math.sin(lat);
+    coslat = Math.cos(lat);
+    sinlon = Math.sin(lon);
+    coslon = Math.cos(lon);
+    q = coslat * coslon;
+    r = coslat * sinlon;
+    s = sinlat;
+
+    if (state.face === FACE_ENUM.FRONT) {
+      phi = Math.acos(q);
+      theta = qsc_fwd_equat_face_theta(phi, s, r);
+    } else if (state.face === FACE_ENUM.RIGHT) {
+      phi = Math.acos(r);
+      theta = qsc_fwd_equat_face_theta(phi, s, -q);
+    } else if (state.face === FACE_ENUM.BACK) {
+      phi = Math.acos(-q);
+      theta = qsc_fwd_equat_face_theta(phi, s, -r);
+    } else if (state.face === FACE_ENUM.LEFT) {
+      phi = Math.acos(-r);
+      theta = qsc_fwd_equat_face_theta(phi, s, q);
+    } else {
+      /* Impossible */
+      phi = theta = 0;
+    }
+    if (Math.abs(theta) <= FORTPI) {
+      area = AREA_ENUM.AREA_0;
+    } else if (theta > FORTPI && theta <= HALF_PI + FORTPI) {
+      area = AREA_ENUM.AREA_1;
+      theta -= HALF_PI;
+    } else if (theta > HALF_PI + FORTPI || theta <= -(HALF_PI + FORTPI)) {
+      area = AREA_ENUM.AREA_2;
+      theta = theta >= 0.0 ? theta - SPI : theta + SPI;
+    } else {
+      area = AREA_ENUM.AREA_3;
+      theta += HALF_PI;
+    }
+  }
+
+  /* Compute mu and nu for the area of definition.
+   * For mu, see Eq. (3-21) in [OL76], but note the typos:
+   * compare with Eq. (3-14). For nu, see Eq. (3-38). */
+  mu = Math.atan((12 / SPI) * (theta + Math.acos(Math.sin(theta) * Math.cos(FORTPI)) - HALF_PI));
+  t = Math.sqrt(
+    (1 - Math.cos(phi)) /
+      (Math.cos(mu) * Math.cos(mu)) /
+      (1 - Math.cos(Math.atan(1 / Math.cos(theta))))
+  );
+
+  /* Apply the result to the real area. */
+  if (area === AREA_ENUM.AREA_1) {
+    mu += HALF_PI;
+  } else if (area === AREA_ENUM.AREA_2) {
+    mu += SPI;
+  } else if (area === AREA_ENUM.AREA_3) {
+    mu += 1.5 * SPI;
+  }
+
+  /* Now compute x, y from mu and nu */
+  xy.x = t * Math.cos(mu);
+  xy.y = t * Math.sin(mu);
+  xy.x = xy.x * state.a + state.x0;
+  xy.y = xy.y * state.a + state.y0;
+
+  return p;
+}
+
+// QSC inverse equations--mapping x,y to lat/long
+// -----------------------------------------------------------------
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var lam = 0,
+    latitude = 0;
+  var mu, nu, cosmu, tannu;
+  var tantheta, theta, cosphi, phi;
+  var t;
+  var area = 0;
+
+  /* de-offset */
+  p.x = (p.x - state.x0) / state.a;
+  p.y = (p.y - state.y0) / state.a;
+
+  /* Convert the input x, y to the mu and nu angles as used by QSC.
+   * This depends on the area of the cube face. */
+  nu = Math.atan(Math.sqrt(p.x * p.x + p.y * p.y));
+  mu = Math.atan2(p.y, p.x);
+  if (p.x >= 0.0 && p.x >= Math.abs(p.y)) {
+    area = AREA_ENUM.AREA_0;
+  } else if (p.y >= 0.0 && p.y >= Math.abs(p.x)) {
+    area = AREA_ENUM.AREA_1;
+    mu -= HALF_PI;
+  } else if (p.x < 0.0 && -p.x >= Math.abs(p.y)) {
+    area = AREA_ENUM.AREA_2;
+    mu = mu < 0.0 ? mu + SPI : mu - SPI;
+  } else {
+    area = AREA_ENUM.AREA_3;
+    mu += HALF_PI;
+  }
+
+  /* Compute phi and theta for the area of definition.
+   * The inverse projection is not described in the original paper, but some
+   * good hints can be found here (as of 2011-12-14):
+   * http://fits.gsfc.nasa.gov/fitsbits/saf.93/saf.9302
+   * (search for "Message-Id: <9302181759.AA25477 at fits.cv.nrao.edu>") */
+  t = (SPI / 12) * Math.tan(mu);
+  tantheta = Math.sin(t) / (Math.cos(t) - 1 / Math.sqrt(2));
+  theta = Math.atan(tantheta);
+  cosmu = Math.cos(mu);
+  tannu = Math.tan(nu);
+  cosphi = 1 - cosmu * cosmu * tannu * tannu * (1 - Math.cos(Math.atan(1 / Math.cos(theta))));
+  if (cosphi < -1) {
+    cosphi = -1;
+  } else if (cosphi > +1) {
+    cosphi = +1;
+  }
+
+  /* Apply the result to the real area on the cube face.
+   * For the top and bottom face, we can compute phi and lam directly.
+   * For the other faces, we must use unit sphere cartesian coordinates
+   * as an intermediate step. */
+  if (state.face === FACE_ENUM.TOP) {
+    phi = Math.acos(cosphi);
+    latitude = HALF_PI - phi;
+    if (area === AREA_ENUM.AREA_0) {
+      lam = theta + HALF_PI;
+    } else if (area === AREA_ENUM.AREA_1) {
+      lam = theta < 0.0 ? theta + SPI : theta - SPI;
+    } else if (area === AREA_ENUM.AREA_2) {
+      lam = theta - HALF_PI;
+    } /* area == AREA_ENUM.AREA_3 */ else {
+      lam = theta;
+    }
+  } else if (state.face === FACE_ENUM.BOTTOM) {
+    phi = Math.acos(cosphi);
+    latitude = phi - HALF_PI;
+    if (area === AREA_ENUM.AREA_0) {
+      lam = -theta + HALF_PI;
+    } else if (area === AREA_ENUM.AREA_1) {
+      lam = -theta;
+    } else if (area === AREA_ENUM.AREA_2) {
+      lam = -theta - HALF_PI;
+    } /* area == AREA_ENUM.AREA_3 */ else {
+      lam = theta < 0.0 ? -theta - SPI : -theta + SPI;
+    }
+  } else {
+    /* Compute phi and lam via cartesian unit sphere coordinates. */
+    var q, r, s;
+    q = cosphi;
+    t = q * q;
+    if (t >= 1) {
+      s = 0;
+    } else {
+      s = Math.sqrt(1 - t) * Math.sin(theta);
+    }
+    t += s * s;
+    if (t >= 1) {
+      r = 0;
+    } else {
+      r = Math.sqrt(1 - t);
+    }
+    /* Rotate q,r,s into the correct area. */
+    if (area === AREA_ENUM.AREA_1) {
+      t = r;
+      r = -s;
+      s = t;
+    } else if (area === AREA_ENUM.AREA_2) {
+      r = -r;
+      s = -s;
+    } else if (area === AREA_ENUM.AREA_3) {
+      t = r;
+      r = s;
+      s = -t;
+    }
+    /* Rotate q,r,s into the correct cube face. */
+    if (state.face === FACE_ENUM.RIGHT) {
+      t = q;
+      q = -r;
+      r = t;
+    } else if (state.face === FACE_ENUM.BACK) {
+      q = -q;
+      r = -r;
+    } else if (state.face === FACE_ENUM.LEFT) {
+      t = q;
+      q = r;
+      r = -t;
+    }
+    /* Now compute phi and lam from the unit sphere coordinates. */
+    latitude = Math.acos(-s) - HALF_PI;
+    lam = Math.atan2(r, q);
+    if (state.face === FACE_ENUM.RIGHT) {
+      lam = qsc_shift_lon_origin(lam, -HALF_PI);
+    } else if (state.face === FACE_ENUM.BACK) {
+      lam = qsc_shift_lon_origin(lam, -SPI);
+    } else if (state.face === FACE_ENUM.LEFT) {
+      lam = qsc_shift_lon_origin(lam, +HALF_PI);
+    }
+  }
+
+  /* Apply the shift from the sphere to the ellipsoid as described
+   * in [LK12]. */
+  if (state.es !== 0) {
+    var invert_sign;
+    var tanphi, xa;
+    invert_sign = latitude < 0 ? 1 : 0;
+    tanphi = Math.tan(latitude);
+    xa = state.b / Math.sqrt(tanphi * tanphi + state.one_minus_f_squared);
+    latitude = Math.atan(Math.sqrt(state.a * state.a - xa * xa) / (state.one_minus_f * xa));
+    if (invert_sign) {
+      latitude = -latitude;
+    }
+  }
+
+  lam += state.long0;
+  p.x = lam;
+  p.y = latitude;
+  return p;
+}
+
+/* Equatorial-face theta before scalar area selection in forward. */
+function qsc_fwd_equat_face_theta(phi: number, y: number, x: number): number {
+  return phi < EPSLN ? 0.0 : Math.atan2(y, x);
+}
+
+/* Helper function: shift the longitude. */
+function qsc_shift_lon_origin(lon: number, offset: number) {
+  var slon = lon + offset;
+  if (slon < -SPI) {
+    slon += TWO_PI;
+  } else if (slon > +SPI) {
+    slon -= TWO_PI;
+  }
+  return slon;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {...base, face: 0, one_minus_f: 0, one_minus_f_squared: 0, ...options};
+  initialize(state);
+  return state;
+}

package/src/projection/experimental/kernels/robin.ts

@@ -0,0 +1,189 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0, modified to reuse the input point and avoid per-coordinate result objects and Newton callbacks. See ../../../PROJ4-LICENSE.md for the upstream license and attribution. Table precision and interval selection follow PROJ 9.5.1 robin.cpp. See ../../../PROJ-LICENSE.txt for PROJ attribution.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {};
+// Robinson projection
+// Based on https://github.com/OSGeo/proj.4/blob/master/src/PJ_robin.c
+// Polynomial coeficients from http://article.gmane.org/gmane.comp.gis.proj-4.devel/6039
+
+import {HALF_PI, D2R, R2D, EPSLN} from '../common/constants';
+import adjust_lon from '../common/adjust_lon';
+
+var COEFS_X = [
+  [1.0, 2.2199e-17, -7.15515e-5, 3.1103e-6],
+  [0.9986, -0.000482243, -2.4897e-5, -1.3309e-6],
+  [0.9954, -0.00083103, -4.48605e-5, -9.86701e-7],
+  [0.99, -0.00135364, -5.9661e-5, 3.6777e-6],
+  [0.9822, -0.00167442, -4.49547e-6, -5.72411e-6],
+  [0.973, -0.00214868, -9.03571e-5, 1.8736e-8],
+  [0.96, -0.00305085, -9.00761e-5, 1.64917e-6],
+  [0.9427, -0.00382792, -6.53386e-5, -2.6154e-6],
+  [0.9216, -0.00467746, -0.00010457, 4.81243e-6],
+  [0.8962, -0.00536223, -3.23831e-5, -5.43432e-6],
+  [0.8679, -0.00609363, -0.000113898, 3.32484e-6],
+  [0.835, -0.00698325, -6.40253e-5, 9.34959e-7],
+  [0.7986, -0.00755338, -5.00009e-5, 9.35324e-7],
+  [0.7597, -0.00798324, -3.5971e-5, -2.27626e-6],
+  [0.7186, -0.00851367, -7.01149e-5, -8.6303e-6],
+  [0.6732, -0.00986209, -0.000199569, 1.91974e-5],
+  [0.6213, -0.010418, 8.83923e-5, 6.24051e-6],
+  [0.5722, -0.00906601, 0.000182, 6.24051e-6],
+  [0.5322, -0.00677797, 0.000275608, 6.24051e-6]
+];
+
+var COEFS_Y = [
+  [-5.20417e-18, 0.0124, 1.21431e-18, -8.45284e-11],
+  [0.062, 0.0124, -1.26793e-9, 4.22642e-10],
+  [0.124, 0.0124, 5.07171e-9, -1.60604e-9],
+  [0.186, 0.0123999, -1.90189e-8, 6.00152e-9],
+  [0.248, 0.0124002, 7.10039e-8, -2.24e-8],
+  [0.31, 0.0123992, -2.64997e-7, 8.35986e-8],
+  [0.372, 0.0124029, 9.88983e-7, -3.11994e-7],
+  [0.434, 0.0123893, -3.69093e-6, -4.35621e-7],
+  [0.4958, 0.0123198, -1.02252e-5, -3.45523e-7],
+  [0.5571, 0.0121916, -1.54081e-5, -5.82288e-7],
+  [0.6176, 0.0119938, -2.41424e-5, -5.25327e-7],
+  [0.6769, 0.011713, -3.20223e-5, -5.16405e-7],
+  [0.7346, 0.0113541, -3.97684e-5, -6.09052e-7],
+  [0.7903, 0.0109107, -4.89042e-5, -1.04739e-6],
+  [0.8435, 0.0103431, -6.4615e-5, -1.40374e-9],
+  [0.8936, 0.00969686, -6.4636e-5, -8.547e-6],
+  [0.9394, 0.00840947, -0.000192841, -4.2106e-6],
+  [0.9761, 0.00616527, -0.000256, -4.2106e-6],
+  [1.0, 0.00328947, -0.000319159, -4.2106e-6]
+];
+
+// PROJ defines the published polynomial coefficients as float constants. Preserve
+// those values instead of silently changing the interpolation table to doubles.
+COEFS_X = COEFS_X.map(row => row.map(Math.fround));
+COEFS_Y = COEFS_Y.map(row => row.map(Math.fround));
+
+var FXC = 0.8487;
+var FYC = 1.3523;
+var C1 = R2D / 5; // rad to 5-degree interval
+var RC1 = 1 / C1;
+var NODES = 18;
+
+var poly3_val = function (coefs: readonly number[], x: number) {
+  return coefs[0] + x * (coefs[1] + x * (coefs[2] + x * coefs[3]));
+};
+
+var poly3_der = function (coefs: readonly number[], x: number) {
+  return coefs[1] + x * (2 * coefs[2] + x * 3 * coefs[3]);
+};
+
+function newton_rapshon(
+  coefs: readonly number[],
+  target: number,
+  start: number,
+  max_err: number,
+  iters: number
+) {
+  var x = start;
+  for (; iters; --iters) {
+    var upd = (poly3_val(coefs, x) - target) / poly3_der(coefs, x);
+    x -= upd;
+    if (Math.abs(upd) < max_err) {
+      break;
+    }
+  }
+  return x;
+}
+
+function initialize(state: State): void {
+  state.x0 = state.x0 || 0;
+  state.y0 = state.y0 || 0;
+  state.long0 = state.long0 || 0;
+  state.es = 0;
+}
+
+export function forward(state: State, ll: Point): Point | null | undefined | number {
+  var lon = adjust_lon(ll.x - state.long0, state.over);
+
+  var dphi = Math.abs(ll.y);
+  var i = Math.floor(dphi * C1 + 1e-15);
+  if (i < 0) {
+    i = 0;
+  } else if (i >= NODES) {
+    // The final table row represents the exact pole, as in PROJ.
+    i = NODES;
+  }
+  dphi = R2D * (dphi - RC1 * i);
+  var x = poly3_val(COEFS_X[i], dphi) * lon;
+  var y = poly3_val(COEFS_Y[i], dphi);
+  if (ll.y < 0) {
+    y = -y;
+  }
+
+  ll.x = x * state.a * FXC + state.x0;
+  ll.y = y * state.a * FYC + state.y0;
+
+  return ll;
+}
+
+export function inverse(state: State, xy: Point): Point | null | undefined | number {
+  var originalY = xy.y;
+  var ll = xy;
+  ll.x = (ll.x - state.x0) / (state.a * FXC);
+  ll.y = Math.abs(originalY - state.y0) / (state.a * FYC);
+
+  // Polynomial pieces have small discontinuities at table knots. Roundoff in
+  // de-scaling must not select a neighbouring piece for an exact knot output.
+  for (let knot = 0; knot <= NODES; knot++) {
+    if (Math.abs(ll.y - COEFS_Y[knot][0]) <= 8 * Number.EPSILON) {
+      ll.x = adjust_lon(ll.x / COEFS_X[knot][0] + state.long0, state.over);
+      ll.y = (originalY < state.y0 ? -1 : 1) * knot * 5 * D2R;
+      return ll;
+    }
+  }
+  if (ll.y >= 1) {
+    // pathologic case
+    ll.x /= COEFS_X[NODES][0];
+    ll.y = originalY < 0 ? -HALF_PI : HALF_PI;
+  } else {
+    // find table interval
+    var i = Math.floor(ll.y * NODES);
+    if (i < 0) {
+      i = 0;
+    } else if (i >= NODES) {
+      i = NODES - 1;
+    }
+    for (;;) {
+      if (COEFS_Y[i][0] > ll.y) {
+        --i;
+      } else if (COEFS_Y[i + 1][0] <= ll.y) {
+        ++i;
+      } else {
+        break;
+      }
+    }
+    // linear interpolation in 5 degree interval
+    var coefs = COEFS_Y[i];
+    var t = (5 * (ll.y - coefs[0])) / (COEFS_Y[i + 1][0] - coefs[0]);
+    // find t so that poly3_val(coefs, t) = ll.y
+    t = newton_rapshon(coefs, ll.y, t, EPSLN, 100);
+
+    ll.x /= poly3_val(COEFS_X[i], t);
+    ll.y = (5 * i + t) * D2R;
+    if (originalY < 0) {
+      ll.y = -ll.y;
+    }
+  }
+
+  ll.x = adjust_lon(ll.x + state.long0, state.over);
+
+  return ll;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {
+    ...base,
+
+    ...options
+  };
+  initialize(state);
+  return state;
+}