ootk 3.0.0 → 4.0.0-1

package/dist/types/types.js

@@ -0,0 +1,23 @@
+/**
+ * @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/>.
+ */
+export var ZoomValue;
+(function (ZoomValue) {
+    ZoomValue[ZoomValue["LEO"] = 0.45] = "LEO";
+    ZoomValue[ZoomValue["GEO"] = 0.82] = "GEO";
+    ZoomValue[ZoomValue["MAX"] = 1] = "MAX";
+})(ZoomValue || (ZoomValue = {}));
+//# sourceMappingURL=types.js.map

package/dist/types/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,MAAM,CAAN,IAAY,SAIX;AAJD,WAAY,SAAS;IACnB,0CAAU,CAAA;IACV,0CAAU,CAAA;IACV,uCAAO,CAAA;AACT,CAAC,EAJW,SAAS,KAAT,SAAS,QAIpB"}

package/dist/utils/index.d.ts

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

package/dist/utils/index.js

@@ -0,0 +1,2 @@
+export * from './jacobian';
+//# sourceMappingURL=index.js.map

package/dist/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dist/utils/jacobian.d.ts

@@ -0,0 +1,11 @@
+import { Matrix } from 'ootk-core';
+import { JacobianFunction } from '../types/types';
+/**
+ * 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 declare function jacobian(f: JacobianFunction, m: number, x0: Float64Array, step?: number): Matrix;

package/dist/utils/jacobian.js

@@ -0,0 +1,29 @@
+import { array2d, Matrix, Vector } from 'ootk-core';
+// 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, m, x0, step = 0.00001) {
+    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);
+}
+//# sourceMappingURL=jacobian.js.map

package/dist/utils/jacobian.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jacobian.js","sourceRoot":"","sources":["../../src/utils/jacobian.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGpD,uDAAuD;AAEvD;;;;;;;GAOG;AACH,MAAM,UAAU,QAAQ,CAAC,CAAmB,EAAE,CAAS,EAAE,EAAgB,EAAE,IAAI,GAAG,OAAO;IACvF,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC;IACpB,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3B,MAAM,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC;IAErB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;QAC1B,MAAM,EAAE,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC;QAEtB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACX,MAAM,EAAE,GAAG,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAE7B,MAAM,EAAE,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC;QAEtB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACX,MAAM,EAAE,GAAG,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAE7B,MAAM,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;QAE3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;YAC1B,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;SAC1B;KACF;IAED,OAAO,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC;AACvB,CAAC"}

package/package.json

@@ -1,21 +1,20 @@
 {
   "name": "ootk",
-  "version": "3.0.0",
-  "description": "Orbital Object Toolkit including SGP4 Propagator and Coordinate Transforms",
-  "main": "dist/ootk.js",
+  "version": "4.0.0-1",
+  "type": "module",
+  "module": "dist/main.js",
+  "description": "Orbital Object Toolkit including Multiple Propagators, Initial Orbit Determination, and Maneuver Calculations.",
   "scripts": {
-    "build": "node ./scripts/cleanup.js && tsc -p tsconfig.build.json && node --openssl-legacy-provider node_modules/webpack/bin/webpack.js --config ./scripts/webpack.js",
-    "build:legacy": "node ./scripts/cleanup.js && tsc -p tsconfig.build.json && node node_modules/webpack/bin/webpack.js --config ./scripts/webpack.js",
-    "lcov": "node ./scripts/openLcov.mjs",
-    "lint": "eslint src",
-    "lint:fix": "eslint src --fix",
-    "lint:test": "eslint test",
-    "sandbox": "http-server ./",
+    "build": "npm run clean && npx tsc -p tsconfig.build.json -m esnext",
+    "clean": "node ./scripts/cleanup.mjs",
+    "lint": "npx eslint src",
+    "lint:fix": "npx eslint src --fix",
     "test": "jest",
     "test:coverage": "jest --coverage",
-    "test:performance": "node test/performance/timing.test.mjs",
-    "version": "auto-changelog -p && git add CHANGELOG.md"
+    "version": "npm run build && auto-changelog && git add CHANGELOG.md"
   },
+  "main": "dist/main.js",
+  "typings": "dist/main.d.ts",
   "repository": {
     "type": "git",
     "url": "git://github.com/thkruz/ootk"
@@ -25,43 +24,36 @@
     "orbit",
     "toolkit",
     "space",
-    "satellite"
+    "satellite",
+    "radar",
+    "iod"
   ],
   "author": "Theodore Kruczek <theodore.kruczek@gmail.com> (https://github.com/ootk/)",
-  "license": "MIT",
+  "license": "APGL-3.0",
   "bugs": {
     "url": "https://github.com/thkruz/ootk/issues"
   },
   "devDependencies": {
-    "@babel/core": "^7.22.9",
-    "@babel/plugin-transform-runtime": "^7.22.9",
-    "@babel/preset-env": "^7.22.9",
-    "@babel/preset-typescript": "^7.22.5",
-    "@types/jest": "^28.1.8",
-    "@types/node-fetch": "^2.6.2",
-    "@typescript-eslint/eslint-plugin": "^5.54.0",
-    "@typescript-eslint/parser": "^5.54.0",
-    "auto-changelog": "^2.2.1",
+    "@babel/core": "^7.23.7",
+    "@babel/plugin-transform-runtime": "^7.23.7",
+    "@babel/preset-env": "^7.23.8",
+    "@babel/preset-typescript": "^7.23.3",
+    "@types/jest": "^29.5.11",
+    "@typescript-eslint/eslint-plugin": "^6.18.1",
+    "@typescript-eslint/parser": "^6.18.1",
+    "auto-changelog": "^2.4.0",
+    "auto-changelog-thkruz": "^1.0.0",
     "babel-eslint": "^10.1.0",
-    "babel-loader": "^8.3.0",
-    "codecov": "^3.8.1",
-    "copy-webpack-plugin": "^11.0.0",
-    "eslint": "^7.32.0",
-    "imports-loader": "^4.0.1",
+    "babel-jest": "^29.7.0",
+    "babel-loader": "^9.1.3",
+    "eslint": "^8.56.0",
+    "eslint-plugin-jsdoc": "^48.0.2",
     "jest": "^28.1.3",
-    "node-fetch": "^2.6.7",
-    "opener": "^1.5.2",
-    "prettier": "^2.8.8",
-    "prettier-plugin-organize-imports": "^3.2.3",
-    "ts-node": "^10.9.1",
-    "typescript": "^4.9.5",
-    "webpack": "^5.11.1",
-    "webpack-cli": "^4.10.0"
+    "tsx": "^4.7.0",
+    "typescript": "^4.9.5"
   },
-  "homepage": "https://github.com/thkruz/ootk",
-  "directories": {
-    "lib": "lib",
-    "src": "src",
-    "test": "test"
-  }
+  "dependencies": {
+    "ootk-core": "^1.0.7"
+  },
+  "homepage": "https://github.com/thkruz/ootk"
 }

package/src/coordinate/Hill.ts

@@ -0,0 +1,326 @@
+/**
+ * @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 {
+  Earth,
+  EpochUTC,
+  J2000,
+  Kilometers,
+  KilometersPerSecond,
+  Matrix,
+  MetersPerSecond,
+  RadiansPerSecond,
+  RelativeState,
+  Seconds,
+  Vector3D,
+} from 'ootk-core';
+import { Thrust } from './../force/Thrust';
+import { Waypoint } from './../maneuver/Waypoint';
+
+// / Hill Modified Equidistant Cyllindrical _(EQCM)_ coordinates.
+export class Hill {
+  private semimajorAxis_: Kilometers;
+  private meanMotion_: RadiansPerSecond;
+
+  constructor(
+    public epoch: EpochUTC,
+    public position: Vector3D<Kilometers>,
+    public velocity: Vector3D<KilometersPerSecond>,
+    semimajorAxis: Kilometers,
+  ) {
+    this.semimajorAxis_ = semimajorAxis;
+    this.meanMotion_ = Earth.smaToMeanMotion(this.semimajorAxis_);
+  }
+
+  static fromState(
+    origin: J2000,
+    radialPosition: Kilometers,
+    intrackPosition: Kilometers,
+    nodeVelocity: KilometersPerSecond,
+    nodeOffsetTime: Seconds,
+  ): Hill {
+    const a = origin.semimajorAxis;
+    const n = Earth.smaToMeanMotion(a);
+    const yDot = -3.0 * radialPosition * n * 0.5 as KilometersPerSecond;
+    const z = (nodeVelocity / n) * Math.sin(n * -nodeOffsetTime) as Kilometers;
+    const zDot = nodeVelocity * Math.cos(n * -nodeOffsetTime) as KilometersPerSecond;
+    const r = new Vector3D(radialPosition, intrackPosition, z);
+    const v = new Vector3D(0.0 as KilometersPerSecond, yDot, zDot);
+
+    return new Hill(origin.epoch, r, v, a);
+  }
+
+  static fromNmc(
+    origin: J2000,
+    majorAxisRange: Kilometers,
+    nodeVelocity: KilometersPerSecond,
+    nodeOffsetTime: Seconds,
+    translation = 0.0,
+  ): Hill {
+    const a = origin.semimajorAxis;
+    const n = Earth.smaToMeanMotion(a);
+    const xDot = majorAxisRange * n * 0.5 as KilometersPerSecond;
+    const z = (nodeVelocity / n) * Math.sin(n * -nodeOffsetTime) as Kilometers;
+    const zDot = nodeVelocity * Math.cos(n * -nodeOffsetTime) as KilometersPerSecond;
+    const r = new Vector3D(0.0 as Kilometers, majorAxisRange + translation as Kilometers, z);
+    const v = new Vector3D(xDot, 0.0 as KilometersPerSecond, zDot);
+
+    return new Hill(origin.epoch, r, v, a);
+  }
+
+  static fromPerch(
+    origin: J2000,
+    perchRange: Kilometers,
+    nodeVelocity: KilometersPerSecond,
+    nodeOffsetTime: Seconds,
+  ): Hill {
+    const a = origin.semimajorAxis;
+    const n = Earth.smaToMeanMotion(a);
+    const z = (nodeVelocity / n) * Math.sin(n * -nodeOffsetTime) as Kilometers;
+    const zDot = nodeVelocity * Math.cos(n * -nodeOffsetTime) as KilometersPerSecond;
+    const r = new Vector3D(0.0 as Kilometers, perchRange, z);
+    const v = new Vector3D(0.0 as KilometersPerSecond, 0.0 as KilometersPerSecond, zDot);
+
+    return new Hill(origin.epoch, r, v, a);
+  }
+
+  get semimajorAxis(): Kilometers {
+    return this.semimajorAxis_;
+  }
+
+  set semimajorAxis(sma: Kilometers) {
+    this.semimajorAxis_ = sma;
+    this.meanMotion_ = Earth.smaToMeanMotion(this.semimajorAxis_);
+  }
+
+  get meanMotion(): RadiansPerSecond {
+    return this.meanMotion_;
+  }
+
+  toJ2000Matrix(origin: J2000, transform: Matrix): J2000 {
+    const magrtgt = origin.position.magnitude();
+    const magrint = magrtgt + this.position.x;
+    const vtgtrsw = transform.multiplyVector3D(origin.velocity);
+
+    const lambdadottgt = vtgtrsw.y / magrtgt;
+    const lambdaint = this.position.y / magrtgt;
+    const phiint = this.position.z / magrtgt;
+    const sinphiint = Math.sin(phiint);
+    const cosphiint = Math.cos(phiint);
+    const sinlambdaint = Math.sin(lambdaint);
+    const coslambdaint = Math.cos(lambdaint);
+
+    const rotRswSez = new Matrix([
+      [sinphiint * coslambdaint, sinphiint * sinlambdaint, -cosphiint],
+      [-sinlambdaint, coslambdaint, 0],
+      [cosphiint * coslambdaint, cosphiint * sinlambdaint, sinphiint],
+    ]);
+
+    const rdotint = this.velocity.x + vtgtrsw.x;
+    const lambdadotint = this.velocity.y / magrtgt + lambdadottgt;
+    const phidotint = this.velocity.z / magrtgt;
+    const vintsez = new Vector3D(-magrint * phidotint, magrint * lambdadotint * cosphiint, rdotint);
+    const vintrsw = rotRswSez.transpose().multiplyVector3D(vintsez);
+    const vinteci = transform.transpose().multiplyVector3D(vintrsw) as Vector3D<KilometersPerSecond>;
+
+    const rintrsw = new Vector3D(
+      cosphiint * magrint * coslambdaint,
+      cosphiint * magrint * sinlambdaint,
+      sinphiint * magrint,
+    );
+
+    const rinteci = transform.transpose().multiplyVector3D(rintrsw) as Vector3D<Kilometers>;
+
+    return new J2000(origin.epoch, rinteci, vinteci);
+  }
+
+  toJ2000(origin: J2000): J2000 {
+    return this.toJ2000Matrix(origin, RelativeState.createMatrix(origin.position, origin.velocity));
+  }
+
+  static transitionMatrix(t: number, meanMotion: number): Matrix {
+    const n = meanMotion;
+    const sn = Math.sin(n * t);
+    const cs = Math.cos(n * t);
+
+    return new Matrix([
+      [4.0 - 3.0 * cs, 0.0, 0.0, sn / n, (2.0 * (1.0 - cs)) / n, 0.0],
+      [6.0 * (sn - n * t), 1.0, 0.0, (-2.0 * (1.0 - cs)) / n, (4.0 * sn - 3.0 * n * t) / n, 0.0],
+      [0.0, 0.0, cs, 0.0, 0.0, sn / n],
+      [3.0 * n * sn, 0.0, 0.0, cs, 2.0 * sn, 0.0],
+      [-6.0 * n * (1.0 - cs), 0.0, 0.0, -2.0 * sn, 4.0 * cs - 3.0, 0.0],
+      [0.0, 0.0, -n * sn, 0.0, 0.0, cs],
+    ]);
+  }
+
+  transition(t: Seconds): Hill {
+    const sysMat = Hill.transitionMatrix(t, this.meanMotion_);
+    const res = sysMat.multiplyVector(this.position.join(this.velocity)).elements;
+
+    return new Hill(
+      this.epoch.roll(t),
+      new Vector3D(res[0] as Kilometers, res[1] as Kilometers, res[2] as Kilometers),
+      new Vector3D(res[3] as KilometersPerSecond, res[4] as KilometersPerSecond, res[5] as KilometersPerSecond),
+      this.semimajorAxis_,
+    );
+  }
+
+  transitionWithMatrix(stm: Matrix, t: Seconds): Hill {
+    const res = stm.multiplyVector(this.position.join(this.velocity)).elements;
+
+    return new Hill(
+      this.epoch.roll(t),
+      new Vector3D(res[0] as Kilometers, res[1] as Kilometers, res[2] as Kilometers),
+      new Vector3D(res[3] as KilometersPerSecond, res[4] as KilometersPerSecond, res[5] as KilometersPerSecond),
+      this.semimajorAxis_,
+    );
+  }
+
+  propagate(newEpoch: EpochUTC): Hill {
+    return this.transition(newEpoch.difference(this.epoch));
+  }
+
+  propagateWithMatrix(stm: Matrix, newEpoch: EpochUTC): Hill {
+    return this.transitionWithMatrix(stm, newEpoch.difference(this.epoch));
+  }
+
+  maneuver(maneuver: Thrust): Hill {
+    const state = this.propagate(maneuver.center);
+
+    return new Hill(state.epoch, state.position, state.velocity.add(maneuver.deltaV), state.semimajorAxis_);
+  }
+
+  ephemeris(start: EpochUTC, stop: EpochUTC, step = 60.0 as Seconds): Hill[] {
+    const output: Hill[] = [];
+    let current = start;
+
+    while (stop >= current) {
+      output.push(this.propagate(current));
+      current = current.roll(step);
+    }
+
+    return output;
+  }
+
+  get period(): Seconds {
+    return (2 * Math.PI) / this.meanMotion_ as Seconds;
+  }
+
+  nextRadialTangent(): Hill {
+    const x = this.position.x;
+    const xDot = this.velocity.x;
+    const yDot = this.velocity.y;
+    let t = Math.atan(-xDot / (3.0 * this.meanMotion_ * x + 2.0 * yDot)) / this.meanMotion_ as Seconds;
+
+    if (t <= 0) {
+      t = t + 0.5 * this.period as Seconds;
+    } else if (isNaN(t)) {
+      t = 0.5 * this.period as Seconds;
+    }
+
+    return this.propagate(this.epoch.roll(t));
+  }
+
+  solveManeuver(waypoint: Waypoint, ignoreCrosstrack = false): Thrust {
+    const t = waypoint.epoch.difference(this.epoch);
+    const w = waypoint.relativePosition;
+    const sysMat = Hill.transitionMatrix(t, this.meanMotion_);
+    const posEquationMat = new Matrix([
+      [sysMat.elements[0][0], sysMat.elements[0][1], sysMat.elements[0][2]],
+      [sysMat.elements[1][0], sysMat.elements[1][1], sysMat.elements[1][2]],
+      [sysMat.elements[2][0], sysMat.elements[2][1], sysMat.elements[2][2]],
+    ]);
+    const solnVector = w
+      .subtract(posEquationMat.multiplyVector3D(this.position)) as unknown as Vector3D<KilometersPerSecond>;
+    const velEquationMat = new Matrix([
+      [sysMat.elements[0][3], sysMat.elements[0][4], sysMat.elements[0][5]],
+      [sysMat.elements[1][3], sysMat.elements[1][4], sysMat.elements[1][5]],
+      [sysMat.elements[2][3], sysMat.elements[2][4], sysMat.elements[2][5]],
+    ]);
+    let result = velEquationMat
+      .inverse()
+      .multiplyVector3D(solnVector)
+      .subtract(this.velocity);
+
+    if (ignoreCrosstrack) {
+      result = new Vector3D(
+        result.x,
+        result.y,
+        0 as KilometersPerSecond,
+      );
+    }
+
+    return new Thrust(
+      this.epoch,
+      result.x * 1000 as MetersPerSecond,
+      result.y * 1000 as MetersPerSecond,
+      result.z * 1000 as MetersPerSecond,
+    );
+  }
+
+  maneuverSequence(
+    pivot: EpochUTC,
+    waypoints: Waypoint[],
+    preManeuvers: Thrust[] = [],
+    postManeuvers: Thrust[] = [],
+  ): Thrust[] {
+    let state = new Hill(this.epoch, this.position, this.velocity, this.semimajorAxis_);
+
+    preManeuvers = preManeuvers.slice();
+    postManeuvers = postManeuvers.slice();
+    let output = preManeuvers;
+
+    // Note difference was once compareTo
+    output.sort((a, b) => a.center.difference(b.center));
+    output = output.filter((mvr) => mvr.center >= this.epoch && mvr.center >= pivot);
+    for (const mvr of output) {
+      state = state.maneuver(mvr);
+    }
+    state = state.propagate(pivot);
+    for (const wpt of waypoints) {
+      const mvr = state.solveManeuver(wpt);
+
+      state = state.maneuver(mvr);
+      output.push(mvr);
+    }
+    output.push(...postManeuvers);
+
+    return output;
+  }
+
+  maneuverOrigin(maneuver: Thrust): Hill {
+    const state = this.propagate(maneuver.center);
+    const vInit = Math.sqrt(Earth.mu / this.semimajorAxis_);
+    const vFinal = vInit - maneuver.intrack * 1e-3;
+    const aFinal = Earth.mu / (vFinal * vFinal) as Kilometers;
+
+    return new Hill(state.epoch, state.position, state.velocity.subtract(maneuver.deltaV), aFinal);
+  }
+
+  get name(): string {
+    return 'Hill';
+  }
+
+  toString(): string {
+    return [
+      `[${this.name}]`,
+      `  Epoch: ${this.epoch}`,
+      `  Position: ${this.position.toString(6)} km`,
+      `  Velocity: ${this.velocity.toString(9)} km/s`,
+    ].join('\n');
+  }
+}

package/src/coordinate/index.ts

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