ootk 3.0.0 → 4.0.0-1

package/src/propagator/RungeKuttaAdaptive.ts

@@ -0,0 +1,232 @@
+/**
+ * @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, Seconds, Vector, Vector3D } from 'ootk-core';
+import { ForceModel } from '../force/ForceModel';
+import { Thrust } from '../force/Thrust';
+import { VerletBlendInterpolator } from './../interpolator/VerletBlendInterpolator';
+import { Propagator } from './Propagator';
+import { RkCheckpoint } from './RkCheckpoint';
+import { RkResult } from './RkResult';
+
+// / Adaptive Runge-Kutta propagator base class.
+export abstract class RungeKuttaAdaptive extends Propagator {
+  /**
+   * Create a new [RungeKuttaAdaptive] object from an initial state vector
+   * along with an optional [ForceModel] and [tolerance].
+   * @param initState_ Initial state vector.
+   * @param forceModel_ Numerical integration force model.
+   * @param tolerance_ Minimum allowable local error tolerance.
+   */
+  constructor(
+    private initState_: J2000,
+    private forceModel_: ForceModel = new ForceModel().setGravity(),
+    private tolerance_: number = 1e-9,
+  ) {
+    super();
+    this._cacheState = this.initState_;
+    this.tolerance_ = Math.max(RungeKuttaAdaptive._minTolerance, Math.abs(tolerance_));
+  }
+
+  // / Initial state vector.
+  private _cacheState: J2000;
+
+  private readonly _checkpoints: RkCheckpoint[] = [];
+
+  // / Integration step size _(seconds)_.
+  private _stepSize = 60.0;
+
+  // / Minimum allowable local error tolerance.
+  private static readonly _minTolerance: number = 1e-15;
+
+  // / Butcher tableau `A` values.
+  protected abstract get a(): Float64Array;
+
+  // / Butcher tableau `B` values.
+  protected abstract get b(): Float64Array[];
+
+  // / Butcher tableau `CH` values.
+  protected abstract get ch(): Float64Array;
+
+  // / Butcher tableau `C` values
+  protected abstract get c(): Float64Array;
+
+  // / Integrator order.
+  protected abstract get order(): number;
+
+  get state(): J2000 {
+    return this._cacheState;
+  }
+
+  reset(): void {
+    this._cacheState = this.initState_;
+    this._stepSize = 60.0;
+  }
+
+  // / Set numerical integration force model.
+  setForceModel(forceModel: ForceModel): void {
+    this.forceModel_ = forceModel;
+  }
+
+  private kfn_(
+    epoch: EpochUTC,
+    rv: Vector<Kilometers|KilometersPerSecond>,
+    hArg: Seconds,
+    kArg: Vector<Kilometers>,
+    step: Seconds,
+  ): Vector {
+    const t = epoch.roll(hArg * step as Seconds);
+    const rvNew = rv.add(kArg);
+    const sample = new J2000(
+      t,
+      rvNew.toVector3D(0) as Vector3D<Kilometers>,
+      rvNew.toVector3D(3) as Vector3D<KilometersPerSecond>,
+    );
+
+    return this.forceModel_.derivative(sample).scale(step);
+  }
+
+  private integrate_(state: J2000, step: Seconds): RkResult {
+    const k: Vector[] = new Array(this.a.length).fill(Vector.origin3);
+    const y = state.position.join(state.velocity) as Vector<Kilometers>;
+
+    for (let i = 0; i < this.a.length; i++) {
+      let kArg = Vector.origin6 as Vector<Kilometers>;
+
+      if (i !== 0) {
+        for (let j = 0; j < i; j++) {
+          kArg = kArg.add(k[j].scale(this.b[i][j])) as Vector<Kilometers>;
+        }
+      }
+      k[i] = this.kfn_(state.epoch, y, this.a[i] as Seconds, kArg, step);
+    }
+    let y1 = y;
+    let y2 = y;
+
+    for (let i = 0; i < k.length; i++) {
+      y1 = y1.add(k[i].scale(this.ch[i])) as Vector<Kilometers>;
+      y2 = y2.add(k[i].scale(this.c[i])) as Vector<Kilometers>;
+    }
+    const teVal = y1.distance(y2);
+    let hNew = 0.9 * step * (this.tolerance_ / teVal) ** (1.0 / this.order);
+    const hOld = Math.abs(step);
+
+    hNew = Math.max(0.2 * hOld, Math.min(5.0 * hOld, hNew));
+    hNew = Math.max(1e-5, Math.min(1000.0, hNew));
+
+    return new RkResult(
+      new J2000(
+        state.epoch.roll(step),
+        y1.toVector3D(0) as Vector3D<Kilometers>,
+        y1.toVector3D(3) as Vector3D<KilometersPerSecond>,
+      ),
+      teVal,
+      hNew,
+    );
+  }
+
+  propagate(epoch: EpochUTC): J2000 {
+    let delta = epoch.difference(this._cacheState.epoch);
+
+    while (delta !== 0) {
+      const direction = delta >= 0 ? 1 : -1;
+      const dt = Math.min(Math.abs(delta), this._stepSize) * direction as Seconds;
+      const result = this.integrate_(this._cacheState, dt);
+
+      this._stepSize = result.newStep;
+      if (result.error > this.tolerance_) {
+        continue;
+      }
+      this._cacheState = result.state;
+      delta = epoch.difference(this._cacheState.epoch);
+    }
+
+    return this._cacheState;
+  }
+
+  maneuver(maneuver: Thrust, interval = 60.0 as Seconds): J2000[] {
+    if (maneuver.isImpulsive) {
+      this._cacheState = maneuver.apply(this.propagate(maneuver.center));
+
+      return [this._cacheState];
+    }
+    let tState = this.propagate(maneuver.start);
+
+    this.forceModel_.loadManeuver(maneuver);
+    const ephemeris: J2000[] = [tState];
+
+    while (tState.epoch < maneuver.stop) {
+      const step = Math.min(maneuver.stop.difference(tState.epoch), interval) as Seconds;
+
+      tState = this.propagate(tState.epoch.roll(step));
+      ephemeris.push(tState);
+    }
+    this.forceModel_.clearManeuver();
+
+    return ephemeris;
+  }
+
+  ephemerisManeuver(
+    start: EpochUTC,
+    finish: EpochUTC,
+    maneuvers: Thrust[],
+    interval = 60.0 as Seconds,
+  ): VerletBlendInterpolator {
+    const tMvr = maneuvers.filter((mvr) => mvr.start >= start || mvr.stop <= finish);
+    const ephemeris: J2000[] = [];
+
+    if (tMvr[0].start > start) {
+      ephemeris.push(this.propagate(start));
+    }
+    for (const mvr of tMvr) {
+      while (this._cacheState.epoch < mvr.start) {
+        const step = Math.min(mvr.start.difference(this._cacheState.epoch), interval) as Seconds;
+
+        this.propagate(this._cacheState.epoch.roll(step));
+        if (this._cacheState.epoch.posix !== mvr.start.posix) {
+          ephemeris.push(this._cacheState);
+        }
+      }
+      ephemeris.push(...this.maneuver(mvr, interval));
+    }
+    while (this._cacheState.epoch.posix < finish.posix) {
+      const step = Math.min(finish.difference(this._cacheState.epoch), interval) as Seconds;
+
+      this.propagate(this._cacheState.epoch.roll(step));
+      ephemeris.push(this._cacheState);
+    }
+
+    return new VerletBlendInterpolator(ephemeris);
+  }
+
+  checkpoint(): number {
+    this._checkpoints.push(new RkCheckpoint(this._cacheState, this._stepSize));
+
+    return this._checkpoints.length - 1;
+  }
+
+  clearCheckpoints(): void {
+    this._checkpoints.length = 0;
+  }
+
+  restore(index: number): void {
+    const checkpoint = this._checkpoints[index];
+
+    this._cacheState = checkpoint.cacheState;
+    this._stepSize = checkpoint.stepSize;
+  }
+}

package/src/propagator/Sgp4Propagator.ts

@@ -0,0 +1,71 @@
+/**
+ * @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 { EpochUTC, J2000, Tle } from 'ootk-core';
+import { Thrust } from '../force/Thrust';
+import { VerletBlendInterpolator } from '../interpolator/VerletBlendInterpolator';
+import { Propagator } from './Propagator';
+
+// / SGP4 propagator.
+export class Sgp4Propagator extends Propagator {
+  // / Create a new [Sgp4Propagator] object from a [TLE].
+  constructor(private tle: Tle) {
+    super();
+    this._cacheState = tle.state.toJ2000();
+  }
+
+  private _cacheState: J2000;
+  private _checkpoints: J2000[] = [];
+
+  get state(): J2000 {
+    return this._cacheState;
+  }
+
+  ephemerisManeuver(start: EpochUTC, finish: EpochUTC, maneuvers: Thrust[], interval = 60.0): VerletBlendInterpolator {
+    throw new Error('Maneuvers cannot be modelled with SGP4.');
+  }
+
+  maneuver(maneuver: Thrust, interval = 60.0): J2000[] {
+    throw new Error('Maneuvers cannot be modelled with SGP4.');
+  }
+
+  propagate(epoch: EpochUTC): J2000 {
+    this._cacheState = this.tle.propagate(epoch).toJ2000();
+
+    return this._cacheState;
+  }
+
+  reset(): void {
+    this._cacheState = this.tle.state.toJ2000();
+  }
+
+  checkpoint(): number {
+    this._checkpoints.push(this._cacheState);
+
+    return this._checkpoints.length - 1;
+  }
+
+  clearCheckpoints(): void {
+    this._checkpoints = [];
+  }
+
+  restore(index: number): void {
+    this._cacheState = this._checkpoints[index];
+  }
+}

package/src/smoothing/ExponentialSmoothing.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 } from 'ootk-core';
+
+// / Exponential data smoothing methods.
+export class ExponentialSmoothing {
+  private constructor() {
+    // disable constructor
+  }
+
+  /*
+   * Perform exponential smoothing on data set [xs] using the provided
+   * data smoothing factor [alpha] _(0.0 <= alpha <= 1.0)_.
+   */
+  static smooth(xs: number[], alpha: number): number[] {
+    const ss: number[] = [];
+
+    for (let i = 0; i < xs.length; i++) {
+      if (i === 0) {
+        ss.push(xs[0]);
+      } else {
+        ss.push(alpha * xs[i] + (1 - alpha) * ss[i - 1]);
+      }
+    }
+
+    return ss;
+  }
+
+  /*
+   * Perform exponential smoothing on data set [xs] using the provided data
+   * smoothing factor [alpha] _(0.0 <= alpha <= 1.0)_ and trend smoothing
+   * factor [beta] _(0.0 <= beta <= 1.0)_.
+   */
+  static smoothDouble(xs: number[], alpha: number, beta: number): number[] {
+    const bs: number[] = [];
+    const ss: number[] = [];
+
+    for (let i = 0; i < xs.length; i++) {
+      if (i === 0) {
+        ss.push(xs[0]);
+        bs.push(xs[1] - xs[0]);
+      } else {
+        ss.push(alpha * xs[i] + (1 - alpha) * (ss[i - 1] + bs[i - 1]));
+        bs.push(beta * (ss[i] - ss[i - 1]) + (1 - beta) * bs[i - 1]);
+      }
+    }
+
+    return ss;
+  }
+
+  /*
+   * Perform exponential smoothing on time series data set [xs] correlated
+   * with the [epochs] array using the provided [timeConstant]
+   * value _(seconds)_.
+   *
+   * Note: the [timeConstant] is the amount of time for the smoothed response
+   * of a unit step function to reach ~63.2% of the original signal.
+   */
+  static smoothTime(epochs: EpochUTC[], xs: number[], timeConstant: number): number[] {
+    const ts = epochs.map((e) => e.posix);
+    const ss: number[] = [];
+
+    for (let i = 0; i < xs.length; i++) {
+      if (i === 0) {
+        ss.push(xs[0]);
+      } else {
+        const a = 1 - Math.exp(-(ts[i] - ts[i - 1]) / timeConstant);
+
+        ss.push(a * xs[i] + (1 - a) * ss[i - 1]);
+      }
+    }
+
+    return ss;
+  }
+}

package/src/transforms/index.ts

@@ -0,0 +1 @@
+export * from './transforms';

package/src/transforms/transforms.ts

@@ -0,0 +1,117 @@
+import { DEG2RAD, Degrees, EnuVec3, RAD2DEG, Radians, RaeVec3, TAU } from 'ootk-core';
+import { RfSensor } from 'src/objects/RfSensor';
+import { RfVec3, RuvVec3 } from 'src/types/types';
+
+/**
+ * Converts Azimuth and Elevation to U and V.
+ * Azimuth is the angle off of boresight in the horizontal plane.
+ * Elevation is the angle off of boresight in the vertical plane.
+ * Cone half angle is the angle of the cone of the radar max field of view.
+ * @param az - Azimuth in radians
+ * @param el - Elevation in radians
+ * @param coneHalfAngle - Cone half angle in radians
+ * @returns U and V in radians
+ */
+export function azel2uv(az: Radians, el: Radians, coneHalfAngle: Radians): { u: number; v: number } {
+  if (az > coneHalfAngle && az < coneHalfAngle) {
+    throw new RangeError(`Azimuth is out of bounds: ${az}`);
+  }
+
+  if (el > coneHalfAngle && el < coneHalfAngle) {
+    throw new RangeError(`Elevation is out of bounds: ${el}`);
+  }
+
+  const alpha = (az / (coneHalfAngle * RAD2DEG)) * 90;
+  const beta = (el / (coneHalfAngle * RAD2DEG)) * 90;
+
+  const u = Math.sin(alpha) as Radians;
+  let v = -Math.sin(beta) as Radians;
+
+  v = Object.is(v, -0) ? (0 as Radians) : v;
+
+  return { u, v };
+}
+
+/**
+ * Determine azimuth and elevation off of boresight based on sensor orientation and RAE.
+ * @param rae Range, Azimuth, Elevation
+ * @param sensor Radar sensor object
+ * @param maxSensorAz Maximum sensor azimuth
+ * @returns Azimuth and Elevation off of boresight
+ */
+export function rae2raeOffBoresight(
+  rae: RaeVec3,
+  sensor: RfSensor,
+  maxSensorAz: Degrees,
+): { az: Radians; el: Radians } {
+  let az = (rae.az * DEG2RAD) as Radians;
+  let el = (rae.el * DEG2RAD) as Radians;
+
+  // Correct azimuth for sensor orientation.
+  az = az > maxSensorAz * DEG2RAD ? ((az - TAU) as Radians) : az;
+
+  az = (az - sensor.boresightAz) as Radians;
+  el = (el - sensor.boresightEl) as Radians;
+
+  return { az, el };
+}
+
+/**
+ * Converts Range Az El to Range U V.
+ * @param rae Range, Azimuth, Elevation
+ * @param sensor Radar sensor object
+ * @param maxSensorAz Maximum sensor azimuth
+ * @returns Range, U, V
+ */
+export function rae2ruv(rae: RaeVec3, sensor: RfSensor, maxSensorAz: Degrees): RuvVec3 {
+  const { az, el } = rae2raeOffBoresight(rae, sensor, maxSensorAz);
+  const { u, v } = azel2uv(az, el, sensor.coneHalfAngleRad);
+
+  return { rng: rae.rng, u, v };
+}
+
+/**
+ * Converts U and V to Azimuth and Elevation off of boresight.
+ * @param u The U coordinate.
+ * @param v The V coordinate.
+ * @param coneHalfAngle The cone half angle of the radar.
+ * @returns Azimuth and Elevation off of boresight.
+ */
+export function uv2azel(u: number, v: number, coneHalfAngle: Radians): { az: Radians; el: Radians } {
+  if (u > 1 || u < -1) {
+    throw new RangeError(`u is out of bounds: ${u}`);
+  }
+
+  if (v > 1 || v < -1) {
+    throw new RangeError(`v is out of bounds: ${v}`);
+  }
+
+  const alpha = Math.asin(u) as Radians;
+  const beta = Math.asin(v) as Radians;
+  const az = ((alpha / 90) * (coneHalfAngle * RAD2DEG)) as Radians;
+  const el = ((beta / 90) * (coneHalfAngle * RAD2DEG)) as Radians;
+
+  return { az, el };
+}
+
+/**
+ * Converts coordinates from East-North-Up (ENU) to Right-Front-Up (RF) coordinate system.
+ * @param enu - The ENU coordinates to be converted.
+ * @param enu.x - The east coordinate.
+ * @param enu.y - The north coordinate.
+ * @param enu.z - The up coordinate.
+ * @param az - The azimuth angle in radians.
+ * @param el - The elevation angle in radians.
+ * @returns The converted RF coordinates.
+ */
+export function enu2rf<D extends number, A extends number = Radians>({ x, y, z }: EnuVec3<D>, az: A, el: A): RfVec3<D> {
+  const xrf = Math.cos(el) * Math.cos(az) * x - Math.sin(az) * y + Math.sin(el) * Math.cos(az) * z;
+  const yrf = Math.cos(el) * Math.sin(az) * x + Math.cos(az) * y + Math.sin(el) * Math.sin(az) * z;
+  const zrf = -Math.sin(el) * x + Math.cos(el) * z;
+
+  return {
+    x: xrf as D,
+    y: yrf as D,
+    z: zrf as D,
+  };
+}

package/src/types/types.ts

@@ -0,0 +1,135 @@
+/**
+ * @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 { Degrees, Kilometers, Milliseconds, SatelliteParams, Vec3 } from 'ootk-core';
+
+export enum ZoomValue {
+  LEO = 0.45,
+  GEO = 0.82,
+  MAX = 1,
+}
+
+export interface DetailedSatelliteParams extends SatelliteParams {
+  id: number;
+  active?: boolean;
+  configuration?: string;
+  country?: string;
+  dryMass?: string;
+  equipment?: string;
+  launchDate?: string;
+  launchMass?: string;
+  launchSite?: string;
+  launchVehicle?: string;
+  lifetime?: string | number;
+  maneuver?: string;
+  manufacturer?: string;
+  mission?: string;
+  motor?: string;
+  owner?: string;
+  bus?: string;
+  payload?: string;
+  power?: string;
+  purpose?: string;
+  length?: string;
+  diameter?: string;
+  shape?: string;
+  span?: string;
+  user?: string;
+  vmag?: number;
+  rcs?: number;
+  source?: string;
+  altId?: string;
+  altName?: string;
+}
+
+export interface DetailedSensorParams {
+  /** The country that owns the sensor */
+  country?: string;
+  /** 3 Letter Designation */
+  shortName?: string;
+  /** For radars, this is the width of the beam */
+  beamwidth?: Degrees;
+  changeObjectInterval?: Milliseconds;
+  linkAehf?: boolean;
+  linkGalileo?: boolean;
+  linkIridium?: boolean;
+  linkStarlink?: boolean;
+  linkWgs?: boolean;
+  static?: boolean;
+  sensorId?: number;
+  url?: string;
+  /** Does this sensor use a volumetric search pattern? */
+  volume?: boolean;
+  /** How far away should we zoom when selecting this sensor? */
+  zoom: ZoomValue;
+  /** For radar sensors, what frequency does this sensor operate in? */
+  band?: string;
+  /** This is the name of the object in the array */
+  objName?: string;
+  /** This is the name of the object in the UI */
+  uiName?: string;
+  /** This is the specific system (ex. AN/FPS-132) */
+  system?: string;
+  /** This is who operates the sensor */
+  operator?: string;
+}
+/**
+ * The RUV coordinate system is a spherical coordinate system with the origin at
+ * the radar. The RUV coordinate system is defined with respect to the radar
+ * boresight. The R-axis points outward along the boresight with the origin at
+ * the radar. The U-axis is in the horizontal plane and points to the right of
+ * the boresight. The V-axis is in the vertical plane and points down from the
+ * boresight.
+ * @template DistanceUnit The unit of measure used for the altitude dimension.
+ * This is typically a type representing a distance, such as kilometers or
+ * meters. The default is Kilometers.
+ * @template AngleUnit The unit of measure used for the latitude and longitude
+ * dimensions. This is typically a type representing an angle, such as degrees
+ * or radians. The default is Radians.
+ */
+
+export type RuvVec3<DistanceUnit = Kilometers> = {
+  rng: DistanceUnit;
+  u: number;
+  v: number;
+};
+/**
+ * Phased Array Radar Face Cartesian Coordinates The cartesian coordinates (XRF,
+ * YRF ZRF) are defined with respect to the phased array radar face. The radar
+ * face lies in the XRF-YRF plane, with the XRF-axis horizontal and the YRF-axis
+ * pointing upward. The ZRF-axis points outward along the normal to the array
+ * face.
+ *
+ * The orientation of the phased array face is defined by the azimuth and the
+ * elevation of the phased array boresight (i.e., the phased array Z-axis).
+ */
+
+export type RfVec3<Units = Kilometers> = Vec3<Units>;
+
+/**
+ * Represents a function that calculates the Jacobian matrix.
+ * @param xs - The input values as a Float64Array. @returns The Jacobian matrix
+ * as a Float64Array.
+ */
+export type JacobianFunction = (xs: Float64Array) => Float64Array;
+
+/**
+ * Represents a differentiable function.
+ * @param x The input value. @returns The output value.
+ */
+
+export type DifferentiableFunction = (x: number) => number;

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './jacobian';

package/src/utils/jacobian.ts

@@ -0,0 +1,38 @@
+import { array2d, Matrix, Vector } from 'ootk-core';
+import { JacobianFunction } from '../types/types';
+
+// TODO: #11 Expand documentation of Jacobian function.
+
+/**
+ * Calculates the Jacobian matrix of a given Jacobian function.
+ * @param f The Jacobian function.
+ * @param m The number of rows in the Jacobian matrix.
+ * @param x0 The initial values of the variables.
+ * @param step The step size for numerical differentiation (default: 1e-5).
+ * @returns The Jacobian matrix.
+ */
+export function jacobian(f: JacobianFunction, m: number, x0: Float64Array, step = 0.00001): Matrix {
+  const n = x0.length;
+  const j = array2d(m, n, 0);
+  const h = 0.5 * step;
+
+  for (let k = 0; k < n; k++) {
+    const xp = x0.slice();
+
+    xp[k] += h;
+    const fp = new Vector(f(xp));
+
+    const xm = x0.slice();
+
+    xm[k] -= h;
+    const fm = new Vector(f(xm));
+
+    const cd = fp.subtract(fm).scale(1 / step);
+
+    for (let i = 0; i < m; i++) {
+      j[i][k] = cd.elements[i];
+    }
+  }
+
+  return new Matrix(j);
+}