ootk 3.0.0 → 4.0.0-1

package/src/force/SolarRadiationPressure.ts

@@ -0,0 +1,42 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2020-2024 Theodore Kruczek
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { astronomicalUnit, J2000, Sun, Vector3D } from 'ootk-core';
+import { Force } from './Force';
+
+// / Solar radiation pressure model.
+export class SolarRadiationPressure extends Force {
+  // / Create a new [SolarRadiationPressure] object.
+  constructor(public mass: number, public area: number, public reflectCoeff: number) {
+    super();
+  }
+
+  // / Solar pressure _(N/m²)_;
+  private static readonly _kRef: number = 4.56e-6 * astronomicalUnit ** 2;
+
+  acceleration(state: J2000): Vector3D {
+    const rSun = Sun.positionApparent(state.epoch);
+    const r = state.position.subtract(rSun);
+    const rMag = r.magnitude();
+    const r2 = rMag * rMag;
+    const ratio = Sun.lightingRatio(state.position, rSun);
+    const p = (ratio * SolarRadiationPressure._kRef) / r2;
+    const flux = r.scale(p / rMag);
+
+    return flux.scale(((this.area * this.reflectCoeff) / this.mass) * 1e-3);
+  }
+}

package/src/force/ThirdBodyGravity.ts

@@ -0,0 +1,62 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2020-2024 Theodore Kruczek
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { J2000, Moon, Sun, Vector3D } from 'ootk-core';
+import { Force } from './Force';
+
+// / Third-body gravity model.
+export class ThirdBodyGravity implements Force {
+  // / Create a new [ThirdBodyGravity] object with the selected bodies enabled.
+  constructor(public moon: boolean = false, public sun: boolean = false) {
+    // Nothing to do here.
+  }
+
+  private static _moonGravity(state: J2000): Vector3D {
+    const rMoon = Moon.eci(state.epoch);
+    const aNum = rMoon.subtract(state.position);
+    const aDen = aNum.magnitude() ** 3;
+    const bNum = rMoon;
+    const bDen = rMoon.magnitude() ** 3;
+    const gravity = aNum.scale(1 / aDen).add(bNum.scale(-1 / bDen));
+
+    return gravity.scale(Moon.mu);
+  }
+
+  private static _sunGravity(state: J2000): Vector3D {
+    const rSun = Sun.positionApparent(state.epoch);
+    const aNum = rSun.subtract(state.position);
+    const aDen = aNum.magnitude() ** 3;
+    const bNum = rSun;
+    const bDen = rSun.magnitude() ** 3;
+    const gravity = aNum.scale(1 / aDen).add(bNum.scale(-1 / bDen));
+
+    return gravity.scale(Sun.mu);
+  }
+
+  acceleration(state: J2000): Vector3D {
+    let accVec = Vector3D.origin;
+
+    if (this.moon) {
+      accVec = accVec.add(ThirdBodyGravity._moonGravity(state));
+    }
+    if (this.sun) {
+      accVec = accVec.add(ThirdBodyGravity._sunGravity(state));
+    }
+
+    return accVec;
+  }
+}

package/src/force/Thrust.ts

@@ -0,0 +1,83 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2020-2024 Theodore Kruczek
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import {
+  EpochUTC,
+  J2000,
+  Kilometers,
+  KilometersPerSecond,
+  MetersPerSecond,
+  RIC,
+  Seconds,
+  SecondsPerMeterPerSecond,
+  Vector3D,
+} from 'ootk-core';
+import { Force } from './Force';
+
+// / Thrust force model.
+export class Thrust implements Force {
+  constructor(
+    public center: EpochUTC,
+    public radial: MetersPerSecond,
+    public intrack: MetersPerSecond,
+    public crosstrack: MetersPerSecond,
+    public durationRate = 0.0 as SecondsPerMeterPerSecond,
+  ) {
+    this.deltaV = new Vector3D<KilometersPerSecond>(
+      radial * 1e-3 as KilometersPerSecond,
+      intrack * 1e-3 as KilometersPerSecond,
+      crosstrack * 1e-3 as KilometersPerSecond,
+    );
+  }
+
+  deltaV: Vector3D<KilometersPerSecond>;
+
+  get magnitude(): MetersPerSecond {
+    return this.deltaV.magnitude() * 1000.0 as MetersPerSecond;
+  }
+
+  get duration(): Seconds {
+    return this.magnitude * this.durationRate as Seconds;
+  }
+
+  get start(): EpochUTC {
+    return this.center.roll(-0.5 * this.duration as Seconds);
+  }
+
+  get stop(): EpochUTC {
+    return this.center.roll(0.5 * this.duration as Seconds);
+  }
+
+  acceleration(state: J2000): Vector3D {
+    const relative = new RIC(
+      Vector3D.origin as Vector3D<Kilometers>,
+      this.deltaV.scale(1.0 / this.duration as KilometersPerSecond),
+    );
+
+    return relative.toJ2000(state).velocity.subtract(state.velocity);
+  }
+
+  apply(state: J2000): J2000 {
+    const relative = new RIC(Vector3D.origin as Vector3D<Kilometers>, this.deltaV);
+
+    return relative.toJ2000(state);
+  }
+
+  get isImpulsive(): boolean {
+    return this.duration <= 0;
+  }
+}

package/src/interfaces/RfSensorParams.ts

@@ -0,0 +1,30 @@
+/**
+ * @author Theodore Kruczek.
+ * @license MIT
+ * @copyright (c) 2022-2024 Theodore Kruczek Permission is
+ * hereby granted, free of charge, to any person obtaining a copy of this
+ * software and associated documentation files (the "Software"), to deal in the
+ * Software without restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { Degrees, SensorParams } from 'ootk-core';
+
+export interface RfSensorParams extends SensorParams {
+  coneHalfAngle: Degrees;
+  boresightAz: Degrees;
+  boresightEl: Degrees;
+}

package/src/interfaces/index.ts

@@ -0,0 +1 @@
+export type { RfSensorParams } from './RfSensorParams';

package/src/interpolator/ChebyshevCoefficients.ts

@@ -0,0 +1,109 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2020-2024 Theodore Kruczek
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { Kilometers, KilometersPerSecond, PositionVelocity, Seconds, Vector3D } from 'ootk-core';
+
+// / Chebyshev compressed ephemeris coefficients.
+export class ChebyshevCoefficients {
+  cxd_: Float64Array;
+  cyd_: Float64Array;
+  czd_: Float64Array;
+  // / Create a new [ChebyshevCoefficients] object.
+  constructor(
+    public a: Seconds,
+    public b: Seconds,
+    private cx_: Float64Array,
+    private cy_: Float64Array,
+    private cz_: Float64Array,
+  ) {
+    this.cxd_ = ChebyshevCoefficients._derivative(a, b, cx_);
+    this.cyd_ = ChebyshevCoefficients._derivative(a, b, cy_);
+    this.czd_ = ChebyshevCoefficients._derivative(a, b, cz_);
+  }
+
+  /**
+   * Calculates the derivative of a polynomial represented by Chebyshev coefficients.
+   * @param a - The lower bound of the polynomial's domain.
+   * @param b - The upper bound of the polynomial's domain.
+   * @param c - The Chebyshev coefficients of the polynomial.
+   * @returns The derivative of the polynomial as an array of coefficients.
+   */
+  private static _derivative(a: number, b: number, c: Float64Array): Float64Array {
+    const n = c.length;
+    const d = new Float64Array(n);
+
+    d[n - 1] = 0;
+    d[n - 2] = 2 * (n - 1) * c[n - 1];
+    for (let k = n - 3; k >= 0; k--) {
+      d[k] = d[k + 2] + 2 * (k + 1) * c[k + 1];
+    }
+    for (let k = 0; k < n; k++) {
+      d[k] *= 2 / (b - a);
+    }
+
+    return d;
+  }
+
+  // / Return the size _(bytes)_ of this coefficient set's cached data.
+  get sizeBytes(): number {
+    return (64 * 2 + 64 * 3 * this.cx_.length) / 8;
+  }
+
+  /**
+   * Evaluates the Chebyshev polynomial represented by the given coefficients at the specified value.
+   * @param c - The coefficients of the Chebyshev polynomial.
+   * @param t - The value at which to evaluate the polynomial _(POSIX seconds)_.
+   * @returns The result of evaluating the polynomial at the specified value.
+   */
+  evaluate(c: Float64Array, t: number): number {
+    const n = c.length;
+    const x = (t - 0.5 * (this.b + this.a)) / (0.5 * (this.b - this.a));
+    const alpha = 2 * x;
+    const beta = -1;
+    let y1 = 0.0;
+    let y2 = 0.0;
+
+    for (let k = n - 1; k >= 1; k--) {
+      const tmp = y1;
+
+      y1 = alpha * y1 + beta * y2 + c[k];
+      y2 = tmp;
+    }
+
+    return x * y1 - y2 + 0.5 * c[0];
+  }
+
+  /**
+   * Interpolates the position and velocity at a given time (km, km/s).
+   * @param t - The time value to interpolate at _(POSIX seconds)_.
+   * @returns An object containing the interpolated position and velocity.
+   */
+  interpolate(t: number): PositionVelocity {
+    const pos = new Vector3D(
+      this.evaluate(this.cx_, t) as Kilometers,
+      this.evaluate(this.cy_, t) as Kilometers,
+      this.evaluate(this.cz_, t) as Kilometers,
+    );
+    const vel = new Vector3D(
+      this.evaluate(this.cxd_, t) as KilometersPerSecond,
+      this.evaluate(this.cyd_, t) as KilometersPerSecond,
+      this.evaluate(this.czd_, t) as KilometersPerSecond,
+    );
+
+    return { position: pos, velocity: vel };
+  }
+}

package/src/interpolator/ChebyshevInterpolator.ts

@@ -0,0 +1,87 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2020-2024 Theodore Kruczek
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { EpochUTC, EpochWindow, J2000 } from 'ootk-core';
+import { ChebyshevCoefficients } from './ChebyshevCoefficients';
+import { StateInterpolator } from './StateInterpolator';
+
+/**
+ * Compressed Chebyshev ephemeris interpolator.
+ *
+ * The ChebyshevInterpolator sacrifices state accuracy in order to gain
+ * speed and memory requirements, so you can store many ephemerides in RAM
+ * and interpolate through them quickly.
+ *
+ * Using more coefficients per revolution during lossy compression results
+ * in increased accuracy and decreased performance.
+ */
+export class ChebyshevInterpolator extends StateInterpolator {
+  private _coefficients: ChebyshevCoefficients[];
+
+  constructor(coefficients: ChebyshevCoefficients[]) {
+    super();
+    this._coefficients = coefficients;
+  }
+
+  private _calcSizeBytes(): number {
+    let output = 0;
+
+    for (const coeffs of this._coefficients) {
+      output += coeffs.sizeBytes;
+    }
+
+    return output;
+  }
+
+  get sizeBytes(): number {
+    return this._calcSizeBytes();
+  }
+
+  interpolate(epoch: EpochUTC): J2000 | null {
+    if (!this.inWindow(epoch)) {
+      return null;
+    }
+    const coeffs = this._matchCoefficients(epoch.posix);
+    const { position: pos, velocity: vel } = coeffs.interpolate(epoch.posix);
+
+    return new J2000(epoch, pos, vel);
+  }
+
+  window(): EpochWindow {
+    return new EpochWindow(
+      new EpochUTC(this._coefficients[0].a),
+      new EpochUTC(this._coefficients[this._coefficients.length - 1].b),
+    );
+  }
+
+  private _matchCoefficients(posix: number): ChebyshevCoefficients {
+    let left = 0;
+    let right = this._coefficients.length;
+
+    while (left < right) {
+      const middle = (left + right) >> 1;
+
+      if (this._coefficients[middle].b < posix) {
+        left = middle + 1;
+      } else {
+        right = middle;
+      }
+    }
+
+    return this._coefficients[left];
+  }
+}

package/src/interpolator/CubicSpline.ts

@@ -0,0 +1,72 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2020-2024 Theodore Kruczek
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { Kilometers, KilometersPerSecond, Seconds, Vector3D } from 'ootk-core';
+
+// / Container for cubic spline data.
+export class CubicSpline {
+  // / Create a new [CubicSpline] object.
+  constructor(
+    public t0: Seconds,
+    public p0: Vector3D,
+    public m0: Vector3D,
+    public t1: Seconds,
+    public p1: Vector3D,
+    public m1: Vector3D,
+  ) {
+    // Nothing to do here.
+  }
+
+  // / Interpolate position at the provided time [t] _(POSIX seconds)_.
+  private position_(t: Seconds): Vector3D<Kilometers> {
+    const t2 = t * t;
+    const t3 = t2 * t;
+    const r0 = this.p0.scale(2 * t3 - 3 * t2 + 1);
+    const v0 = this.m0.scale((t3 - 2 * t2 + t) * (this.t1 - this.t0));
+    const r1 = this.p1.scale(-2 * t3 + 3 * t2);
+    const v1 = this.m1.scale((t3 - t2) * (this.t1 - this.t0));
+
+    return r0.add(v0).add(r1).add(v1) as Vector3D<Kilometers>;
+  }
+
+  // / Interpolate velocity at the provided time [t] _(POSIX seconds)_.
+  private velocity_(t: Seconds): Vector3D<KilometersPerSecond> {
+    const t2 = t * t;
+    const r0 = this.p0.scale(6 * t2 - 6 * t);
+    const v0 = this.m0.scale((3 * t2 - 4 * t + 1) * (this.t1 - this.t0));
+    const r1 = this.p1.scale(-6 * t2 + 6 * t);
+    const v1 = this.m1.scale((3 * t2 - 2 * t) * (this.t1 - this.t0));
+
+    return r0
+      .add(v0)
+      .add(r1)
+      .add(v1)
+      .scale(1 / (this.t1 - this.t0)) as Vector3D<KilometersPerSecond>;
+  }
+
+  /**
+   * Interpolates the position and velocity at a given time.
+   * (km) and velocity (km/s) vectors at the provided time.
+   * @param t The time value to interpolate at _(POSIX seconds)_.
+   * @returns An array containing the interpolated position and velocity as Vector3D objects.
+   */
+  interpolate(t: Seconds): Vector3D[] {
+    const n = (t - this.t0) / (this.t1 - this.t0) as Seconds;
+
+    return [this.position_(n), this.velocity_(n)];
+  }
+}

package/src/interpolator/CubicSplineInterpolator.ts

@@ -0,0 +1,90 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2020-2024 Theodore Kruczek
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { EpochUTC, EpochWindow, J2000, Kilometers, KilometersPerSecond, Vector3D } from 'ootk-core';
+import { CubicSpline } from './CubicSpline';
+import { StateInterpolator } from './StateInterpolator';
+
+/**
+ * Cubic spline ephemeris interpolator.
+ *
+ * The [CubicSplineInterpolator] is a very fast and accurate interpolator
+ * at the expense of memory due to the cached spline pairs used in the
+ * interpolation operation. Accuracy is significantly impacted when using
+ * sparse ephemerides.
+ */
+export class CubicSplineInterpolator extends StateInterpolator {
+  constructor(private _splines: CubicSpline[]) {
+    super();
+  }
+
+  static fromEphemeris(ephemeris: J2000[]): CubicSplineInterpolator {
+    const splines: CubicSpline[] = [];
+
+    for (let i = 0; i < ephemeris.length - 1; i++) {
+      const e0 = ephemeris[i];
+      const t0 = e0.epoch.posix;
+      const p0 = e0.position;
+      const m0 = e0.velocity;
+      const e1 = ephemeris[i + 1];
+      const t1 = e1.epoch.posix;
+      const p1 = e1.position;
+      const m1 = e1.velocity;
+
+      splines.push(new CubicSpline(t0, p0, m0, t1, p1, m1));
+    }
+
+    return new CubicSplineInterpolator(splines);
+  }
+
+  get sizeBytes(): number {
+    return (64 * 14 * this._splines.length) / 8;
+  }
+
+  private matchSpline_(posix: number): CubicSpline {
+    let left = 0;
+    let right = this._splines.length;
+
+    while (left < right) {
+      const middle = (left + right) >> 1;
+
+      if (this._splines[middle].t1 < posix) {
+        left = middle + 1;
+      } else {
+        right = middle;
+      }
+    }
+
+    return this._splines[left];
+  }
+
+  interpolate(epoch: EpochUTC): J2000 | null {
+    if (!this.inWindow(epoch)) {
+      return null;
+    }
+    const posix = epoch.posix;
+    const splineVecs = this
+      .matchSpline_(posix)
+      .interpolate(posix) as [Vector3D<Kilometers>, Vector3D<KilometersPerSecond>];
+
+    return new J2000(epoch, splineVecs[0], splineVecs[1]);
+  }
+
+  window(): EpochWindow {
+    return new EpochWindow(new EpochUTC(this._splines[0].t0), new EpochUTC(this._splines[this._splines.length - 1].t1));
+  }
+}

package/src/interpolator/FieldInterpolator.ts

@@ -0,0 +1,37 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2020-2024 Theodore Kruczek
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable class-methods-use-this */
+
+import { Interpolator } from './Interpolator';
+
+// / Base class for arbitrary field interpolators.
+export abstract class FieldInterpolator extends Interpolator {
+  Float64List?: Float64Array;
+
+  /**
+   * Interpolate field values at the provided [epoch].
+   * @param final Final state vector.
+   * @param EpochUTC Epoch of the final state vector.
+   * @param epoch Epoch to interpolate field values at.
+   * @throws [Error] if the interpolator is not initialized.
+   */
+  interpolate(final: unknown, EpochUTC: unknown, epoch: unknown) {
+    throw new Error('Method not implemented.');
+  }
+}

package/src/interpolator/Interpolator.ts

@@ -0,0 +1,56 @@
+/**
+ * @author @thkruz Theodore Kruczek
+ * @license AGPL-3.0-or-later
+ * @copyright (c) 2020-2024 Theodore Kruczek
+ *
+ * Orbital Object ToolKit is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free Software
+ * Foundation, either version 3 of the License, or (at your option) any later version.
+ *
+ * Orbital Object ToolKit is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License along with
+ * Orbital Object ToolKit. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import { EpochUTC, EpochWindow, Seconds } from 'ootk-core';
+
+// / Interpolator base class.
+export abstract class Interpolator {
+  // Return the start and end epoch covered by this interpolator.
+  abstract window(): EpochWindow;
+
+  /*
+   * Return `true` if the provided [epoch] is within this interpolator's
+   * cached value range.
+   */
+  inWindow(epoch: EpochUTC): boolean {
+    const start = this.window().start;
+    const stop = this.window().end;
+
+    return start <= epoch && epoch <= stop;
+  }
+
+  /*
+   * Calculate the start/stop epoch between this and another [Interpolator].
+   *
+   * Returns `null` if there is no overlap between interpolators.
+   */
+  overlap(interpolator: Interpolator): EpochWindow | null {
+    const x1 = this.window().start;
+    const x2 = this.window().end;
+    const y1 = interpolator.window().start;
+    const y2 = interpolator.window().end;
+
+    if (x1 <= y2 && y1 <= x2) {
+      const e1 = new EpochUTC(Math.max(x1.posix, y1.posix) as Seconds);
+      const e2 = new EpochUTC(Math.min(x2.posix, y2.posix) as Seconds);
+
+      return new EpochWindow(e1, e2);
+    }
+
+    return null;
+  }
+}