@math.gl/projection 0.0.0-stage → 5.0.0-alpha.12

package/src/experimental/kernel.ts

@@ -0,0 +1,139 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {createProjection, projectionOperation} from './mutable-projection';
+import {DEGREES_TO_RADIANS, numberParameter} from './parameters';
+import type {ProjectionContext, ProjectionImplementation, ProjectionParameters} from './types';
+
+export type Point = {x: number; y: number};
+
+/** Fully initialized inputs to numerical kernels. Angles are radians, lengths meters. */
+export type KernelParameters = {
+  a: number;
+  b: number;
+  e: number;
+  es: number;
+  ep2: number;
+  sphere: boolean;
+  over: boolean;
+  long0: number;
+  lat0: number;
+  lat1: number;
+  lat2: number;
+  /** NaN means a latitude of true scale was not supplied. */
+  lat_ts: number;
+  x0: number;
+  y0: number;
+  k0: number;
+};
+
+export const ORIGIN_PARAMETERS = ['lon_0', 'lat_0', 'x_0', 'y_0'] as const;
+export const SCALE_PARAMETERS = ['k', 'k_0'] as const;
+
+export function angleParameter(
+  parameters: ProjectionParameters,
+  name: string,
+  fallback = 0
+): number {
+  const degrees = numberParameter(parameters, name, fallback);
+  if (name !== 'lon_0' && Math.abs(degrees) > 90) {
+    throw new Error('Latitude parameter must be between -90 and 90 degrees: +' + name);
+  }
+  return degrees * DEGREES_TO_RADIANS;
+}
+
+export function flagParameter(parameters: ProjectionParameters, name: string): boolean {
+  const present = Object.prototype.hasOwnProperty.call(parameters, name);
+  if (present && parameters[name] !== undefined)
+    throw new Error('Expected a flag without a value: +' + name);
+  return present;
+}
+
+export function kernelParameters({
+  semiMajorAxis: a,
+  eccentricitySquared: es,
+  parameters
+}: ProjectionContext): KernelParameters {
+  const k0 = numberParameter(parameters, 'k_0', numberParameter(parameters, 'k', 1));
+  if (k0 <= 0) throw new Error('Projection scale must be positive');
+  return {
+    a,
+    b: a * Math.sqrt(1 - es),
+    es,
+    e: Math.sqrt(es),
+    ep2: es / (1 - es),
+    sphere: es === 0,
+    over: flagParameter(parameters, 'over'),
+    long0: angleParameter(parameters, 'lon_0'),
+    lat0: angleParameter(parameters, 'lat_0'),
+    lat1: angleParameter(parameters, 'lat_1'),
+    lat2: angleParameter(parameters, 'lat_2', numberParameter(parameters, 'lat_1', 0)),
+    lat_ts: angleParameter(parameters, 'lat_ts', NaN),
+    x0: numberParameter(parameters, 'x_0', 0),
+    y0: numberParameter(parameters, 'y_0', 0),
+    k0
+  };
+}
+
+export function validateConic(base: KernelParameters, parameters: ProjectionParameters): void {
+  if (!Object.prototype.hasOwnProperty.call(parameters, 'lat_1')) {
+    throw new Error('Conic projections require +lat_1');
+  }
+  if (
+    Math.abs(base.lat1 + base.lat2) < 1e-10 ||
+    Math.abs(base.lat1) >= Math.PI / 2 ||
+    Math.abs(base.lat2) >= Math.PI / 2
+  ) {
+    throw new Error('Conic standard parallels must not be opposite or at a pole');
+  }
+}
+
+/** Adapt kernels with explicit state into the allocation-isolated public plugin contract. */
+export function bindKernel<State>(
+  name: string,
+  state: State,
+  forward: (state: State, point: Point) => Point | null | undefined | number,
+  inverse: (state: State, point: Point) => Point | null | undefined | number,
+  adapt = createProjection
+): ProjectionImplementation {
+  const run = (operation: typeof forward, point: Point): void => {
+    const result = operation(state, point);
+    if (
+      !result ||
+      typeof result !== 'object' ||
+      !Number.isFinite(result.x) ||
+      !Number.isFinite(result.y)
+    )
+      throw new Error(name + ': coordinate outside projection domain or inverse did not converge');
+    point.x = result.x;
+    point.y = result.y;
+  };
+  return adapt(
+    point => run(forward, point),
+    point => run(inverse, point)
+  );
+}
+
+/** Azimuthal antipodes have no unique azimuth; reject even when roundoff is finite. */
+export function guardAzimuthalDomain(
+  base: KernelParameters,
+  implementation: ProjectionImplementation
+): ProjectionImplementation {
+  const forward = projectionOperation(implementation, false);
+  return createProjection(
+    point => {
+      const longitude = point.x,
+        latitude = point.y;
+      const delta = Math.atan2(Math.sin(longitude - base.long0), Math.cos(longitude - base.long0));
+      const polar = Math.abs(Math.abs(base.lat0) - Math.PI / 2) < 1e-10;
+      if (
+        Math.abs(latitude + base.lat0) < 1e-10 &&
+        (polar || Math.abs(Math.abs(delta) - Math.PI) < 1e-10)
+      )
+        throw new Error('Azimuthal projection is undefined at the antipode');
+      forward(point);
+    },
+    projectionOperation(implementation, true)
+  );
+}

package/src/experimental/kernels/aea.ts

@@ -0,0 +1,170 @@
+// 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;
+  e3: number;
+  sin_po: number;
+  cos_po: number;
+  t1: number;
+  con: number;
+  ms1: number;
+  qs1: number;
+  t2: number;
+  ms2: number;
+  qs2: number;
+  t3: number;
+  qs0: number;
+  ns0: number;
+  c: number;
+  rh: number;
+  sin_phi: number;
+  cos_phi: number;
+};
+import msfnz from '../common/msfnz';
+import qsfnz from '../common/qsfnz';
+import adjust_lon from '../common/adjust_lon';
+import asinz from '../common/asinz';
+import {EPSLN} from '../common/constants';
+
+function initialize(state: State): void {
+  if (Math.abs(state.lat1 + state.lat2) < EPSLN) {
+    return;
+  }
+  state.temp = state.b / state.a;
+  state.es = 1 - Math.pow(state.temp, 2);
+  state.e3 = Math.sqrt(state.es);
+
+  state.sin_po = Math.sin(state.lat1);
+  state.cos_po = Math.cos(state.lat1);
+  state.t1 = state.sin_po;
+  state.con = state.sin_po;
+  state.ms1 = msfnz(state.e3, state.sin_po, state.cos_po);
+  state.qs1 = qsfnz(state.e3, state.sin_po);
+
+  state.sin_po = Math.sin(state.lat2);
+  state.cos_po = Math.cos(state.lat2);
+  state.t2 = state.sin_po;
+  state.ms2 = msfnz(state.e3, state.sin_po, state.cos_po);
+  state.qs2 = qsfnz(state.e3, state.sin_po);
+
+  state.sin_po = Math.sin(state.lat0);
+  state.cos_po = Math.cos(state.lat0);
+  state.t3 = state.sin_po;
+  state.qs0 = qsfnz(state.e3, state.sin_po);
+
+  if (Math.abs(state.lat1 - state.lat2) > EPSLN) {
+    state.ns0 = (state.ms1 * state.ms1 - state.ms2 * state.ms2) / (state.qs2 - state.qs1);
+  } else {
+    state.ns0 = state.con;
+  }
+  state.c = state.ms1 * state.ms1 + state.ns0 * state.qs1;
+  state.rh = (state.a * Math.sqrt(state.c - state.ns0 * state.qs0)) / state.ns0;
+}
+
+/* Albers Conical 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;
+
+  state.sin_phi = Math.sin(lat);
+  state.cos_phi = Math.cos(lat);
+
+  var qs = qsfnz(state.e3, state.sin_phi);
+  var rh1 = (state.a * Math.sqrt(state.c - state.ns0 * qs)) / state.ns0;
+  var theta = state.ns0 * adjust_lon(lon - state.long0, state.over);
+  var x = rh1 * Math.sin(theta) + state.x0;
+  var y = state.rh - rh1 * Math.cos(theta) + state.y0;
+
+  p.x = x;
+  p.y = y;
+  return p;
+}
+
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var rh1, qs, con, theta, lon, lat;
+
+  p.x -= state.x0;
+  p.y = state.rh - p.y + state.y0;
+  if (state.ns0 >= 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;
+  }
+  theta = 0;
+  if (rh1 !== 0) {
+    theta = Math.atan2(con * p.x, con * p.y);
+  }
+  con = (rh1 * state.ns0) / state.a;
+  if (state.sphere) {
+    lat = Math.asin((state.c - con * con) / (2 * state.ns0));
+  } else {
+    qs = (state.c - con * con) / state.ns0;
+    lat = phi1z(state.e3, qs);
+  }
+
+  lon = adjust_lon(theta / state.ns0 + state.long0, state.over);
+  p.x = lon;
+  p.y = lat;
+  return p;
+}
+
+/* Function to compute phi1, the latitude for the inverse of the
+   Albers Conical Equal-Area projection.
+------------------------------------------- */
+function phi1z(eccent: number, qs: number): number | null {
+  var sinphi, cosphi, con, com, dphi;
+  var phi = asinz(0.5 * qs);
+  if (eccent < EPSLN) {
+    return phi;
+  }
+
+  var eccnts = eccent * eccent;
+  for (var i = 1; i <= 25; i++) {
+    sinphi = Math.sin(phi);
+    cosphi = Math.cos(phi);
+    con = eccent * sinphi;
+    com = 1 - con * con;
+    dphi =
+      ((0.5 * com * com) / cosphi) *
+      (qs / (1 - eccnts) - sinphi / com + (0.5 / eccent) * Math.log((1 - con) / (1 + con)));
+    phi = phi + dphi;
+    if (Math.abs(dphi) <= 1e-7) {
+      return phi;
+    }
+  }
+  return null;
+}
+
+export function createState(base: KernelParameters): State {
+  const state: State = {
+    ...base,
+    temp: 0,
+    e3: 0,
+    sin_po: 0,
+    cos_po: 0,
+    t1: 0,
+    con: 0,
+    ms1: 0,
+    qs1: 0,
+    t2: 0,
+    ms2: 0,
+    qs2: 0,
+    t3: 0,
+    qs0: 0,
+    ns0: 0,
+    c: 0,
+    rh: 0,
+    sin_phi: 0,
+    cos_phi: 0
+  };
+  initialize(state);
+  return state;
+}

package/src/experimental/kernels/aeqd.ts

@@ -0,0 +1,182 @@
+// 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 & {
+  sin_p12: number;
+  cos_p12: number;
+  f: number;
+};
+import adjust_lon from '../common/adjust_lon';
+import {HALF_PI, EPSLN} from '../common/constants';
+import mlfn from '../common/mlfn';
+import e0fn from '../common/e0fn';
+import e1fn from '../common/e1fn';
+import e2fn from '../common/e2fn';
+import e3fn from '../common/e3fn';
+import asinz from '../common/asinz';
+import imlfn from '../common/imlfn';
+import {vincentyDirect, vincentyInverse} from '../common/vincenty';
+
+function initialize(state: State): void {
+  state.sin_p12 = Math.sin(state.lat0);
+  state.cos_p12 = Math.cos(state.lat0);
+  state.x0 = state.x0 || 0;
+  state.y0 = state.y0 || 0;
+  state.long0 = state.long0 || 0;
+  // flattening for ellipsoid
+  state.f = state.es / (1 + Math.sqrt(1 - state.es));
+}
+
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var lon = p.x;
+  var lat = p.y;
+  var sinphi = Math.sin(p.y);
+  var cosphi = Math.cos(p.y);
+  var dlon = adjust_lon(lon - state.long0, state.over);
+  var e0, e1, e2, e3, Mlp, Ml, c, kp, cos_c, azi1;
+  if (state.sphere) {
+    if (Math.abs(state.sin_p12 - 1) <= EPSLN) {
+      // North Pole case
+      p.x = state.x0 + state.a * (HALF_PI - lat) * Math.sin(dlon);
+      p.y = state.y0 - state.a * (HALF_PI - lat) * Math.cos(dlon);
+      return p;
+    } else if (Math.abs(state.sin_p12 + 1) <= EPSLN) {
+      // South Pole case
+      p.x = state.x0 + state.a * (HALF_PI + lat) * Math.sin(dlon);
+      p.y = state.y0 + state.a * (HALF_PI + lat) * Math.cos(dlon);
+      return p;
+    } else {
+      // default case
+      cos_c = state.sin_p12 * sinphi + state.cos_p12 * cosphi * Math.cos(dlon);
+      c = Math.acos(cos_c);
+      kp = c ? c / Math.sin(c) : 1;
+      p.x = state.x0 + state.a * kp * cosphi * Math.sin(dlon);
+      p.y =
+        state.y0 +
+        state.a * kp * (state.cos_p12 * sinphi - state.sin_p12 * cosphi * Math.cos(dlon));
+      return p;
+    }
+  } else {
+    e0 = e0fn(state.es);
+    e1 = e1fn(state.es);
+    e2 = e2fn(state.es);
+    e3 = e3fn(state.es);
+    if (Math.abs(state.sin_p12 - 1) <= EPSLN) {
+      // North Pole case
+      Mlp = state.a * mlfn(e0, e1, e2, e3, HALF_PI);
+      Ml = state.a * mlfn(e0, e1, e2, e3, lat);
+      p.x = state.x0 + (Mlp - Ml) * Math.sin(dlon);
+      p.y = state.y0 - (Mlp - Ml) * Math.cos(dlon);
+      return p;
+    } else if (Math.abs(state.sin_p12 + 1) <= EPSLN) {
+      // South Pole case
+      Mlp = state.a * mlfn(e0, e1, e2, e3, HALF_PI);
+      Ml = state.a * mlfn(e0, e1, e2, e3, lat);
+      p.x = state.x0 + (Mlp + Ml) * Math.sin(dlon);
+      p.y = state.y0 + (Mlp + Ml) * Math.cos(dlon);
+      return p;
+    } else {
+      // Default case
+      // Correct the upstream origin shortcut to use longitude relative to lon_0.
+      if (Math.abs(dlon) < EPSLN && Math.abs(lat - state.lat0) < EPSLN) {
+        p.x = state.x0;
+        p.y = state.y0;
+        return p;
+      }
+      vincentyInverse(state.lat0, state.long0, lat, lon, state.a, state.f, p);
+      azi1 = p.x;
+      const distance = p.y;
+      p.x = state.x0 + distance * Math.sin(azi1);
+      p.y = state.y0 + distance * Math.cos(azi1);
+      return p;
+    }
+  }
+}
+
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  p.x -= state.x0;
+  p.y -= state.y0;
+  var rh, z, sinz, cosz, lon, lat, con, e0, e1, e2, e3, Mlp, M, azi1, s12;
+  if (state.sphere) {
+    rh = Math.sqrt(p.x * p.x + p.y * p.y);
+    if (rh > 2 * HALF_PI * state.a) {
+      return null;
+    }
+    z = rh / state.a;
+
+    sinz = Math.sin(z);
+    cosz = Math.cos(z);
+
+    lon = state.long0;
+    if (Math.abs(rh) <= EPSLN) {
+      lat = state.lat0;
+    } else {
+      lat = asinz(cosz * state.sin_p12 + (p.y * sinz * state.cos_p12) / rh);
+      con = Math.abs(state.lat0) - HALF_PI;
+      if (Math.abs(con) <= EPSLN) {
+        if (state.lat0 >= 0) {
+          lon = adjust_lon(state.long0 + Math.atan2(p.x, -p.y), state.over);
+        } else {
+          lon = adjust_lon(state.long0 - Math.atan2(-p.x, p.y), state.over);
+        }
+      } else {
+        lon = adjust_lon(
+          state.long0 +
+            Math.atan2(p.x * sinz, rh * state.cos_p12 * cosz - p.y * state.sin_p12 * sinz),
+          state.over
+        );
+      }
+    }
+
+    p.x = lon;
+    p.y = lat;
+    return p;
+  } else {
+    e0 = e0fn(state.es);
+    e1 = e1fn(state.es);
+    e2 = e2fn(state.es);
+    e3 = e3fn(state.es);
+    if (Math.abs(state.sin_p12 - 1) <= EPSLN) {
+      // North pole case
+      Mlp = state.a * mlfn(e0, e1, e2, e3, HALF_PI);
+      rh = Math.sqrt(p.x * p.x + p.y * p.y);
+      M = Mlp - rh;
+      lat = imlfn(M / state.a, e0, e1, e2, e3);
+      lon = adjust_lon(state.long0 + Math.atan2(p.x, -1 * p.y), state.over);
+      p.x = lon;
+      p.y = lat;
+      return p;
+    } else if (Math.abs(state.sin_p12 + 1) <= EPSLN) {
+      // South pole case
+      Mlp = state.a * mlfn(e0, e1, e2, e3, HALF_PI);
+      rh = Math.sqrt(p.x * p.x + p.y * p.y);
+      M = rh - Mlp;
+
+      lat = imlfn(M / state.a, e0, e1, e2, e3);
+      lon = adjust_lon(state.long0 + Math.atan2(p.x, p.y), state.over);
+      p.x = lon;
+      p.y = lat;
+      return p;
+    } else {
+      // default case
+      azi1 = Math.atan2(p.x, p.y);
+      s12 = Math.sqrt(p.x * p.x + p.y * p.y);
+      vincentyDirect(state.lat0, state.long0, azi1, s12, state.a, state.f, p);
+      return p;
+    }
+  }
+}
+
+export function createState(base: KernelParameters): State {
+  const state: State = {
+    ...base,
+    sin_p12: 0,
+    cos_p12: 0,
+    f: 0
+  };
+  initialize(state);
+  return state;
+}

package/src/experimental/kernels/bonne.ts

@@ -0,0 +1,141 @@
+// 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 & {
+  phi1: number;
+  en: number[];
+  m1: number;
+  am1: number;
+  cphi1: number;
+};
+import adjust_lat from '../common/adjust_lat';
+import adjust_lon from '../common/adjust_lon';
+import hypot from '../common/hypot';
+import pj_enfn from '../common/pj_enfn';
+import pj_inv_mlfn from '../common/pj_inv_mlfn';
+import pj_mlfn from '../common/pj_mlfn';
+import {HALF_PI} from '../common/constants';
+
+var EPS10 = 1e-10;
+
+function initialize(state: State): void {
+  var c;
+
+  state.phi1 = state.lat1;
+  if (Math.abs(state.phi1) < EPS10) {
+    throw new Error();
+  }
+  if (state.es) {
+    state.en = pj_enfn(state.es);
+    state.am1 = Math.sin(state.phi1);
+    c = Math.cos(state.phi1);
+    state.m1 = pj_mlfn(state.phi1, state.am1, c, state.en);
+    state.am1 = c / (Math.sqrt(1 - state.es * state.am1 * state.am1) * state.am1);
+  } else {
+    if (Math.abs(state.phi1) + EPS10 >= HALF_PI) {
+      state.cphi1 = 0;
+    } else {
+      state.cphi1 = 1 / Math.tan(state.phi1);
+    }
+  }
+}
+
+function e_fwd(state: State, p: Point): Point {
+  var lam = adjust_lon(p.x - (state.long0 || 0), state.over);
+  var phi = p.y;
+  var rh, E, c;
+  E = Math.sin(phi);
+  c = Math.cos(phi);
+  rh = state.am1 + state.m1 - pj_mlfn(phi, E, c, state.en);
+  E = (c * lam) / (rh * Math.sqrt(1 - state.es * E * E));
+  p.x = rh * Math.sin(E);
+  p.y = state.am1 - rh * Math.cos(E);
+
+  p.x = state.a * p.x + (state.x0 || 0);
+  p.y = state.a * p.y + (state.y0 || 0);
+  return p;
+}
+
+function e_inv(state: State, p: Point): Point {
+  p.x = (p.x - (state.x0 || 0)) / state.a;
+  p.y = (p.y - (state.y0 || 0)) / state.a;
+
+  var s, rh, lam, phi;
+  p.y = state.am1 - p.y;
+  rh = hypot(p.x, p.y);
+  if (state.phi1 < 0) rh = -rh;
+  phi = pj_inv_mlfn(state.am1 + state.m1 - rh, state.es, state.en);
+  s = Math.abs(phi);
+  if (s < HALF_PI) {
+    s = Math.sin(phi);
+    lam =
+      (rh *
+        Math.atan2(Math.sign(state.phi1) * p.x, Math.sign(state.phi1) * p.y) *
+        Math.sqrt(1 - state.es * s * s)) /
+      Math.cos(phi);
+  } else if (Math.abs(s - HALF_PI) <= EPS10) {
+    lam = 0;
+  } else {
+    throw new Error();
+  }
+  p.x = adjust_lon(lam + (state.long0 || 0), state.over);
+  p.y = adjust_lat(phi);
+  return p;
+}
+
+function s_fwd(state: State, p: Point): Point {
+  var lam = adjust_lon(p.x - (state.long0 || 0), state.over);
+  var phi = p.y;
+  var E, rh;
+  rh = state.cphi1 + state.phi1 - phi;
+  if (Math.abs(rh) > EPS10) {
+    E = (lam * Math.cos(phi)) / rh;
+    p.x = rh * Math.sin(E);
+    p.y = state.cphi1 - rh * Math.cos(E);
+  } else {
+    p.x = p.y = 0;
+  }
+
+  p.x = state.a * p.x + (state.x0 || 0);
+  p.y = state.a * p.y + (state.y0 || 0);
+  return p;
+}
+
+function s_inv(state: State, p: Point): Point {
+  p.x = (p.x - (state.x0 || 0)) / state.a;
+  p.y = (p.y - (state.y0 || 0)) / state.a;
+
+  var lam, phi;
+  p.y = state.cphi1 - p.y;
+  var rh = hypot(p.x, p.y);
+  if (state.phi1 < 0) rh = -rh;
+  phi = state.cphi1 + state.phi1 - rh;
+  if (Math.abs(phi) > HALF_PI) {
+    throw new Error();
+  }
+  if (Math.abs(Math.abs(phi) - HALF_PI) <= EPS10) {
+    lam = 0;
+  } else {
+    lam =
+      (rh * Math.atan2(Math.sign(state.phi1) * p.x, Math.sign(state.phi1) * p.y)) / Math.cos(phi);
+  }
+  p.x = adjust_lon(lam + (state.long0 || 0), state.over);
+  p.y = adjust_lat(phi);
+  return p;
+}
+
+export function forward(state: State, p: Point): Point {
+  return state.es ? e_fwd(state, p) : s_fwd(state, p);
+}
+export function inverse(state: State, p: Point): Point {
+  return state.es ? e_inv(state, p) : s_inv(state, p);
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {...base, phi1: 0, en: [], m1: 0, am1: 0, cphi1: 0, ...options};
+  initialize(state);
+  return state;
+}