@math.gl/geospatial 5.0.0-alpha.9 → 5.0.0-beta.2

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

@@ -0,0 +1,140 @@
+// 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 ../../../../projection/PROJ4-LICENSE.md for the upstream license and attribution. Corrected series signs and inverse refinement informed by PROJ 9.5.1 cass.cpp. See ../../../../projection/PROJ-LICENSE.txt. Newton solver implementation is original math.gl code.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {
+  en: number[];
+  scratch: Point;
+  ml0: number;
+};
+import pj_enfn from '../common/pj_enfn';
+import pj_mlfn from '../common/pj_mlfn';
+import pj_inv_mlfn from '../common/pj_inv_mlfn';
+import gN from '../common/gN';
+import adjust_lon from '../common/adjust_lon';
+import adjust_lat from '../common/adjust_lat';
+import {HALF_PI, EPSLN} from '../common/constants';
+
+function initialize(state: State): void {
+  if (!state.sphere) {
+    state.en = pj_enfn(state.es);
+    state.ml0 = state.a * pj_mlfn(state.lat0, Math.sin(state.lat0), Math.cos(state.lat0), state.en);
+  }
+}
+
+/* Cassini forward equations--mapping lat,long to x,y
+  ----------------------------------------------------------------------- */
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  /* Forward equations
+      ----------------- */
+  var x, y;
+  var lam = p.x;
+  var phi = p.y;
+  lam = adjust_lon(lam - state.long0, state.over);
+
+  if (state.sphere) {
+    x = state.a * Math.asin(Math.cos(phi) * Math.sin(lam));
+    y = state.a * (Math.atan2(Math.tan(phi), Math.cos(lam)) - state.lat0);
+  } else {
+    // ellipsoid
+    var sinphi = Math.sin(phi);
+    var cosphi = Math.cos(phi);
+    var nl = gN(state.a, state.e, sinphi);
+    var tl = Math.tan(phi) * Math.tan(phi);
+    var al = lam * Math.cos(phi);
+    var asq = al * al;
+    var cl = (state.es * cosphi * cosphi) / (1 - state.es);
+    var ml = state.a * pj_mlfn(phi, sinphi, cosphi, state.en);
+
+    x = nl * al * (1 - asq * tl * (1 / 6 + ((8 - tl + 8 * cl) * asq) / 120));
+    y = ml - state.ml0 + ((nl * sinphi) / cosphi) * asq * (0.5 + ((5 - tl + 6 * cl) * asq) / 24);
+  }
+
+  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 {
+  p.x -= state.x0;
+  p.y -= state.y0;
+  var x = p.x / state.a;
+  var y = p.y / state.a;
+  var phi, lam;
+
+  if (state.sphere) {
+    var dd = y + state.lat0;
+    phi = Math.asin(Math.sin(dd) * Math.cos(x));
+    lam = Math.atan2(Math.tan(x), Math.cos(dd));
+  } else {
+    /* ellipsoid */
+    var ml1 = state.ml0 / state.a + y;
+    var phi1 = pj_inv_mlfn(ml1, state.es, state.en);
+    if (Math.abs(Math.abs(phi1) - HALF_PI) <= EPSLN) {
+      p.x = state.long0;
+      p.y = Math.sign(phi1) * HALF_PI;
+      return p;
+    }
+    var nl1 = gN(state.a, state.e, Math.sin(phi1));
+
+    var rl1 = ((nl1 * nl1 * nl1) / state.a / state.a) * (1 - state.es);
+    var tl1 = Math.pow(Math.tan(phi1), 2);
+    var dl = (x * state.a) / nl1;
+    var dsq = dl * dl;
+    phi = phi1 - ((nl1 * Math.tan(phi1)) / rl1) * dl * dl * (0.5 - ((1 + 3 * tl1) * dl * dl) / 24);
+    lam = (dl * (1 - dsq * (tl1 / 3 - ((1 + 3 * tl1) * tl1 * dsq) / 15))) / Math.cos(phi1);
+  }
+
+  if (!state.sphere) {
+    // Invert the actual forward series rather than accepting the truncated inverse.
+    // Reuse instance scratch storage, including for typed-array batches.
+    const targetX = p.x + state.x0,
+      targetY = p.y + state.y0;
+    const q = state.scratch;
+    let converged = false;
+    for (let iteration = 0; iteration < 12; iteration++) {
+      evaluate(state, lam, phi);
+      const rx = q.x - targetX,
+        ry = q.y - targetY;
+      if (Math.max(Math.abs(rx), Math.abs(ry)) < 1e-7) {
+        converged = true;
+        break;
+      }
+      const h = 1e-7,
+        stepPhi = phi > HALF_PI - h ? -h : h;
+      const x0 = q.x,
+        y0 = q.y;
+      evaluate(state, lam + h, phi);
+      const a = (q.x - x0) / h,
+        c = (q.y - y0) / h;
+      evaluate(state, lam, phi + stepPhi);
+      const b = (q.x - x0) / stepPhi,
+        d = (q.y - y0) / stepPhi;
+      const determinant = a * d - b * c;
+      if (!Number.isFinite(determinant) || Math.abs(determinant) < 1e-12) break;
+      lam -= (d * rx - b * ry) / determinant;
+      phi -= (a * ry - c * rx) / determinant;
+      if (!Number.isFinite(lam) || Math.abs(phi) > HALF_PI) break;
+    }
+    if (!converged) throw new Error('Cassini inverse did not converge');
+  }
+  p.x = adjust_lon(lam + state.long0, state.over);
+  p.y = adjust_lat(phi);
+  return p;
+}
+
+function evaluate(state: State, longitude: number, latitude: number): void {
+  state.scratch.x = longitude + state.long0;
+  state.scratch.y = latitude;
+  forward(state, state.scratch);
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {...base, en: [], scratch: {x: 0, y: 0}, ml0: 0, ...options};
+  initialize(state);
+  return state;
+}

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

@@ -0,0 +1,71 @@
+// 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 ../../../../projection/PROJ4-LICENSE.md for the upstream license and attribution.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {};
+import adjust_lon from '../common/adjust_lon';
+import qsfnz from '../common/qsfnz';
+import msfnz from '../common/msfnz';
+import iqsfnz from '../common/iqsfnz';
+
+function initialize(state: State): void {
+  // no-op
+  if (!state.sphere) {
+    state.k0 = msfnz(state.e, Math.sin(state.lat_ts), Math.cos(state.lat_ts));
+  }
+}
+
+/* Cylindrical Equal Area 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;
+  /* Forward equations
+      ----------------- */
+  var dlon = adjust_lon(lon - state.long0, state.over);
+  if (state.sphere) {
+    x = state.x0 + state.a * dlon * Math.cos(state.lat_ts);
+    y = state.y0 + (state.a * Math.sin(lat)) / Math.cos(state.lat_ts);
+  } else {
+    var qs = qsfnz(state.e, Math.sin(lat));
+    x = state.x0 + state.a * state.k0 * dlon;
+    y = state.y0 + (state.a * qs * 0.5) / state.k0;
+  }
+
+  p.x = x;
+  p.y = y;
+  return p;
+}
+
+/* Cylindrical Equal Area inverse equations--mapping x,y to lat/long
+    ------------------------------------------------------------ */
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  p.x -= state.x0;
+  p.y -= state.y0;
+  var lon, lat;
+
+  if (state.sphere) {
+    lon = adjust_lon(state.long0 + p.x / state.a / Math.cos(state.lat_ts), state.over);
+    lat = Math.asin((p.y / state.a) * Math.cos(state.lat_ts));
+  } else {
+    lat = iqsfnz(state.e, (2 * p.y * state.k0) / state.a);
+    lon = adjust_lon(state.long0 + p.x / (state.a * state.k0), state.over);
+  }
+
+  p.x = lon;
+  p.y = lat;
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {
+    ...base,
+
+    ...options
+  };
+  initialize(state);
+  return state;
+}

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

@@ -0,0 +1,36 @@
+// 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 ../../../../projection/PROJ4-LICENSE.md for the upstream license and attribution.
+
+import type {KernelParameters} from '../kernel';
+export type State = KernelParameters & {
+  m: number;
+  n: number;
+  C_y: number;
+  C_x: number;
+  en: number[];
+};
+import {forward as sinuForward, inverse as sinuInverse} from './sinu';
+
+function initialize(state: State): void {
+  /* Force spherical handling */
+  state.sphere = true;
+  state.b = state.a;
+
+  state.m = 1.0;
+  state.n = 2.570796326794896619231321691; /* 1 + π/2 */
+  state.es = 0;
+
+  state.C_y = Math.sqrt((state.m + 1.0) / state.n);
+  state.C_x = state.C_y / (state.m + 1.0);
+}
+
+export var forward = sinuForward;
+export var inverse = sinuInverse;
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {...base, m: 0, n: 0, C_y: 0, C_x: 0, en: [], ...options};
+  initialize(state);
+  return state;
+}

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

@@ -0,0 +1,137 @@
+// 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: Adapted from proj4js 2.22.0. See ../../../../projection/PROJ4-LICENSE.md for the upstream license and attribution. math.gl uses the higher-order meridional series shared with Cassini, rather than the upstream truncated e0/e1/e2/e3 series. Qualified against PROJ 9.5.1.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {
+  temp: number;
+  en: number[];
+  sin_phi: number;
+  cos_phi: number;
+  ms1: number;
+  ml1: number;
+  ns: number;
+  ms2: number;
+  ml2: number;
+  g: number;
+  ml0: number;
+  rh: number;
+};
+import pj_enfn from '../common/pj_enfn';
+import pj_mlfn from '../common/pj_mlfn';
+import pj_inv_mlfn from '../common/pj_inv_mlfn';
+import msfnz from '../common/msfnz';
+import adjust_lon from '../common/adjust_lon';
+import adjust_lat from '../common/adjust_lat';
+import {EPSLN} from '../common/constants';
+
+function initialize(state: State): void {
+  /* Place parameters in static storage for common use
+      ------------------------------------------------- */
+  // Standard Parallels cannot be equal and on opposite sides of the equator
+  if (Math.abs(state.lat1 + state.lat2) < EPSLN) {
+    return;
+  }
+  // kernelParameters defaults omitted parallels; an explicit zero is meaningful.
+  state.temp = state.b / state.a;
+  state.es = 1 - Math.pow(state.temp, 2);
+  state.e = Math.sqrt(state.es);
+  state.en = pj_enfn(state.es);
+
+  state.sin_phi = Math.sin(state.lat1);
+  state.cos_phi = Math.cos(state.lat1);
+
+  state.ms1 = msfnz(state.e, state.sin_phi, state.cos_phi);
+  state.ml1 = pj_mlfn(state.lat1, Math.sin(state.lat1), Math.cos(state.lat1), state.en);
+
+  if (Math.abs(state.lat1 - state.lat2) < EPSLN) {
+    state.ns = state.sin_phi;
+  } else {
+    state.sin_phi = Math.sin(state.lat2);
+    state.cos_phi = Math.cos(state.lat2);
+    state.ms2 = msfnz(state.e, state.sin_phi, state.cos_phi);
+    state.ml2 = pj_mlfn(state.lat2, Math.sin(state.lat2), Math.cos(state.lat2), state.en);
+    state.ns = (state.ms1 - state.ms2) / (state.ml2 - state.ml1);
+  }
+  state.g = state.ml1 + state.ms1 / state.ns;
+  state.ml0 = pj_mlfn(state.lat0, Math.sin(state.lat0), Math.cos(state.lat0), state.en);
+  state.rh = state.a * (state.g - state.ml0);
+}
+
+/* Equidistant Conic 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 rh1;
+
+  /* Forward equations
+      ----------------- */
+  if (state.sphere) {
+    rh1 = state.a * (state.g - lat);
+  } else {
+    var ml = pj_mlfn(lat, Math.sin(lat), Math.cos(lat), state.en);
+    rh1 = state.a * (state.g - ml);
+  }
+  var theta = state.ns * adjust_lon(lon - state.long0, state.over);
+  var x = state.x0 + rh1 * Math.sin(theta);
+  var y = state.y0 + state.rh - rh1 * Math.cos(theta);
+  p.x = x;
+  p.y = y;
+  return p;
+}
+
+/* Inverse equations
+  ----------------- */
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  p.x -= state.x0;
+  p.y = state.rh - p.y + state.y0;
+  var con, rh1, lat, lon;
+  if (state.ns >= 0) {
+    rh1 = Math.sqrt(p.x * p.x + p.y * p.y);
+    con = 1;
+  } else {
+    rh1 = -Math.sqrt(p.x * p.x + p.y * p.y);
+    con = -1;
+  }
+  var theta = 0;
+  if (rh1 !== 0) {
+    theta = Math.atan2(con * p.x, con * p.y);
+  }
+
+  if (state.sphere) {
+    lon = adjust_lon(state.long0 + theta / state.ns, state.over);
+    lat = adjust_lat(state.g - rh1 / state.a);
+    p.x = lon;
+    p.y = lat;
+    return p;
+  } else {
+    var ml = state.g - rh1 / state.a;
+    lat = pj_inv_mlfn(ml, state.es, state.en);
+    lon = adjust_lon(state.long0 + theta / state.ns, state.over);
+    p.x = lon;
+    p.y = lat;
+    return p;
+  }
+}
+
+export function createState(base: KernelParameters): State {
+  const state: State = {
+    ...base,
+    temp: 0,
+    en: [],
+    sin_phi: 0,
+    cos_phi: 0,
+    ms1: 0,
+    ml1: 0,
+    ns: 0,
+    ms2: 0,
+    ml2: 0,
+    g: 0,
+    ml0: 0,
+    rh: 0
+  };
+  initialize(state);
+  return state;
+}

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

@@ -0,0 +1,146 @@
+// math.gl
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2018 Bernie Jenny, Monash University, Melbourne, Australia (Equal Earth, ported through proj4js)
+// SPDX-FileComment: Adapted from proj4js 2.22.0 lib/projections/eqearth.js with explicit TypeScript state and bounded inverse pole roundoff. Original Apache-2.0 notice retained below. See ../../../../projection/APACHE-2.0-LICENSE.txt and ../../../../projection/THIRD-PARTY-NOTICES.md. Independent corrections acknowledge PROJ 9.5.1 src/projections/eqearth.cpp and OSGeo/PROJ #1097; see ../../../../projection/PROJ-LICENSE.txt.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {
+  apa: number[];
+  qp: number;
+  rqda: number;
+};
+/**
+ * Copyright 2018 Bernie Jenny, Monash University, Melbourne, Australia.
+ *
+ * Licensed 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.
+ *
+ * Equal Earth is a projection inspired by the Robinson projection, but unlike
+ * the Robinson projection retains the relative size of areas. The projection
+ * was designed in 2018 by Bojan Savric, Tom Patterson and Bernhard Jenny.
+ *
+ * Publication:
+ * Bojan Savric, Tom Patterson & Bernhard Jenny (2018). The Equal Earth map
+ * projection, International Journal of Geographical Information Science,
+ * DOI: 10.1080/13658816.2018.1504949
+ *
+ * Code released August 2018
+ * Ported to JavaScript and adapted for mapshaper-proj by Matthew Bloch August 2018
+ * Modified for proj4js by Andreas Hocevar by Andreas Hocevar March 2024
+ */
+
+import adjust_lon from '../common/adjust_lon';
+import qsfnz from '../common/qsfnz';
+import authset from '../common/authset';
+import authlat from '../common/authlat';
+
+var A1 = 1.340264,
+  A2 = -0.081106,
+  A3 = 0.000893,
+  A4 = 0.003796,
+  M = Math.sqrt(3) / 2.0;
+
+function initialize(state: State): void {
+  state.long0 = state.long0 !== undefined ? state.long0 : 0;
+  state.x0 = state.x0 !== undefined ? state.x0 : 0;
+  state.y0 = state.y0 !== undefined ? state.y0 : 0;
+  if (state.es !== 0) {
+    state.apa = authset(state.es);
+    state.qp = qsfnz(state.e, 1);
+    state.rqda = Math.sqrt(0.5 * state.qp);
+  }
+}
+
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var lam = adjust_lon(p.x - state.long0, state.over);
+  var phi = p.y;
+  var sinphi = Math.sin(phi);
+  if (state.es !== 0) {
+    sinphi = qsfnz(state.e, sinphi) / state.qp;
+  }
+  var paramLat = Math.asin(M * sinphi),
+    paramLatSq = paramLat * paramLat,
+    paramLatPow6 = paramLatSq * paramLatSq * paramLatSq;
+  p.x =
+    (lam * Math.cos(paramLat)) /
+    (M * (A1 + 3 * A2 * paramLatSq + paramLatPow6 * (7 * A3 + 9 * A4 * paramLatSq)));
+  p.y = paramLat * (A1 + A2 * paramLatSq + paramLatPow6 * (A3 + A4 * paramLatSq));
+
+  if (state.es !== 0) {
+    p.x *= state.rqda;
+    p.y *= state.rqda;
+  }
+
+  p.x = state.a * p.x + state.x0;
+  p.y = state.a * p.y + state.y0;
+  return p;
+}
+
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  p.x = (p.x - state.x0) / state.a;
+  p.y = (p.y - state.y0) / state.a;
+
+  if (state.es !== 0) {
+    p.x /= state.rqda;
+    p.y /= state.rqda;
+  }
+
+  const poleParam = Math.PI / 3;
+  const poleSq = poleParam * poleParam;
+  const poleY = poleParam * (A1 + A2 * poleSq + poleSq ** 3 * (A3 + A4 * poleSq));
+  if (Math.abs(p.y) > poleY + 8 * Number.EPSILON * poleY) return null;
+
+  var EPS = 1e-9,
+    NITER = 12,
+    paramLat = p.y,
+    paramLatSq,
+    paramLatPow6,
+    fy,
+    fpy,
+    dlat,
+    i;
+
+  for (i = 0; i < NITER; ++i) {
+    paramLatSq = paramLat * paramLat;
+    paramLatPow6 = paramLatSq * paramLatSq * paramLatSq;
+    fy = paramLat * (A1 + A2 * paramLatSq + paramLatPow6 * (A3 + A4 * paramLatSq)) - p.y;
+    fpy = A1 + 3 * A2 * paramLatSq + paramLatPow6 * (7 * A3 + 9 * A4 * paramLatSq);
+    paramLat -= dlat = fy / fpy;
+    if (Math.abs(dlat) < EPS) {
+      break;
+    }
+  }
+  paramLatSq = paramLat * paramLat;
+  paramLatPow6 = paramLatSq * paramLatSq * paramLatSq;
+  p.x =
+    (M * p.x * (A1 + 3 * A2 * paramLatSq + paramLatPow6 * (7 * A3 + 9 * A4 * paramLatSq))) /
+    Math.cos(paramLat);
+  // Clamp only roundoff at the pole; points beyond the map remain invalid.
+  const sinBeta = Math.sin(paramLat) / M;
+  const poleRoundoff = 8 * Number.EPSILON;
+  if (Math.abs(sinBeta) > 1 + poleRoundoff) return null;
+  p.y =
+    Math.abs(sinBeta) >= 1 - poleRoundoff ? (Math.sign(sinBeta) * Math.PI) / 2 : Math.asin(sinBeta);
+
+  if (state.es !== 0) {
+    p.y = authlat(p.y, state.apa);
+  }
+
+  p.x = adjust_lon(p.x + state.long0, state.over);
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {...base, apa: [], qp: 0, rqda: 0, ...options};
+  initialize(state);
+  return state;
+}

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

@@ -0,0 +1,55 @@
+// 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: Adapted from proj4js 2.22.0 with bounded inverse pole roundoff. See ../../../../projection/PROJ4-LICENSE.md for upstream attribution.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {
+  t2: number;
+  t1: number;
+};
+import adjust_lon from '../common/adjust_lon';
+
+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.t2;
+}
+
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var lon = p.x;
+  var lat = p.y;
+
+  var dlon = adjust_lon(lon - state.long0, state.over);
+  var x = state.x0 + state.a * dlon * Math.cos(state.lat0);
+  var y = state.y0 + state.a * lat;
+
+  state.t1 = x;
+  state.t2 = Math.cos(state.lat0);
+  p.x = x;
+  p.y = y;
+  return p;
+}
+
+/* Equirectangular inverse equations--mapping x,y to lat/long
+  --------------------------------------------------------- */
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  p.x -= state.x0;
+  p.y -= state.y0;
+  var lat = p.y / state.a;
+  if (Math.abs(lat) > Math.PI / 2 && Math.abs(lat) <= Math.PI / 2 + 8 * Number.EPSILON)
+    lat = (Math.sign(lat) * Math.PI) / 2;
+
+  var lon = adjust_lon(state.long0 + p.x / (state.a * Math.cos(state.lat0)), state.over);
+  p.x = lon;
+  p.y = lat;
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {...base, t2: 0, t1: 0, ...options};
+  initialize(state);
+  return state;
+}