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

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 ../../../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 ../../../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,136 @@
+// math.gl
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2018 Bernie Jenny, Monash University, Melbourne, Australia (Equal Earth, ported through proj4js)
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0 lib/projections/eqearth.js. Modified to use explicit TypeScript state. Original Apache-2.0 notice retained below. See ../../../APACHE-2.0-LICENSE.txt and ../../../THIRD-PARTY-NOTICES.md.
+
+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;
+  }
+
+  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);
+  p.y = Math.asin(Math.sin(paramLat) / M);
+
+  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,53 @@
+// 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 & {
+  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;
+
+  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;
+}

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

@@ -0,0 +1,190 @@
+// 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 & {
+  cgb: number[];
+  cbg: number[];
+  utg: number[];
+  gtu: number[];
+  Qn: number;
+  Zb: number;
+};
+// Heavily based on this etmerc projection implementation
+// https://github.com/mbloch/mapshaper-proj/blob/master/src/projections/etmerc.js
+
+import sinh from '../common/sinh';
+import hypot from '../common/hypot';
+import asinhy from '../common/asinhy';
+import gatg from '../common/gatg';
+import clens from '../common/clens';
+import clens_cmplx from '../common/clens_cmplx';
+import adjust_lon from '../common/adjust_lon';
+
+function initialize(state: State): void {
+  state.x0 = state.x0 !== undefined ? state.x0 : 0;
+  state.y0 = state.y0 !== undefined ? state.y0 : 0;
+  state.long0 = state.long0 !== undefined ? state.long0 : 0;
+  state.lat0 = state.lat0 !== undefined ? state.lat0 : 0;
+  state.k0 = state.k0 !== undefined ? state.k0 : 1;
+
+  state.cgb = [];
+  state.cbg = [];
+  state.utg = [];
+  state.gtu = [];
+
+  var f = state.es / (1 + Math.sqrt(1 - state.es));
+  var n = f / (2 - f);
+  var np = n;
+
+  state.cgb[0] =
+    n * (2 + n * (-2 / 3 + n * (-2 + n * (116 / 45 + n * (26 / 45 + n * (-2854 / 675))))));
+  state.cbg[0] =
+    n * (-2 + n * (2 / 3 + n * (4 / 3 + n * (-82 / 45 + n * (32 / 45 + n * (4642 / 4725))))));
+
+  np = np * n;
+  state.cgb[1] =
+    np * (7 / 3 + n * (-8 / 5 + n * (-227 / 45 + n * (2704 / 315 + n * (2323 / 945)))));
+  state.cbg[1] =
+    np * (5 / 3 + n * (-16 / 15 + n * (-13 / 9 + n * (904 / 315 + n * (-1522 / 945)))));
+
+  np = np * n;
+  state.cgb[2] = np * (56 / 15 + n * (-136 / 35 + n * (-1262 / 105 + n * (73814 / 2835))));
+  state.cbg[2] = np * (-26 / 15 + n * (34 / 21 + n * (8 / 5 + n * (-12686 / 2835))));
+
+  np = np * n;
+  state.cgb[3] = np * (4279 / 630 + n * (-332 / 35 + n * (-399572 / 14175)));
+  state.cbg[3] = np * (1237 / 630 + n * (-12 / 5 + n * (-24832 / 14175)));
+
+  np = np * n;
+  state.cgb[4] = np * (4174 / 315 + n * (-144838 / 6237));
+  state.cbg[4] = np * (-734 / 315 + n * (109598 / 31185));
+
+  np = np * n;
+  state.cgb[5] = np * (601676 / 22275);
+  state.cbg[5] = np * (444337 / 155925);
+
+  np = Math.pow(n, 2);
+  state.Qn = (state.k0 / (1 + n)) * (1 + np * (1 / 4 + np * (1 / 64 + np / 256)));
+
+  state.utg[0] =
+    n *
+    (-0.5 + n * (2 / 3 + n * (-37 / 96 + n * (1 / 360 + n * (81 / 512 + n * (-96199 / 604800))))));
+  state.gtu[0] =
+    n *
+    (0.5 + n * (-2 / 3 + n * (5 / 16 + n * (41 / 180 + n * (-127 / 288 + n * (7891 / 37800))))));
+
+  state.utg[1] =
+    np * (-1 / 48 + n * (-1 / 15 + n * (437 / 1440 + n * (-46 / 105 + n * (1118711 / 3870720)))));
+  state.gtu[1] =
+    np * (13 / 48 + n * (-3 / 5 + n * (557 / 1440 + n * (281 / 630 + n * (-1983433 / 1935360)))));
+
+  np = np * n;
+  state.utg[2] = np * (-17 / 480 + n * (37 / 840 + n * (209 / 4480 + n * (-5569 / 90720))));
+  state.gtu[2] = np * (61 / 240 + n * (-103 / 140 + n * (15061 / 26880 + n * (167603 / 181440))));
+
+  np = np * n;
+  state.utg[3] = np * (-4397 / 161280 + n * (11 / 504 + n * (830251 / 7257600)));
+  state.gtu[3] = np * (49561 / 161280 + n * (-179 / 168 + n * (6601661 / 7257600)));
+
+  np = np * n;
+  state.utg[4] = np * (-4583 / 161280 + n * (108847 / 3991680));
+  state.gtu[4] = np * (34729 / 80640 + n * (-3418889 / 1995840));
+
+  np = np * n;
+  state.utg[5] = np * (-20648693 / 638668800);
+  state.gtu[5] = np * (212378941 / 319334400);
+
+  var Z = gatg(state.cbg, state.lat0);
+  state.Zb = -state.Qn * (Z + clens(state.gtu, 2 * Z));
+}
+
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var Ce = adjust_lon(p.x - state.long0, state.over);
+  var Cn = p.y;
+
+  Cn = gatg(state.cbg, Cn);
+  var sin_Cn = Math.sin(Cn);
+  var cos_Cn = Math.cos(Cn);
+  var sin_Ce = Math.sin(Ce);
+  var cos_Ce = Math.cos(Ce);
+
+  Cn = Math.atan2(sin_Cn, cos_Ce * cos_Cn);
+  Ce = Math.atan2(sin_Ce * cos_Cn, hypot(sin_Cn, cos_Cn * cos_Ce));
+  Ce = asinhy(Math.tan(Ce));
+
+  clens_cmplx(state.gtu, 2 * Cn, 2 * Ce, p);
+
+  Cn = Cn + p.x;
+  Ce = Ce + p.y;
+
+  var x;
+  var y;
+
+  if (Math.abs(Ce) <= 2.623395162778) {
+    x = state.a * (state.Qn * Ce) + state.x0;
+    y = state.a * (state.Qn * Cn + state.Zb) + state.y0;
+  } else {
+    x = Infinity;
+    y = Infinity;
+  }
+
+  p.x = x;
+  p.y = y;
+
+  return p;
+}
+
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var Ce = (p.x - state.x0) * (1 / state.a);
+  var Cn = (p.y - state.y0) * (1 / state.a);
+
+  Cn = (Cn - state.Zb) / state.Qn;
+  Ce = Ce / state.Qn;
+
+  var lon;
+  var lat;
+
+  if (Math.abs(Ce) <= 2.623395162778) {
+    clens_cmplx(state.utg, 2 * Cn, 2 * Ce, p);
+
+    Cn = Cn + p.x;
+    Ce = Ce + p.y;
+    Ce = Math.atan(sinh(Ce));
+
+    var sin_Cn = Math.sin(Cn);
+    var cos_Cn = Math.cos(Cn);
+    var sin_Ce = Math.sin(Ce);
+    var cos_Ce = Math.cos(Ce);
+
+    Cn = Math.atan2(sin_Cn * cos_Ce, hypot(sin_Ce, cos_Ce * cos_Cn));
+    Ce = Math.atan2(sin_Ce, cos_Ce * cos_Cn);
+
+    lon = adjust_lon(Ce + state.long0, state.over);
+    lat = gatg(state.cgb, Cn);
+  } else {
+    lon = Infinity;
+    lat = Infinity;
+  }
+
+  p.x = lon;
+  p.y = lat;
+
+  return p;
+}
+
+export function createState(base: KernelParameters): State {
+  const state: State = {
+    ...base,
+    cgb: [],
+    cbg: [],
+    utg: [],
+    gtu: [],
+    Qn: 0,
+    Zb: 0
+  };
+  initialize(state);
+  return state;
+}

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

@@ -0,0 +1,79 @@
+// 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 & {
+  rc: number;
+  C: number;
+  phic0: number;
+  ratexp: number;
+  K: number;
+};
+import srat from '../common/srat';
+var MAX_ITER = 20;
+import {HALF_PI, FORTPI} from '../common/constants';
+
+function initialize(state: State): void {
+  var sphi = Math.sin(state.lat0);
+  var cphi = Math.cos(state.lat0);
+  cphi *= cphi;
+  state.rc = Math.sqrt(1 - state.es) / (1 - state.es * sphi * sphi);
+  state.C = Math.sqrt(1 + (state.es * cphi * cphi) / (1 - state.es));
+  state.phic0 = Math.asin(sphi / state.C);
+  state.ratexp = 0.5 * state.C * state.e;
+  state.K =
+    Math.tan(0.5 * state.phic0 + FORTPI) /
+    (Math.pow(Math.tan(0.5 * state.lat0 + FORTPI), state.C) * srat(state.e * sphi, state.ratexp));
+}
+
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var lon = p.x;
+  var lat = p.y;
+
+  p.y =
+    2 *
+      Math.atan(
+        state.K *
+          Math.pow(Math.tan(0.5 * lat + FORTPI), state.C) *
+          srat(state.e * Math.sin(lat), state.ratexp)
+      ) -
+    HALF_PI;
+  p.x = state.C * lon;
+  return p;
+}
+
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var DEL_TOL = 1e-14;
+  var lon = p.x / state.C;
+  var lat = p.y;
+  var num = Math.pow(Math.tan(0.5 * lat + FORTPI) / state.K, 1 / state.C);
+  for (var i = MAX_ITER; i > 0; --i) {
+    lat = 2 * Math.atan(num * srat(state.e * Math.sin(p.y), -0.5 * state.e)) - HALF_PI;
+    if (Math.abs(lat - p.y) < DEL_TOL) {
+      break;
+    }
+    p.y = lat;
+  }
+  /* convergence failed */
+  if (!i) {
+    return null;
+  }
+  p.x = lon;
+  p.y = lat;
+  return p;
+}
+
+export function createState(base: KernelParameters): State {
+  const state: State = {
+    ...base,
+    rc: 0,
+    C: 0,
+    phic0: 0,
+    ratexp: 0,
+    K: 0
+  };
+  initialize(state);
+  return state;
+}