// Port of GeographicLib's geographiclib-geodesic 2.2.0 (src/Geodesic.js), MIT
// License, Copyright (c) Charles Karney (2011-2022). See NOTICE. Algorithms
// from C. F. F. Karney, Algorithms for geodesics, J. Geodesy 87, 43-55 (2013).

///|
const ORDER : Int32 = 6

///|
const MAXIT1 : Int32 = 20

///|
const MAXIT2 : Int32 = 83

///|
const TOL0 : Double = 2.220446049250313e-16

///|
const TOL1 : Double = 4.440892098500626e-14

///|
const TOL2 : Double = 1.4901161193847656e-8

///|
const XTHRESH : Double = 1.4901161193847656e-5

///|
/// sqrt of the smallest normal double, 2^-511.
const TINY : Double = 1.4916681462400413e-154

///|
const PI : Double = 3.141592653589793

///|
/// The positive root k of k^4 + 2k^3 - (x^2 + y^2 - 1)k^2 - 2y^2k - y^2 = 0.
fn astroid(trig : Trig, x : Double, y : Double) -> Double {
  let p = sq(x)
  let q = sq(y)
  let r = (p + q - 1.0) / 6.0
  if q == 0.0 && r <= 0.0 {
    return 0.0
  }
  let s = p * q / 4.0
  let r2 = sq(r)
  let r3 = r * r2
  let disc = s * (s + 2.0 * r3)
  let mut u = r
  if disc >= 0.0 {
    let mut t3 = s + r3
    t3 += if t3 < 0.0 { -disc.sqrt() } else { disc.sqrt() }
    let t = trig.cbrt(t3)
    u += t + (if t != 0.0 { r2 / t } else { 0.0 })
  } else {
    let ang = trig.atan2((-disc).sqrt(), -(s + r3))
    u += 2.0 * r * trig.cos(ang / 3.0)
  }
  let v = (sq(u) + q).sqrt()
  let uv = if u < 0.0 { q / (v - u) } else { u + v }
  let w = (uv - q) / (2.0 * v)
  uv / ((uv + sq(w)).sqrt() + w)
}

///|
/// An ellipsoid of revolution with geodesic problems solved on it: `a` is the
/// equatorial radius in meters and `f` the flattening.
pub struct Geodesic {
  a : Double
  f : Double
  priv f1 : Double
  priv e2 : Double
  priv ep2 : Double
  priv n : Double
  priv b : Double
  priv c2 : Double
  priv etol2 : Double
  priv a3x : FixedArray[Double]
  priv c3x : FixedArray[Double]
  priv c4x : FixedArray[Double]
  priv trig : Trig
}

///|
/// The ellipsoid with equatorial radius `a` (meters) and flattening `f`;
/// None unless both semi-axes are finite and positive.
pub fn Geodesic::new(
  a : Double,
  f : Double,
  trig~ : Trig = Trig::moonbit(),
) -> Geodesic? {
  let f1 = 1.0 - f
  let e2 = f * (2.0 - f)
  let b = a * f1
  if !(a > 0.0 && !a.is_inf() && b > 0.0 && !b.is_inf()) {
    return None
  }
  let n = f / (2.0 - f)
  let c2 = (
      sq(a) +
      sq(b) *
      (if e2 == 0.0 {
        1.0
      } else {
        (if e2 > 0.0 { trig.atanh(e2.sqrt()) } else { trig.atan((-e2).sqrt()) }) /
        e2.abs().sqrt()
      })
    ) /
    2.0
  let etol2 = 0.1 *
    TOL2 /
    (jmax(0.001, f.abs()) * jmin(1.0, 1.0 - f / 2.0) / 2.0).sqrt()
  let a3x = FixedArray::make(ORDER, 0.0)
  let mut o = 0
  let mut k = 0
  for j = ORDER - 1; j >= 0; j = j - 1 {
    let p = if ORDER - j - 1 < j { ORDER - j - 1 } else { j }
    a3x[k] = polyval(p, a3_coeff, o, n) / a3_coeff[o + p + 1]
    k += 1
    o += p + 2
  }
  let c3x = FixedArray::make(ORDER * (ORDER - 1) / 2, 0.0)
  o = 0
  k = 0
  for l in 1..= l; j = j - 1 {
      let p = if ORDER - j - 1 < j { ORDER - j - 1 } else { j }
      c3x[k] = polyval(p, c3_coeff, o, n) / c3_coeff[o + p + 1]
      k += 1
      o += p + 2
    }
  }
  let c4x = FixedArray::make(ORDER * (ORDER + 1) / 2, 0.0)
  o = 0
  k = 0
  for l in 0..= l; j = j - 1 {
      let p = ORDER - j - 1
      c4x[k] = polyval(p, c4_coeff, o, n) / c4_coeff[o + p + 1]
      k += 1
      o += p + 2
    }
  }
  Some({ a, f, f1, e2, ep2: e2 / sq(f1), n, b, c2, etol2, a3x, c3x, c4x, trig, })
}

///|
/// WGS 84's equatorial radius in meters.
pub const WGS84_A : Double = 6378137.0

///|
/// WGS 84's flattening.
pub const WGS84_F : Double = 0.0033528106647474805

///|
/// The WGS 84 ellipsoid.
pub fn Geodesic::wgs84(trig~ : Trig = Trig::moonbit()) -> Geodesic {
  Geodesic::new(WGS84_A, WGS84_F, trig~).unwrap()
}

///|
/// Scratch coefficient arrays of one solution (index 0 of `c1a`, `c2a` unused).
priv struct Coeffs {
  c1a : FixedArray[Double]
  c2a : FixedArray[Double]
  c3a : FixedArray[Double]
}

///|
fn Coeffs::new() -> Coeffs {
  {
    c1a: FixedArray::make(ORDER + 1, 0.0),
    c2a: FixedArray::make(ORDER + 1, 0.0),
    c3a: FixedArray::make(ORDER, 0.0),
  }
}

///|
/// `Lengths`: distance / b (`s12b`, when `distance`), reduced length / b
/// (`m12b`, NaN unless `reduced`) and the secular coefficient `m0`.
fn lengths(
  eps : Double,
  sig12 : Double,
  ssig1 : Double,
  csig1 : Double,
  dn1 : Double,
  ssig2 : Double,
  csig2 : Double,
  dn2 : Double,
  distance : Bool,
  reduced : Bool,
  c : Coeffs,
) -> (Double, Double, Double) {
  let mut m0x = 0.0
  let mut j12 = 0.0
  let mut a1 = 0.0
  let mut a2 = 0.0
  let mut s12b = nan
  a1 = a1m1f(eps)
  fourier(c1f_coeff, eps, c.c1a)
  if reduced {
    a2 = a2m1f(eps)
    fourier(c2f_coeff, eps, c.c2a)
    m0x = a1 - a2
    a2 = 1.0 + a2
  }
  a1 = 1.0 + a1
  if distance {
    let b1 = sin_cos_series(true, ssig2, csig2, c.c1a) -
      sin_cos_series(true, ssig1, csig1, c.c1a)
    s12b = a1 * (sig12 + b1)
    if reduced {
      let b2 = sin_cos_series(true, ssig2, csig2, c.c2a) -
        sin_cos_series(true, ssig1, csig1, c.c2a)
      j12 = m0x * sig12 + (a1 * b1 - a2 * b2)
    }
  } else if reduced {
    for l in 1..<=ORDER {
      c.c2a[l] = a1 * c.c1a[l] - a2 * c.c2a[l]
    }
    j12 = m0x * sig12 +
      (
        sin_cos_series(true, ssig2, csig2, c.c2a) -
        sin_cos_series(true, ssig1, csig1, c.c2a)
      )
  }
  let m12b = if reduced {
    dn2 * (csig1 * ssig2) - dn1 * (ssig1 * csig2) - csig1 * csig2 * j12
  } else {
    nan
  }
  (s12b, m12b, m0x)
}

///|
/// `InverseStart`'s result: `sig12` is -1 unless the line is short enough to
/// need no Newton's method, when `salp2`, `calp2` and `dnm` are set too.
priv struct Start {
  sig12 : Double
  salp1 : Double
  calp1 : Double
  salp2 : Double
  calp2 : Double
  dnm : Double
}

///|
fn Geodesic::inverse_start(
  self : Geodesic,
  sbet1 : Double,
  cbet1 : Double,
  dn1 : Double,
  sbet2 : Double,
  cbet2 : Double,
  dn2 : Double,
  lam12 : Double,
  slam12 : Double,
  clam12 : Double,
  c : Coeffs,
) -> Start {
  let trig = self.trig
  let mut sig12 = -1.0
  let mut salp2 = nan
  let mut calp2 = nan
  let mut dnm = nan
  let sbet12 = sbet2 * cbet1 - cbet2 * sbet1
  let cbet12 = cbet2 * cbet1 + sbet2 * sbet1
  let mut sbet12a = sbet2 * cbet1
  sbet12a += cbet2 * sbet1
  let shortline = cbet12 >= 0.0 && sbet12 < 0.5 && cbet2 * lam12 < 0.5
  let mut somg12 = slam12
  let mut comg12 = clam12
  if shortline {
    let mut sbetm2 = sq(sbet1 + sbet2)
    sbetm2 /= sbetm2 + sq(cbet1 + cbet2)
    dnm = (1.0 + self.ep2 * sbetm2).sqrt()
    let omg12 = lam12 / (self.f1 * dnm)
    somg12 = trig.sin(omg12)
    comg12 = trig.cos(omg12)
  }
  let mut salp1 = cbet2 * somg12
  let mut calp1 = if comg12 >= 0.0 {
    sbet12 + cbet2 * sbet1 * sq(somg12) / (1.0 + comg12)
  } else {
    sbet12a - cbet2 * sbet1 * sq(somg12) / (1.0 - comg12)
  }
  let ssig12 = hypot(salp1, calp1)
  let csig12 = sbet1 * sbet2 + cbet1 * cbet2 * comg12
  if shortline && ssig12 < self.etol2 {
    salp2 = cbet1 * somg12
    calp2 = sbet12 -
      cbet1 *
      sbet2 *
      (if comg12 >= 0.0 { sq(somg12) / (1.0 + comg12) } else { 1.0 - comg12 })
    let t = hypot(salp2, calp2)
    salp2 /= t
    calp2 /= t
    sig12 = trig.atan2(ssig12, csig12)
  } else if self.n.abs() > 0.1 ||
    csig12 >= 0.0 ||
    ssig12 >= 6.0 * self.n.abs() * PI * sq(cbet1) {
    ()
  } else {
    let lam12x = trig.atan2(-slam12, -clam12)
    let mut x = 0.0
    let mut y = 0.0
    let mut lamscale = 0.0
    if self.f >= 0.0 {
      let k2 = sq(sbet1) * self.ep2
      let eps = k2 / (2.0 * (1.0 + (1.0 + k2).sqrt()) + k2)
      lamscale = self.f * cbet1 * self.a3f(eps) * PI
      let betscale = lamscale * cbet1
      x = lam12x / lamscale
      y = sbet12a / betscale
    } else {
      let cbet12a = cbet2 * cbet1 - sbet2 * sbet1
      let bet12a = trig.atan2(sbet12a, cbet12a)
      let (_, m12b, m0) = lengths(
        self.n,
        PI + bet12a,
        sbet1,
        -cbet1,
        dn1,
        sbet2,
        cbet2,
        dn2,
        false,
        true,
        c,
      )
      x = -1.0 + m12b / (cbet1 * cbet2 * m0 * PI)
      let betscale = if x < -0.01 {
        sbet12a / x
      } else {
        -self.f * sq(cbet1) * PI
      }
      lamscale = betscale / cbet1
      y = lam12 / lamscale
    }
    if y > -TOL1 && x > -1.0 - XTHRESH {
      if self.f >= 0.0 {
        salp1 = jmin(1.0, -x)
        calp1 = -(1.0 - sq(salp1)).sqrt()
      } else {
        calp1 = jmax(if x > -TOL1 { 0.0 } else { -1.0 }, x)
        salp1 = (1.0 - sq(calp1)).sqrt()
      }
    } else {
      let k = astroid(trig, x, y)
      let omg12a = lamscale *
        (if self.f >= 0.0 { -x * k / (1.0 + k) } else { -y * (1.0 + k) / k })
      somg12 = trig.sin(omg12a)
      comg12 = -trig.cos(omg12a)
      salp1 = cbet2 * somg12
      calp1 = sbet12a - cbet2 * sbet1 * sq(somg12) / (1.0 - comg12)
    }
  }
  if !(salp1 <= 0.0) {
    let t = hypot(salp1, calp1)
    salp1 /= t
    calp1 /= t
  } else {
    salp1 = 1.0
    calp1 = 0.0
  }
  { sig12, salp1, calp1, salp2, calp2, dnm, }
}

///|
/// `Lambda12`'s result for one guess of alp1.
priv struct Lambda {
  lam12 : Double
  salp2 : Double
  calp2 : Double
  sig12 : Double
  ssig1 : Double
  csig1 : Double
  ssig2 : Double
  csig2 : Double
  eps : Double
  domg12 : Double
  dlam12 : Double
}

///|
fn Geodesic::lambda12(
  self : Geodesic,
  sbet1 : Double,
  cbet1 : Double,
  dn1 : Double,
  sbet2 : Double,
  cbet2 : Double,
  dn2 : Double,
  salp1 : Double,
  calp1 : Double,
  slam120 : Double,
  clam120 : Double,
  diffp : Bool,
  c : Coeffs,
) -> Lambda {
  let trig = self.trig
  let calp1 = if sbet1 == 0.0 && calp1 == 0.0 { -TINY } else { calp1 }
  let salp0 = salp1 * cbet1
  let calp0 = hypot(calp1, salp1 * sbet1)
  let mut ssig1 = sbet1
  let somg1 = salp0 * sbet1
  let comg1 = calp1 * cbet1
  let mut csig1 = comg1
  let t = hypot(ssig1, csig1)
  ssig1 /= t
  csig1 /= t
  let salp2 = if cbet2 != cbet1 { salp0 / cbet2 } else { salp1 }
  let calp2 = if cbet2 != cbet1 || sbet2.abs() != -sbet1 {
    (sq(calp1 * cbet1) +
    (if cbet1 < -sbet1 {
      (cbet2 - cbet1) * (cbet1 + cbet2)
    } else {
      (sbet1 - sbet2) * (sbet1 + sbet2)
    })).sqrt() /
    cbet2
  } else {
    calp1.abs()
  }
  let mut ssig2 = sbet2
  let somg2 = salp0 * sbet2
  let comg2 = calp2 * cbet2
  let mut csig2 = comg2
  let t = hypot(ssig2, csig2)
  ssig2 /= t
  csig2 /= t
  let sig12 = trig.atan2(
    jmax(0.0, csig1 * ssig2 - ssig1 * csig2),
    csig1 * csig2 + ssig1 * ssig2,
  )
  let somg12 = jmax(0.0, comg1 * somg2 - somg1 * comg2)
  let comg12 = comg1 * comg2 + somg1 * somg2
  let eta = trig.atan2(
    somg12 * clam120 - comg12 * slam120,
    comg12 * clam120 + somg12 * slam120,
  )
  let k2 = sq(calp0) * self.ep2
  let eps = k2 / (2.0 * (1.0 + (1.0 + k2).sqrt()) + k2)
  self.c3f(eps, c.c3a)
  let b312 = sin_cos_series(true, ssig2, csig2, c.c3a) -
    sin_cos_series(true, ssig1, csig1, c.c3a)
  let domg12 = -self.f * self.a3f(eps) * salp0 * (sig12 + b312)
  let lam12 = eta + domg12
  let dlam12 = if !diffp {
    nan
  } else if calp2 == 0.0 {
    -2.0 * self.f1 * dn1 / sbet1
  } else {
    let (_, m12b, _) = lengths(
      eps, sig12, ssig1, csig1, dn1, ssig2, csig2, dn2, false, true, c,
    )
    m12b * (self.f1 / (calp2 * cbet2))
  }
  {
    lam12,
    salp2,
    calp2,
    sig12,
    ssig1,
    csig1,
    ssig2,
    csig2,
    eps,
    domg12,
    dlam12,
  }
}

///|
/// An inverse problem's solution: `s12` meters, `azi1` and `azi2` degrees at
/// each end, `a12` the arc in degrees, `area` (S12) square meters between the
/// geodesic and the equator (NaN unless asked for).
pub(all) struct Inverse {
  s12 : Double
  azi1 : Double
  azi2 : Double
  a12 : Double
  area : Double
}

///|
/// `InverseInt`, with the sines and cosines of the azimuths.
priv struct InverseSolution {
  s12 : Double
  a12 : Double
  area : Double
  salp1 : Double
  calp1 : Double
  salp2 : Double
  calp2 : Double
}

///|
fn Geodesic::inverse_int(
  self : Geodesic,
  lat1 : Double,
  lon1 : Double,
  lat2 : Double,
  lon2 : Double,
  area : Bool,
) -> InverseSolution {
  let trig = self.trig
  let mut lat1 = ang_round(lat_fix(lat1))
  let mut lat2 = ang_round(lat_fix(lat2))
  let (lon12, lon12s) = ang_diff(lon1, lon2)
  let mut lonsign = copysign(1.0, lon12)
  let lon12 = lon12 * lonsign
  let lon12s = lon12s * lonsign
  let lam12 = lon12 * DEGREE
  let (slam12, clam12) = sincosde(trig, lon12, lon12s, true)
  let lon12s = 180.0 - lon12 - lon12s
  let swapp = if lat1.abs() < lat2.abs() || lat2.is_nan() { -1.0 } else { 1.0 }
  if swapp < 0.0 {
    lonsign *= -1.0
    let t = lat1
    lat1 = lat2
    lat2 = t
  }
  let latsign = copysign(1.0, -lat1)
  lat1 *= latsign
  lat2 *= latsign
  let (s, c) = sincosd(trig, lat1)
  let mut sbet1 = self.f1 * s
  let mut cbet1 = c
  let t = hypot(sbet1, cbet1)
  sbet1 /= t
  cbet1 /= t
  cbet1 = jmax(TINY, cbet1)
  let (s, c) = sincosd(trig, lat2)
  let mut sbet2 = self.f1 * s
  let mut cbet2 = c
  let t = hypot(sbet2, cbet2)
  sbet2 /= t
  cbet2 /= t
  cbet2 = jmax(TINY, cbet2)
  if cbet1 < -sbet1 {
    if cbet2 == cbet1 {
      sbet2 = copysign(sbet1, sbet2)
    }
  } else if sbet2.abs() == -sbet1 {
    cbet2 = cbet1
  }
  let dn1 = (1.0 + self.ep2 * sq(sbet1)).sqrt()
  let dn2 = (1.0 + self.ep2 * sq(sbet2)).sqrt()
  let coeffs = Coeffs::new()
  let mut a12 = nan
  let mut s12x = nan
  let mut sig12 = 0.0
  let mut salp1 = 0.0
  let mut calp1 = 0.0
  let mut salp2 = 0.0
  let mut calp2 = 0.0
  let mut omg12 = 0.0
  let mut somg12 = 2.0
  let mut comg12 = 0.0
  let mut meridian = lat1 == -90.0 || slam12 == 0.0
  if meridian {
    calp1 = clam12
    salp1 = slam12
    calp2 = 1.0
    salp2 = 0.0
    let ssig1 = sbet1
    let csig1 = calp1 * cbet1
    let ssig2 = sbet2
    let csig2 = calp2 * cbet2
    sig12 = trig.atan2(
      jmax(0.0, csig1 * ssig2 - ssig1 * csig2),
      csig1 * csig2 + ssig1 * ssig2,
    )
    let (s12b, m12b, _) = lengths(
      self.n,
      sig12,
      ssig1,
      csig1,
      dn1,
      ssig2,
      csig2,
      dn2,
      true,
      true,
      coeffs,
    )
    let mut s12b = s12b
    let mut m12x = m12b
    if sig12 < TOL2 || m12x >= 0.0 {
      if sig12 < 3.0 * TINY || (sig12 < TOL0 && (s12b < 0.0 || m12x < 0.0)) {
        sig12 = 0.0
        m12x = 0.0
        s12b = 0.0
      }
      s12x = s12b * self.b
      a12 = sig12 / DEGREE
    } else {
      meridian = false
    }
  }
  if !meridian && sbet1 == 0.0 && (self.f <= 0.0 || lon12s >= self.f * 180.0) {
    calp1 = 0.0
    calp2 = 0.0
    salp1 = 1.0
    salp2 = 1.0
    s12x = self.a * lam12
    sig12 = lam12 / self.f1
    omg12 = sig12
    a12 = lon12 / self.f1
  } else if !meridian {
    let start = self.inverse_start(
      sbet1, cbet1, dn1, sbet2, cbet2, dn2, lam12, slam12, clam12, coeffs,
    )
    sig12 = start.sig12
    salp1 = start.salp1
    calp1 = start.calp1
    if sig12 >= 0.0 {
      salp2 = start.salp2
      calp2 = start.calp2
      let dnm = start.dnm
      s12x = sig12 * self.b * dnm
      a12 = sig12 / DEGREE
      omg12 = lam12 / (self.f1 * dnm)
    } else {
      let mut numit = 0
      let mut salp1a = TINY
      let mut calp1a = 1.0
      let mut salp1b = TINY
      let mut calp1b = -1.0
      let mut tripn = false
      let mut tripb = false
      let mut l = self.lambda12(
        sbet1,
        cbet1,
        dn1,
        sbet2,
        cbet2,
        dn2,
        salp1,
        calp1,
        slam12,
        clam12,
        numit < MAXIT1,
        coeffs,
      )
      while !(tripb ||
            !(l.lam12.abs() >= (if tripn { 8.0 } else { 1.0 }) * TOL0) ||
            numit == MAXIT2) {
        let v = l.lam12
        let dv = l.dlam12
        if v > 0.0 && (numit < MAXIT1 || calp1 / salp1 > calp1b / salp1b) {
          salp1b = salp1
          calp1b = calp1
        } else if v < 0.0 && (numit < MAXIT1 || calp1 / salp1 < calp1a / salp1a) {
          salp1a = salp1
          calp1a = calp1
        }
        let mut newton = false
        if numit < MAXIT1 && dv > 0.0 {
          let dalp1 = -v / dv
          if dalp1.abs() < PI {
            let sdalp1 = trig.sin(dalp1)
            let cdalp1 = trig.cos(dalp1)
            let nsalp1 = salp1 * cdalp1 + calp1 * sdalp1
            if nsalp1 > 0.0 {
              calp1 = calp1 * cdalp1 - salp1 * sdalp1
              salp1 = nsalp1
              let t = hypot(salp1, calp1)
              salp1 /= t
              calp1 /= t
              tripn = v.abs() <= 16.0 * TOL0
              newton = true
            }
          }
        }
        if !newton {
          salp1 = (salp1a + salp1b) / 2.0
          calp1 = (calp1a + calp1b) / 2.0
          let t = hypot(salp1, calp1)
          salp1 /= t
          calp1 /= t
          tripn = false
          tripb = (salp1a - salp1).abs() + (calp1a - calp1) < TOL0 ||
            (salp1 - salp1b).abs() + (calp1 - calp1b) < TOL0
        }
        numit += 1
        l = self.lambda12(
          sbet1,
          cbet1,
          dn1,
          sbet2,
          cbet2,
          dn2,
          salp1,
          calp1,
          slam12,
          clam12,
          numit < MAXIT1,
          coeffs,
        )
      }
      salp2 = l.salp2
      calp2 = l.calp2
      sig12 = l.sig12
      let (s12b, _, _) = lengths(
        l.eps,
        sig12,
        l.ssig1,
        l.csig1,
        dn1,
        l.ssig2,
        l.csig2,
        dn2,
        true,
        false,
        coeffs,
      )
      s12x = s12b * self.b
      a12 = sig12 / DEGREE
      if area {
        let sdomg12 = trig.sin(l.domg12)
        let cdomg12 = trig.cos(l.domg12)
        somg12 = slam12 * cdomg12 - clam12 * sdomg12
        comg12 = clam12 * cdomg12 + slam12 * sdomg12
      }
    }
  }
  let s12 = 0.0 + s12x
  let mut s12_area = nan
  if area {
    let salp0 = salp1 * cbet1
    let calp0 = hypot(calp1, salp1 * sbet1)
    s12_area = if calp0 != 0.0 && salp0 != 0.0 {
      let mut ssig1 = sbet1
      let mut csig1 = calp1 * cbet1
      let mut ssig2 = sbet2
      let mut csig2 = calp2 * cbet2
      let k2 = sq(calp0) * self.ep2
      let eps = k2 / (2.0 * (1.0 + (1.0 + k2).sqrt()) + k2)
      let a4 = sq(self.a) * calp0 * salp0 * self.e2
      let t = hypot(ssig1, csig1)
      ssig1 /= t
      csig1 /= t
      let t = hypot(ssig2, csig2)
      ssig2 /= t
      csig2 /= t
      let c4a = FixedArray::make(ORDER, 0.0)
      self.c4f(eps, c4a)
      let b41 = sin_cos_series(false, ssig1, csig1, c4a)
      let b42 = sin_cos_series(false, ssig2, csig2, c4a)
      a4 * (b42 - b41)
    } else {
      0.0
    }
    if !meridian && somg12 == 2.0 {
      somg12 = trig.sin(omg12)
      comg12 = trig.cos(omg12)
    }
    let alp12 = if !meridian && comg12 > -0.7071 && sbet2 - sbet1 < 1.75 {
      let domg12 = 1.0 + comg12
      let dbet1 = 1.0 + cbet1
      let dbet2 = 1.0 + cbet2
      2.0 *
      trig.atan2(
        somg12 * (sbet1 * dbet2 + sbet2 * dbet1),
        domg12 * (sbet1 * sbet2 + dbet1 * dbet2),
      )
    } else {
      let mut salp12 = salp2 * calp1 - calp2 * salp1
      let mut calp12 = calp2 * calp1 + salp2 * salp1
      if salp12 == 0.0 && calp12 < 0.0 {
        salp12 = TINY * calp1
        calp12 = -1.0
      }
      trig.atan2(salp12, calp12)
    }
    s12_area += self.c2 * alp12
    s12_area *= swapp * lonsign * latsign
    s12_area += 0.0
  }
  if swapp < 0.0 {
    let t = salp1
    salp1 = salp2
    salp2 = t
    let t = calp1
    calp1 = calp2
    calp2 = t
  }
  salp1 *= swapp * lonsign
  calp1 *= swapp * latsign
  salp2 *= swapp * lonsign
  calp2 *= swapp * latsign
  { s12, a12, area: s12_area, salp1, calp1, salp2, calp2, }
}

///|
/// Solves the inverse problem between two points (degrees); `area` asks for
/// S12 too.
pub fn Geodesic::inverse(
  self : Geodesic,
  lat1 : Double,
  lon1 : Double,
  lat2 : Double,
  lon2 : Double,
  area~ : Bool = false,
) -> Inverse {
  let r = self.inverse_int(lat1, lon1, lat2, lon2, area)
  {
    s12: r.s12,
    azi1: atan2d(self.trig, r.salp1, r.calp1),
    azi2: atan2d(self.trig, r.salp2, r.calp2),
    a12: r.a12,
    area: r.area,
  }
}