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

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 ../../../../projection/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 ../../../../projection/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;
+}

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

@@ -0,0 +1,183 @@
+// 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 & {
+  flip_axis: number;
+  sweep: string;
+  h: number;
+  radius_g_1: number;
+  radius_g: number;
+  C: number;
+  radius_p: number;
+  radius_p2: number;
+  radius_p_inv2: number;
+  shape: string;
+};
+import hypot from '../common/hypot';
+
+function initialize(state: State): void {
+  state.flip_axis = state.sweep === 'x' ? 1 : 0;
+  state.h = Number(state.h);
+  state.radius_g_1 = state.h / state.a;
+
+  if (state.radius_g_1 <= 0 || state.radius_g_1 > 1e10) {
+    throw new Error();
+  }
+
+  state.radius_g = 1.0 + state.radius_g_1;
+  state.C = state.radius_g * state.radius_g - 1.0;
+
+  if (state.es !== 0.0) {
+    var one_es = 1.0 - state.es;
+    var rone_es = 1 / one_es;
+
+    state.radius_p = Math.sqrt(one_es);
+    state.radius_p2 = one_es;
+    state.radius_p_inv2 = rone_es;
+
+    state.shape = 'ellipse'; // Use as a condition in the forward and inverse functions.
+  } else {
+    state.radius_p = 1.0;
+    state.radius_p2 = 1.0;
+    state.radius_p_inv2 = 1.0;
+
+    state.shape = 'sphere'; // Use as a condition in the forward and inverse functions.
+  }
+}
+
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var lon = p.x;
+  var lat = p.y;
+  var tmp, v_x, v_y, v_z;
+  lon = lon - state.long0;
+
+  if (state.shape === 'ellipse') {
+    lat = Math.atan(state.radius_p2 * Math.tan(lat));
+    var r = state.radius_p / hypot(state.radius_p * Math.cos(lat), Math.sin(lat));
+
+    v_x = r * Math.cos(lon) * Math.cos(lat);
+    v_y = r * Math.sin(lon) * Math.cos(lat);
+    v_z = r * Math.sin(lat);
+
+    if ((state.radius_g - v_x) * v_x - v_y * v_y - v_z * v_z * state.radius_p_inv2 < 0.0) {
+      p.x = Number.NaN;
+      p.y = Number.NaN;
+      return p;
+    }
+
+    tmp = state.radius_g - v_x;
+    if (state.flip_axis) {
+      p.x = state.radius_g_1 * Math.atan(v_y / hypot(v_z, tmp));
+      p.y = state.radius_g_1 * Math.atan(v_z / tmp);
+    } else {
+      p.x = state.radius_g_1 * Math.atan(v_y / tmp);
+      p.y = state.radius_g_1 * Math.atan(v_z / hypot(v_y, tmp));
+    }
+  } else if (state.shape === 'sphere') {
+    tmp = Math.cos(lat);
+    v_x = Math.cos(lon) * tmp;
+    v_y = Math.sin(lon) * tmp;
+    v_z = Math.sin(lat);
+    tmp = state.radius_g - v_x;
+
+    if (state.flip_axis) {
+      p.x = state.radius_g_1 * Math.atan(v_y / hypot(v_z, tmp));
+      p.y = state.radius_g_1 * Math.atan(v_z / tmp);
+    } else {
+      p.x = state.radius_g_1 * Math.atan(v_y / tmp);
+      p.y = state.radius_g_1 * Math.atan(v_z / hypot(v_y, tmp));
+    }
+  }
+  p.x = p.x * state.a;
+  p.y = p.y * state.a;
+  return p;
+}
+
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var v_x = -1.0;
+  var v_y = 0.0;
+  var v_z = 0.0;
+  var a, b, det, k;
+
+  p.x = p.x / state.a;
+  p.y = p.y / state.a;
+
+  if (state.shape === 'ellipse') {
+    if (state.flip_axis) {
+      v_z = Math.tan(p.y / state.radius_g_1);
+      v_y = Math.tan(p.x / state.radius_g_1) * hypot(1.0, v_z);
+    } else {
+      v_y = Math.tan(p.x / state.radius_g_1);
+      v_z = Math.tan(p.y / state.radius_g_1) * hypot(1.0, v_y);
+    }
+
+    var v_zp = v_z / state.radius_p;
+    a = v_y * v_y + v_zp * v_zp + v_x * v_x;
+    b = 2 * state.radius_g * v_x;
+    det = b * b - 4 * a * state.C;
+
+    if (det < 0.0) {
+      p.x = Number.NaN;
+      p.y = Number.NaN;
+      return p;
+    }
+
+    k = (-b - Math.sqrt(det)) / (2.0 * a);
+    v_x = state.radius_g + k * v_x;
+    v_y *= k;
+    v_z *= k;
+
+    p.x = Math.atan2(v_y, v_x);
+    p.y = Math.atan((v_z * Math.cos(p.x)) / v_x);
+    p.y = Math.atan(state.radius_p_inv2 * Math.tan(p.y));
+  } else if (state.shape === 'sphere') {
+    if (state.flip_axis) {
+      v_z = Math.tan(p.y / state.radius_g_1);
+      v_y = Math.tan(p.x / state.radius_g_1) * Math.sqrt(1.0 + v_z * v_z);
+    } else {
+      v_y = Math.tan(p.x / state.radius_g_1);
+      v_z = Math.tan(p.y / state.radius_g_1) * Math.sqrt(1.0 + v_y * v_y);
+    }
+
+    a = v_y * v_y + v_z * v_z + v_x * v_x;
+    b = 2 * state.radius_g * v_x;
+    det = b * b - 4 * a * state.C;
+    if (det < 0.0) {
+      p.x = Number.NaN;
+      p.y = Number.NaN;
+      return p;
+    }
+
+    k = (-b - Math.sqrt(det)) / (2.0 * a);
+    v_x = state.radius_g + k * v_x;
+    v_y *= k;
+    v_z *= k;
+
+    p.x = Math.atan2(v_y, v_x);
+    p.y = Math.atan((v_z * Math.cos(p.x)) / v_x);
+  }
+  p.x = p.x + state.long0;
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {
+    ...base,
+    flip_axis: 0,
+    sweep: '',
+    h: 0,
+    radius_g_1: 0,
+    radius_g: 0,
+    C: 0,
+    radius_p: 0,
+    radius_p2: 0,
+    radius_p_inv2: 0,
+    shape: '',
+    ...options
+  };
+  initialize(state);
+  return state;
+}

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

@@ -0,0 +1,123 @@
+// 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: Spherical path adapted from proj4js 2.22.0; ellipsoidal path delegates to the attributed PROJ/GeographicLib adapter. See ../../../../projection/PROJ4-LICENSE.md for the upstream license and attribution.
+
+import type {KernelParameters, Point} from '../kernel';
+import {
+  prepareEllipsoidalGnomonic,
+  forwardEllipsoidalGnomonic,
+  inverseEllipsoidalGnomonic
+} from '../ellipsoidal-gnomonic';
+import type {EllipsoidalGnomonic} from '../ellipsoidal-gnomonic';
+export type State = KernelParameters & {
+  ellipsoid?: EllipsoidalGnomonic;
+  sin_p14: number;
+  cos_p14: number;
+  infinity_dist: number;
+  rc: number;
+  phic0: number;
+};
+import adjust_lon from '../common/adjust_lon';
+import asinz from '../common/asinz';
+import {EPSLN} from '../common/constants';
+
+function initialize(state: State): void {
+  if (!state.sphere) state.ellipsoid = prepareEllipsoidalGnomonic(state);
+  /* Place parameters in static storage for common use
+      ------------------------------------------------- */
+  state.sin_p14 = Math.sin(state.lat0);
+  state.cos_p14 = Math.cos(state.lat0);
+  // Approximation for projecting points to the horizon (infinity)
+  state.infinity_dist = 1000 * state.a;
+  state.rc = 1;
+}
+
+/* Gnomonic forward equations--mapping lat,long to x,y
+    --------------------------------------------------- */
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  if (state.ellipsoid) return forwardEllipsoidalGnomonic(state, state.ellipsoid, p);
+  var sinphi, cosphi; /* sin and cos value        */
+  var dlon; /* delta longitude value      */
+  var coslon; /* cos of longitude        */
+  var ksp; /* scale factor          */
+  var g;
+  var x, y;
+  var lon = p.x;
+  var lat = p.y;
+  /* Forward equations
+      ----------------- */
+  dlon = adjust_lon(lon - state.long0, state.over);
+
+  sinphi = Math.sin(lat);
+  cosphi = Math.cos(lat);
+
+  coslon = Math.cos(dlon);
+  g = state.sin_p14 * sinphi + state.cos_p14 * cosphi * coslon;
+  ksp = 1;
+  if (g > 0 || Math.abs(g) <= EPSLN) {
+    x = state.x0 + (state.a * ksp * cosphi * Math.sin(dlon)) / g;
+    y = state.y0 + (state.a * ksp * (state.cos_p14 * sinphi - state.sin_p14 * cosphi * coslon)) / g;
+  } else {
+    // Point is in the opposing hemisphere and is unprojectable
+    // We still need to return a reasonable point, so we project
+    // to infinity, on a bearing
+    // equivalent to the northern hemisphere equivalent
+    // This is a reasonable approximation for short shapes and lines that
+    // straddle the horizon.
+
+    x = state.x0 + state.infinity_dist * cosphi * Math.sin(dlon);
+    y = state.y0 + state.infinity_dist * (state.cos_p14 * sinphi - state.sin_p14 * cosphi * coslon);
+  }
+  p.x = x;
+  p.y = y;
+  return p;
+}
+
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  if (state.ellipsoid) return inverseEllipsoidalGnomonic(state, state.ellipsoid, p);
+  var rh; /* Rho */
+  var sinc, cosc;
+  var c;
+  var lon, lat;
+
+  /* Inverse equations
+      ----------------- */
+  p.x = (p.x - state.x0) / state.a;
+  p.y = (p.y - state.y0) / state.a;
+
+  p.x /= state.k0;
+  p.y /= state.k0;
+
+  rh = Math.sqrt(p.x * p.x + p.y * p.y);
+  if (rh) {
+    c = Math.atan2(rh, state.rc);
+    sinc = Math.sin(c);
+    cosc = Math.cos(c);
+
+    lat = asinz(cosc * state.sin_p14 + (p.y * sinc * state.cos_p14) / rh);
+    lon = Math.atan2(p.x * sinc, rh * state.cos_p14 * cosc - p.y * state.sin_p14 * sinc);
+    lon = adjust_lon(state.long0 + lon, state.over);
+  } else {
+    lat = state.lat0;
+    lon = state.long0;
+  }
+
+  p.x = lon;
+  p.y = lat;
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {
+    ...base,
+    sin_p14: 0,
+    cos_p14: 0,
+    infinity_dist: 0,
+    rc: 0,
+    phic0: 0,
+    ...options
+  };
+  initialize(state);
+  return state;
+}

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

@@ -0,0 +1,74 @@
+// 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 & {
+  lc: number;
+  rs: number;
+  cp: number;
+  n2: number;
+  xs: number;
+  ys: number;
+};
+import latiso from '../common/latiso';
+import sinh from '../common/sinh';
+import cosh from '../common/cosh';
+import invlatiso from '../common/invlatiso';
+
+function initialize(state: State): void {
+  // array of:  a, b, lon0, lat0, k0, x0, y0
+  if (!state.k0) {
+    state.k0 = 1;
+  }
+  var temp = state.b / state.a;
+  state.e = Math.sqrt(1 - temp * temp);
+  state.lc = state.long0;
+  state.rs = Math.sqrt(
+    1 + (state.e * state.e * Math.pow(Math.cos(state.lat0), 4)) / (1 - state.e * state.e)
+  );
+  var sinz = Math.sin(state.lat0);
+  var pc = Math.asin(sinz / state.rs);
+  var sinzpc = Math.sin(pc);
+  state.cp = latiso(0, pc, sinzpc) - state.rs * latiso(state.e, state.lat0, sinz);
+  state.n2 =
+    (state.k0 * state.a * Math.sqrt(1 - state.e * state.e)) / (1 - state.e * state.e * sinz * sinz);
+  state.xs = state.x0;
+  state.ys = state.y0 - state.n2 * pc;
+}
+
+// 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 L = state.rs * (lon - state.lc);
+  var Ls = state.cp + state.rs * latiso(state.e, lat, Math.sin(lat));
+  var lat1 = Math.asin(Math.sin(L) / cosh(Ls));
+  var Ls1 = latiso(0, lat1, Math.sin(lat1));
+  p.x = state.xs + state.n2 * Ls1;
+  p.y = state.ys + state.n2 * Math.atan(sinh(Ls) / Math.cos(L));
+  return p;
+}
+
+// inverse equations--mapping x,y to lat/long
+// -----------------------------------------------------------------
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var x = p.x;
+  var y = p.y;
+
+  var L = Math.atan(sinh((x - state.xs) / state.n2) / Math.cos((y - state.ys) / state.n2));
+  var lat1 = Math.asin(Math.sin((y - state.ys) / state.n2) / cosh((x - state.xs) / state.n2));
+  var LC = latiso(0, lat1, Math.sin(lat1));
+  p.x = state.lc + L / state.rs;
+  p.y = invlatiso(state.e, (LC - state.cp) / state.rs);
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {...base, lc: 0, rs: 0, cp: 0, n2: 0, xs: 0, ys: 0, ...options};
+  initialize(state);
+  return state;
+}