ootk 4.0.0-0 → 4.0.0-2

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;
+  }
+}

package/src/interpolator/LagrangeInterpolator.ts

@@ -0,0 +1,192 @@
+/**
+ * @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, Seconds, Vector3D } from 'ootk-core';
+import { StateInterpolator } from './StateInterpolator';
+
+export class LagrangeInterpolator extends StateInterpolator {
+  private t_: Float64Array;
+  private x_: Float64Array;
+  private y_: Float64Array;
+  private z_: Float64Array;
+  private order: number;
+
+  constructor(t: Float64Array, x: Float64Array, y: Float64Array, z: Float64Array, order = 10) {
+    super();
+    this.t_ = t;
+    this.x_ = x;
+    this.y_ = y;
+    this.z_ = z;
+    this.order = order;
+  }
+
+  /**
+   * Creates a LagrangeInterpolator from an array of J2000 ephemeris data.
+   * @param ephemeris - The array of J2000 ephemeris data.
+   * @param order - The order of the LagrangeInterpolator. Default is 10.
+   * @returns A new LagrangeInterpolator instance.
+   */
+  static fromEphemeris(ephemeris: J2000[], order = 10): LagrangeInterpolator {
+    const k = ephemeris.length;
+    const t = new Float64Array(k);
+    const x = new Float64Array(k);
+    const y = new Float64Array(k);
+    const z = new Float64Array(k);
+
+    for (let i = 0; i < k; i++) {
+      const state = ephemeris[i];
+
+      t[i] = state.epoch.posix;
+      x[i] = state.position.x;
+      y[i] = state.position.y;
+      z[i] = state.position.z;
+    }
+
+    return new LagrangeInterpolator(t, x, y, z, order);
+  }
+
+  get sizeBytes(): number {
+    return (64 * 4 * this.t_.length) / 8;
+  }
+
+  interpolate(epoch: EpochUTC): J2000 | null {
+    if (!this.inWindow(epoch)) {
+      return null;
+    }
+    const posix = epoch.posix;
+    const subDex = this.slice_(posix);
+    const start = subDex.left;
+    const stop = subDex.right;
+    const ts = this.t_.subarray(start, stop);
+    const xs = this.x_.subarray(start, stop);
+    const ys = this.y_.subarray(start, stop);
+    const zs = this.z_.subarray(start, stop);
+    const position = new Vector3D(
+      LagrangeInterpolator.position_(ts, xs, posix) as Kilometers,
+      LagrangeInterpolator.position_(ts, ys, posix) as Kilometers,
+      LagrangeInterpolator.position_(ts, zs, posix) as Kilometers,
+    );
+    const velocity = new Vector3D(
+      LagrangeInterpolator.velocity_(ts, xs, posix) as KilometersPerSecond,
+      LagrangeInterpolator.velocity_(ts, ys, posix) as KilometersPerSecond,
+      LagrangeInterpolator.velocity_(ts, zs, posix) as KilometersPerSecond,
+    );
+
+    return new J2000(epoch, position, velocity);
+  }
+
+  private static position_(xs: Float64Array, ys: Float64Array, x: number): number {
+    const k = xs.length - 1;
+    let result = 0.0;
+
+    for (let j = 0; j < k; j++) {
+      let product = ys[j];
+
+      for (let m = 0; m < k; m++) {
+        if (j === m) {
+          continue;
+        }
+        product *= (x - xs[m]) / (xs[j] - xs[m]);
+      }
+      result += product;
+    }
+
+    return result;
+  }
+
+  private static velocity_(xs: Float64Array, ys: Float64Array, x: number): number {
+    const k = xs.length;
+    let result = 0.0;
+
+    for (let j = 0; j < k; j++) {
+      let total = 0.0;
+
+      for (let i = 0; i < k; i++) {
+        if (i === j) {
+          continue;
+        }
+        let product = 1 / (xs[j] - xs[i]);
+
+        for (let m = 0; m < k; m++) {
+          if (m === i || m === j) {
+            continue;
+          }
+          product *= (x - xs[m]) / (xs[j] - xs[m]);
+        }
+        total += product;
+      }
+      result += ys[j] * total;
+    }
+
+    return result;
+  }
+
+  private static _getClosest(target: number, t1: number, d1: number, t2: number, d2: number): number {
+    return target - t1 >= t2 - target ? d2 : d1;
+  }
+
+  private slice_(posix: number): { left: number; right: number } {
+    const n = this.t_.length;
+
+    if (posix <= this.t_[0]) {
+      return { left: 0, right: this.order };
+    }
+    if (posix >= this.t_[n - 1]) {
+      return { left: n - this.order, right: n };
+    }
+
+    let i = 0;
+    let j = this.t_.length;
+    let mid = 0;
+
+    while (i < j) {
+      mid = (i + j) >> 1;
+      if (this.t_[mid] === posix) {
+        break;
+      }
+      if (posix < this.t_[mid]) {
+        if (mid > 0 && posix > this.t_[mid - 1]) {
+          mid = LagrangeInterpolator._getClosest(posix, this.t_[mid - 1], mid - 1, this.t_[mid], mid);
+          break;
+        }
+        j = mid;
+      } else {
+        if (mid < this.t_.length - 1 && posix < this.t_[mid + 1]) {
+          mid = LagrangeInterpolator._getClosest(posix, this.t_[mid], mid, this.t_[mid + 1], mid + 1);
+          break;
+        }
+        i = mid + 1;
+      }
+    }
+    const offset = Math.floor(this.order / 2);
+    const left = mid - offset;
+    const right = mid + offset - (this.order % 2 === 1 ? 1 : 0);
+
+    if (left < 0) {
+      return { left: 0, right: this.order };
+    }
+    if (right > n) {
+      return { left: n - this.order, right: n };
+    }
+
+    return { left, right };
+  }
+
+  window(): EpochWindow {
+    return new EpochWindow(new EpochUTC(this.t_[0] as Seconds), new EpochUTC(this.t_[this.t_.length - 1] as Seconds));
+  }
+}

package/src/interpolator/StateInterpolator.ts

@@ -0,0 +1,39 @@
+/**
+ * @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 } from 'ootk-core';
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable class-methods-use-this */
+
+import { Interpolator } from './Interpolator';
+
+// / Base class for state vector interpolators.
+export abstract class StateInterpolator extends Interpolator {
+  /**
+   * Interpolates the state at the given epoch.
+   * @param epoch The epoch in UTC format.
+   * @throws If the interpolator has not been initialized.
+   */
+  interpolate(epoch: EpochUTC): J2000 | null {
+    throw new Error('Not implemented.');
+  }
+
+  // / Return the size _(bytes)_ of this interpolator's cached data.
+  get sizeBytes(): number {
+    throw new Error('Not implemented.');
+  }
+}