@interstellar-tools/equations 1.0.0 → 1.2.0

package/dist/categories/anomalies/asymptote-true-anomaly.d.ts

@@ -0,0 +1,50 @@
+import type { Radians } from '@interstellar-tools/types';
+/**
+ * Compute the **true anomaly of a hyperbola's asymptotes**: the limit a body on a hyperbola approaches but never reaches.
+ *
+ * $$
+ * \nu_\infty = \arccos\left(-\frac{1}{e}\right)
+ * $$
+ *
+ * **Units**
+ * - Input: `e` dimensionless.
+ * - Output: $ \nu_\infty $ in **radians**, in (π/2, π).
+ *
+ * ::: info Notes
+ *
+ * - The body comes in from $ -\nu_\infty $ and leaves towards $ +\nu_\infty $.
+ * - The trajectory turns through $ 2\nu_\infty - \pi = 2\arcsin(1/e) $, the turning angle of a flyby; see `gravityAssistTurningAngle`.
+ * - Just above $ e = 1 $ the asymptotes open to almost π (a near-parabola); for large $ e $ they close towards π/2 (a near-straight line).
+ *
+ * :::
+ *
+ * ::: practice Apollo 11, arriving at the Moon
+ *
+ * **134.0°**
+ *
+ * _Asymptote of the approach hyperbola, e = 1.44_
+ *
+ * Without the lunar orbit insertion burn at closest approach, the Moon's gravity would have bent Apollo 11's path through 88° and sent it back out of the Moon's sphere of influence.
+ *
+ * ```ts
+ * asymptoteTrueAnomaly(1.44); // ≈ 2.338 rad, 134.0°
+ * ```
+ *
+ * :::
+ *
+ * @param e - Eccentricity $ e $ (finite, > 1).
+ * @returns Asymptote true anomaly $ \nu_\infty $ in **radians**.
+ * @throws {TypeError} If `e` is not a finite number.
+ * @throws {RangeError} If `e <= 1`.
+ * @group Anomalies
+ *
+ * @example
+ * ```ts
+ * asymptoteTrueAnomaly(2); // 2π/3 (120°)
+ * ```
+ *
+ * @see {@link trueToHyperbolicAnomaly}
+ * @see https://en.wikipedia.org/wiki/Hyperbolic_trajectory Hyperbolic trajectory
+ */
+export declare const asymptoteTrueAnomaly: (e: number) => Radians;
+//# sourceMappingURL=asymptote-true-anomaly.d.ts.map

package/dist/categories/anomalies/asymptote-true-anomaly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asymptote-true-anomaly.d.ts","sourceRoot":"","sources":["../../../src/categories/anomalies/asymptote-true-anomaly.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,oBAAoB,GAAI,GAAG,MAAM,KAAG,OAOhD,CAAC"}

package/dist/categories/anomalies/asymptote-true-anomaly.js

@@ -0,0 +1,55 @@
+/**
+ * Compute the **true anomaly of a hyperbola's asymptotes**: the limit a body on a hyperbola approaches but never reaches.
+ *
+ * $$
+ * \nu_\infty = \arccos\left(-\frac{1}{e}\right)
+ * $$
+ *
+ * **Units**
+ * - Input: `e` dimensionless.
+ * - Output: $ \nu_\infty $ in **radians**, in (π/2, π).
+ *
+ * ::: info Notes
+ *
+ * - The body comes in from $ -\nu_\infty $ and leaves towards $ +\nu_\infty $.
+ * - The trajectory turns through $ 2\nu_\infty - \pi = 2\arcsin(1/e) $, the turning angle of a flyby; see `gravityAssistTurningAngle`.
+ * - Just above $ e = 1 $ the asymptotes open to almost π (a near-parabola); for large $ e $ they close towards π/2 (a near-straight line).
+ *
+ * :::
+ *
+ * ::: practice Apollo 11, arriving at the Moon
+ *
+ * **134.0°**
+ *
+ * _Asymptote of the approach hyperbola, e = 1.44_
+ *
+ * Without the lunar orbit insertion burn at closest approach, the Moon's gravity would have bent Apollo 11's path through 88° and sent it back out of the Moon's sphere of influence.
+ *
+ * ```ts
+ * asymptoteTrueAnomaly(1.44); // ≈ 2.338 rad, 134.0°
+ * ```
+ *
+ * :::
+ *
+ * @param e - Eccentricity $ e $ (finite, > 1).
+ * @returns Asymptote true anomaly $ \nu_\infty $ in **radians**.
+ * @throws {TypeError} If `e` is not a finite number.
+ * @throws {RangeError} If `e <= 1`.
+ * @group Anomalies
+ *
+ * @example
+ * ```ts
+ * asymptoteTrueAnomaly(2); // 2π/3 (120°)
+ * ```
+ *
+ * @see {@link trueToHyperbolicAnomaly}
+ * @see https://en.wikipedia.org/wiki/Hyperbolic_trajectory Hyperbolic trajectory
+ */
+export const asymptoteTrueAnomaly = (e) => {
+    if (!Number.isFinite(e))
+        throw new TypeError(`e must be a finite number. Received: ${e}`);
+    if (e <= 1)
+        throw new RangeError(`e must be > 1. Received: ${e}`);
+    return Math.acos(-1 / e);
+};
+//# sourceMappingURL=asymptote-true-anomaly.js.map

package/dist/categories/anomalies/asymptote-true-anomaly.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"asymptote-true-anomaly.js","sourceRoot":"","sources":["../../../src/categories/anomalies/asymptote-true-anomaly.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAS,EAAW,EAAE;IACzD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;QACrB,MAAM,IAAI,SAAS,CAAC,wCAAwC,CAAC,EAAE,CAAC,CAAC;IAEnE,IAAI,CAAC,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,4BAA4B,CAAC,EAAE,CAAC,CAAC;IAElE,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAY,CAAC;AACtC,CAAC,CAAC"}

package/dist/categories/anomalies/hyperbolic-to-true-anomaly.d.ts

@@ -0,0 +1,38 @@
+import type { Radians } from '@interstellar-tools/types';
+/**
+ * Convert a **hyperbolic anomaly** $ F $ to the **true anomaly** on a hyperbola.
+ *
+ * $$
+ * \tan\frac{\nu}{2} = \sqrt{\frac{e + 1}{e - 1}}\,\tanh\frac{F}{2}
+ * $$
+ *
+ * **Units**
+ * - Inputs: `F` in **radians**, `e` dimensionless.
+ * - Output: $ \nu $ in **radians**, in $ (-\nu_\infty, \nu_\infty) $.
+ *
+ * ::: info Notes
+ *
+ * - The inverse of {@link trueToHyperbolicAnomaly}.
+ * - As $ F \to \pm\infty $, $ \nu $ approaches the asymptotes $ \pm\nu_\infty $ but never reaches them.
+ * - Returns a signed angle, negative before periapsis. Use `norm2pi` for [0, 2π).
+ *
+ * :::
+ *
+ * @param F - Hyperbolic anomaly $ F $ in **radians** (finite).
+ * @param e - Eccentricity $ e $ (finite, > 1).
+ * @returns True anomaly $ \nu $ in **radians**, in (-π, π).
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `e <= 1`.
+ * @group Anomalies
+ *
+ * @example
+ * ```ts
+ * const nu = hyperbolicToTrueAnomaly(Math.acosh(2), 2);
+ * // nu ≈ π/2
+ * ```
+ *
+ * @see {@link trueToHyperbolicAnomaly}
+ * @see {@link solveKeplerHyperbolic}
+ */
+export declare const hyperbolicToTrueAnomaly: (F: number, e: number) => Radians;
+//# sourceMappingURL=hyperbolic-to-true-anomaly.d.ts.map

package/dist/categories/anomalies/hyperbolic-to-true-anomaly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hyperbolic-to-true-anomaly.d.ts","sourceRoot":"","sources":["../../../src/categories/anomalies/hyperbolic-to-true-anomaly.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,eAAO,MAAM,uBAAuB,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,OAa9D,CAAC"}

package/dist/categories/anomalies/hyperbolic-to-true-anomaly.js

@@ -0,0 +1,49 @@
+/**
+ * Convert a **hyperbolic anomaly** $ F $ to the **true anomaly** on a hyperbola.
+ *
+ * $$
+ * \tan\frac{\nu}{2} = \sqrt{\frac{e + 1}{e - 1}}\,\tanh\frac{F}{2}
+ * $$
+ *
+ * **Units**
+ * - Inputs: `F` in **radians**, `e` dimensionless.
+ * - Output: $ \nu $ in **radians**, in $ (-\nu_\infty, \nu_\infty) $.
+ *
+ * ::: info Notes
+ *
+ * - The inverse of {@link trueToHyperbolicAnomaly}.
+ * - As $ F \to \pm\infty $, $ \nu $ approaches the asymptotes $ \pm\nu_\infty $ but never reaches them.
+ * - Returns a signed angle, negative before periapsis. Use `norm2pi` for [0, 2π).
+ *
+ * :::
+ *
+ * @param F - Hyperbolic anomaly $ F $ in **radians** (finite).
+ * @param e - Eccentricity $ e $ (finite, > 1).
+ * @returns True anomaly $ \nu $ in **radians**, in (-π, π).
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `e <= 1`.
+ * @group Anomalies
+ *
+ * @example
+ * ```ts
+ * const nu = hyperbolicToTrueAnomaly(Math.acosh(2), 2);
+ * // nu ≈ π/2
+ * ```
+ *
+ * @see {@link trueToHyperbolicAnomaly}
+ * @see {@link solveKeplerHyperbolic}
+ */
+export const hyperbolicToTrueAnomaly = (F, e) => {
+    for (const [name, x] of [
+        ['F', F],
+        ['e', e]
+    ]) {
+        if (!Number.isFinite(x))
+            throw new TypeError(`${name} must be a finite number. Received: ${x}`);
+    }
+    if (e <= 1)
+        throw new RangeError(`e must be > 1. Received: ${e}`);
+    return (2 *
+        Math.atan(Math.sqrt((e + 1) / (e - 1)) * Math.tanh(F / 2)));
+};
+//# sourceMappingURL=hyperbolic-to-true-anomaly.js.map

package/dist/categories/anomalies/hyperbolic-to-true-anomaly.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hyperbolic-to-true-anomaly.js","sourceRoot":"","sources":["../../../src/categories/anomalies/hyperbolic-to-true-anomaly.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,CAAS,EAAE,CAAS,EAAW,EAAE;IACvE,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI;QACtB,CAAC,GAAG,EAAE,CAAC,CAAC;QACR,CAAC,GAAG,EAAE,CAAC,CAAC;KACA,EAAE,CAAC;QACX,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YACrB,MAAM,IAAI,SAAS,CAAC,GAAG,IAAI,uCAAuC,CAAC,EAAE,CAAC,CAAC;IAC3E,CAAC;IAED,IAAI,CAAC,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,4BAA4B,CAAC,EAAE,CAAC,CAAC;IAElE,OAAO,CAAC,CAAC;QACP,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAY,CAAC;AAC3E,CAAC,CAAC"}

package/dist/categories/anomalies/true-to-hyperbolic-anomaly.d.ts

@@ -0,0 +1,40 @@
+import type { Radians } from '@interstellar-tools/types';
+/**
+ * Convert a **true anomaly** on a hyperbola to the **hyperbolic anomaly** $ F $.
+ *
+ * $$
+ * \tanh\frac{F}{2} = \sqrt{\frac{e - 1}{e + 1}}\,\tan\frac{\nu}{2}
+ * $$
+ *
+ * **Units**
+ * - Inputs: `nu` in **radians**, `e` dimensionless.
+ * - Output: $ F $ in **radians** (dimensionless, unbounded).
+ *
+ * ::: info Notes
+ *
+ * - The hyperbolic counterpart of the eccentric anomaly. Feed it to $ M_h = e \sinh F - F $ to get a time from periapsis.
+ * - `nu` is wrapped to (-π, π] first, so the incoming branch can be given either as a negative angle or just below 2π, as {@link stateToElements} returns it.
+ * - Only $ |\nu| < \nu_\infty $ exists on a hyperbola; see {@link asymptoteTrueAnomaly}.
+ *
+ * :::
+ *
+ * @param nu - True anomaly $ \nu $ in **radians** (finite, inside the asymptotes).
+ * @param e - Eccentricity $ e $ (finite, > 1).
+ * @returns Hyperbolic anomaly $ F $ in **radians**: negative before periapsis, positive after.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `e <= 1` or `nu` is at or beyond the asymptotes.
+ * @group Anomalies
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * const F = trueToHyperbolicAnomaly((Math.PI / 2) as Radians, 2);
+ * // F ≈ 1.317 (cosh F = e)
+ * ```
+ *
+ * @see {@link hyperbolicToTrueAnomaly}
+ * @see https://en.wikipedia.org/wiki/Hyperbolic_trajectory#Hyperbolic_anomaly Hyperbolic anomaly
+ */
+export declare const trueToHyperbolicAnomaly: (nu: Radians, e: number) => number;
+//# sourceMappingURL=true-to-hyperbolic-anomaly.d.ts.map

package/dist/categories/anomalies/true-to-hyperbolic-anomaly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"true-to-hyperbolic-anomaly.d.ts","sourceRoot":"","sources":["../../../src/categories/anomalies/true-to-hyperbolic-anomaly.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAIzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,uBAAuB,GAAI,IAAI,OAAO,EAAE,GAAG,MAAM,KAAG,MAmBhE,CAAC"}

package/dist/categories/anomalies/true-to-hyperbolic-anomaly.js

@@ -0,0 +1,54 @@
+import { asymptoteTrueAnomaly } from './asymptote-true-anomaly.js';
+/**
+ * Convert a **true anomaly** on a hyperbola to the **hyperbolic anomaly** $ F $.
+ *
+ * $$
+ * \tanh\frac{F}{2} = \sqrt{\frac{e - 1}{e + 1}}\,\tan\frac{\nu}{2}
+ * $$
+ *
+ * **Units**
+ * - Inputs: `nu` in **radians**, `e` dimensionless.
+ * - Output: $ F $ in **radians** (dimensionless, unbounded).
+ *
+ * ::: info Notes
+ *
+ * - The hyperbolic counterpart of the eccentric anomaly. Feed it to $ M_h = e \sinh F - F $ to get a time from periapsis.
+ * - `nu` is wrapped to (-π, π] first, so the incoming branch can be given either as a negative angle or just below 2π, as {@link stateToElements} returns it.
+ * - Only $ |\nu| < \nu_\infty $ exists on a hyperbola; see {@link asymptoteTrueAnomaly}.
+ *
+ * :::
+ *
+ * @param nu - True anomaly $ \nu $ in **radians** (finite, inside the asymptotes).
+ * @param e - Eccentricity $ e $ (finite, > 1).
+ * @returns Hyperbolic anomaly $ F $ in **radians**: negative before periapsis, positive after.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `e <= 1` or `nu` is at or beyond the asymptotes.
+ * @group Anomalies
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * const F = trueToHyperbolicAnomaly((Math.PI / 2) as Radians, 2);
+ * // F ≈ 1.317 (cosh F = e)
+ * ```
+ *
+ * @see {@link hyperbolicToTrueAnomaly}
+ * @see https://en.wikipedia.org/wiki/Hyperbolic_trajectory#Hyperbolic_anomaly Hyperbolic anomaly
+ */
+export const trueToHyperbolicAnomaly = (nu, e) => {
+    for (const [name, x] of [
+        ['nu', nu],
+        ['e', e]
+    ]) {
+        if (!Number.isFinite(x))
+            throw new TypeError(`${name} must be a finite number. Received: ${x}`);
+    }
+    if (e <= 1)
+        throw new RangeError(`e must be > 1. Received: ${e}`);
+    const wrapped = Math.atan2(Math.sin(nu), Math.cos(nu));
+    if (Math.abs(wrapped) >= asymptoteTrueAnomaly(e))
+        throw new RangeError(`nu is at or beyond the asymptotes (|nu| >= acos(-1/e)). Received: nu=${nu}, e=${e}`);
+    return 2 * Math.atanh(Math.sqrt((e - 1) / (e + 1)) * Math.tan(wrapped / 2));
+};
+//# sourceMappingURL=true-to-hyperbolic-anomaly.js.map

package/dist/categories/anomalies/true-to-hyperbolic-anomaly.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"true-to-hyperbolic-anomaly.js","sourceRoot":"","sources":["../../../src/categories/anomalies/true-to-hyperbolic-anomaly.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,EAAW,EAAE,CAAS,EAAU,EAAE;IACxE,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI;QACtB,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,GAAG,EAAE,CAAC,CAAC;KACA,EAAE,CAAC;QACX,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YACrB,MAAM,IAAI,SAAS,CAAC,GAAG,IAAI,uCAAuC,CAAC,EAAE,CAAC,CAAC;IAC3E,CAAC;IAED,IAAI,CAAC,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,4BAA4B,CAAC,EAAE,CAAC,CAAC;IAElE,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IAEvD,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,oBAAoB,CAAC,CAAC,CAAC;QAC9C,MAAM,IAAI,UAAU,CAClB,wEAAwE,EAAE,OAAO,CAAC,EAAE,CACrF,CAAC;IAEJ,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC;AAC9E,CAAC,CAAC"}

package/dist/categories/helpers/misc.d.ts

@@ -69,6 +69,24 @@ export declare const sub: (a: Vector3DTupleType, b: Vector3DTupleType) => Vector
  * ```
  */
 export declare const dot: (a: Vector3DTupleType, b: Vector3DTupleType) => number;
+/**
+ * Compute the **cross product** of two 3D vectors.
+ *
+ * $$
+ * \mathbf{a}\times\mathbf{b} = \begin{pmatrix} a_y b_z - a_z b_y \\ a_z b_x - a_x b_z \\ a_x b_y - a_y b_x \end{pmatrix}
+ * $$
+ *
+ * @param a - First vector.
+ * @param b - Second vector.
+ * @returns Cross product, perpendicular to both (units: product of the input component units).
+ * @group Helpers
+ *
+ * @example
+ * ```ts
+ * cross([1, 0, 0], [0, 1, 0]); // [0, 0, 1]
+ * ```
+ */
+export declare const cross: (a: Vector3DTupleType, b: Vector3DTupleType) => Vector3DTupleType;
 /**
  * Normalize an angle to the range **[0, 2π)**.
  *

package/dist/categories/helpers/misc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../../src/categories/helpers/misc.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEnE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,IAAI,GAAI,GAAG,iBAAiB,WAExC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,KAAK,GAAI,GAAG,iBAAiB,EAAE,GAAG,MAAM,KAAG,iBAEvD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,GAAG,GACd,GAAG,iBAAiB,EACpB,GAAG,iBAAiB,KACnB,iBAEF,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,GAAG,GAAI,GAAG,iBAAiB,EAAE,GAAG,iBAAiB,WAE7D,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,OAAO,GAAI,GAAG,MAAM,KAAG,MAEnC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,QAAQ,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,WAIvD,CAAC"}
+{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../../src/categories/helpers/misc.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEnE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,IAAI,GAAI,GAAG,iBAAiB,WAExC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,KAAK,GAAI,GAAG,iBAAiB,EAAE,GAAG,MAAM,KAAG,iBAEvD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,GAAG,GACd,GAAG,iBAAiB,EACpB,GAAG,iBAAiB,KACnB,iBAEF,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,GAAG,GAAI,GAAG,iBAAiB,EAAE,GAAG,iBAAiB,WAE7D,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,KAAK,GAChB,GAAG,iBAAiB,EACpB,GAAG,iBAAiB,KACnB,iBAMF,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,OAAO,GAAI,GAAG,MAAM,KAAG,MAEnC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,QAAQ,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,MAAM,WAIvD,CAAC"}

package/dist/categories/helpers/misc.js

@@ -77,6 +77,30 @@ export const sub = (a, b) => {
 export const dot = (a, b) => {
     return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 };
+/**
+ * Compute the **cross product** of two 3D vectors.
+ *
+ * $$
+ * \mathbf{a}\times\mathbf{b} = \begin{pmatrix} a_y b_z - a_z b_y \\ a_z b_x - a_x b_z \\ a_x b_y - a_y b_x \end{pmatrix}
+ * $$
+ *
+ * @param a - First vector.
+ * @param b - Second vector.
+ * @returns Cross product, perpendicular to both (units: product of the input component units).
+ * @group Helpers
+ *
+ * @example
+ * ```ts
+ * cross([1, 0, 0], [0, 1, 0]); // [0, 0, 1]
+ * ```
+ */
+export const cross = (a, b) => {
+    return [
+        a[1] * b[2] - a[2] * b[1],
+        a[2] * b[0] - a[0] * b[2],
+        a[0] * b[1] - a[1] * b[0]
+    ];
+};
 /**
  * Normalize an angle to the range **[0, 2π)**.
  *

package/dist/categories/helpers/misc.js.map

@@ -1 +1 @@
-{"version":3,"file":"misc.js","sourceRoot":"","sources":["../../../src/categories/helpers/misc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAGvD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,CAAoB,EAAE,EAAE;IAC3C,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACtC,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,CAAoB,EAAE,CAAS,EAAqB,EAAE;IAC1E,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AACxC,CAAC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,CACjB,CAAoB,EACpB,CAAoB,EACD,EAAE;IACrB,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACjD,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,CAAoB,EAAE,CAAoB,EAAE,EAAE;IAChE,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACjD,CAAC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,CAAS,EAAU,EAAE;IAC3C,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,MAAM,CAAC;AAC1C,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,EAAE;IAC1D,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAEtB,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;AAClC,CAAC,CAAC"}
+{"version":3,"file":"misc.js","sourceRoot":"","sources":["../../../src/categories/helpers/misc.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAGvD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,CAAoB,EAAE,EAAE;IAC3C,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACtC,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,CAAoB,EAAE,CAAS,EAAqB,EAAE;IAC1E,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AACxC,CAAC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,CACjB,CAAoB,EACpB,CAAoB,EACD,EAAE;IACrB,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACjD,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,CAAC,CAAoB,EAAE,CAAoB,EAAE,EAAE;IAChE,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACjD,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CACnB,CAAoB,EACpB,CAAoB,EACD,EAAE;IACrB,OAAO;QACL,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACzB,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACzB,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;KAC1B,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,CAAS,EAAU,EAAE;IAC3C,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,MAAM,CAAC;AAC1C,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAS,EAAE,CAAS,EAAE,CAAS,EAAE,EAAE;IAC1D,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAEtB,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;AAClC,CAAC,CAAC"}

package/dist/categories/kepler/solve-kepler-hyperbolic.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Solve **Kepler's equation for a hyperbola**: find the hyperbolic anomaly $ F $ from the hyperbolic mean anomaly $ M_h $.
+ *
+ * $$
+ * M_h = e \sinh F - F
+ * $$
+ *
+ * solved with Newton's method:
+ *
+ * $$
+ * F_{n+1} = F_n - \frac{e \sinh F_n - F_n - M_h}{e \cosh F_n - 1}, \qquad F_0 = \min\left(\operatorname{asinh}\frac{|M_h|}{e - 1},\ \sqrt[3]{\frac{6|M_h|}{e}}\right)
+ * $$
+ *
+ * **Units**
+ * - Inputs: `Mh` in **radians**, `e` dimensionless.
+ * - Output: $ F $ in **radians** (dimensionless, unbounded).
+ *
+ * ::: info Notes
+ *
+ * - The equation is odd in $ F $, so the solver works on $ |M_h| $ and restores the sign. Negative values are before periapsis.
+ * - $ F_0 $ is an upper bound on the root, since $ e\sinh F - F $ is at least $ (e-1)\sinh F $ and at least $ (e-1)F + eF^3/6 $. The function is increasing and convex for $ F > 0 $, so Newton's method converges monotonically from there, even close to $ e = 1 $ where the derivative $ e\cosh F - 1 $ is small near periapsis.
+ * - Unlike an ellipse, a hyperbola isn't periodic: $ M_h $ isn't reduced to one turn.
+ * - {@link solveKeplerHighEccentricity} also accepts $ e > 1 $, but this solver throws when it doesn't converge instead of returning its last estimate.
+ *
+ * :::
+ *
+ * @param Mh - Hyperbolic mean anomaly $ M_h $ in **radians** (finite).
+ * @param e - Eccentricity $ e $ (finite, > 1).
+ * @param tolerance - Stop when a step is smaller than `tolerance * max(1, |F|)`. Defaults to `1e-14`.
+ * @param maxIter - Maximum number of Newton steps. Defaults to `50`.
+ * @returns The hyperbolic anomaly $ F $ in **radians**, with the sign of `Mh`.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `e <= 1`, `tolerance <= 0` or `maxIter < 1`.
+ * @throws {Error} If the iteration doesn't converge within `maxIter` steps.
+ * @group Kepler Solvers
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * const F = solveKeplerHyperbolic(12.66 as Radians, 1.44);
+ * // F ≈ 3.087, and 1.44 * sinh(F) - F ≈ 12.66
+ * ```
+ *
+ * @see {@link hyperbolicTimeOfFlight}
+ * @see https://en.wikipedia.org/wiki/Hyperbolic_trajectory#Hyperbolic_anomaly Hyperbolic anomaly
+ */
+export declare const solveKeplerHyperbolic: (Mh: number, e: number, tolerance?: number, maxIter?: number) => number;
+//# sourceMappingURL=solve-kepler-hyperbolic.d.ts.map

package/dist/categories/kepler/solve-kepler-hyperbolic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solve-kepler-hyperbolic.d.ts","sourceRoot":"","sources":["../../../src/categories/kepler/solve-kepler-hyperbolic.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,qBAAqB,GAChC,IAAI,MAAM,EACV,GAAG,MAAM,EACT,kBAAiB,EACjB,gBAAY,KACX,MAsCF,CAAC"}

package/dist/categories/kepler/solve-kepler-hyperbolic.js

@@ -0,0 +1,90 @@
+/** sinh x - x, from its Taylor series for small x to avoid cancellation. */
+const sinhMinusX = (x) => {
+    if (Math.abs(x) > 0.5)
+        return Math.sinh(x) - x;
+    const x2 = x * x;
+    let term = (x * x2) / 6;
+    let sum = term;
+    for (let k = 5; Math.abs(term) > 1e-17 * Math.abs(sum); k += 2) {
+        term *= x2 / ((k - 1) * k);
+        sum += term;
+    }
+    return sum;
+};
+/**
+ * Solve **Kepler's equation for a hyperbola**: find the hyperbolic anomaly $ F $ from the hyperbolic mean anomaly $ M_h $.
+ *
+ * $$
+ * M_h = e \sinh F - F
+ * $$
+ *
+ * solved with Newton's method:
+ *
+ * $$
+ * F_{n+1} = F_n - \frac{e \sinh F_n - F_n - M_h}{e \cosh F_n - 1}, \qquad F_0 = \min\left(\operatorname{asinh}\frac{|M_h|}{e - 1},\ \sqrt[3]{\frac{6|M_h|}{e}}\right)
+ * $$
+ *
+ * **Units**
+ * - Inputs: `Mh` in **radians**, `e` dimensionless.
+ * - Output: $ F $ in **radians** (dimensionless, unbounded).
+ *
+ * ::: info Notes
+ *
+ * - The equation is odd in $ F $, so the solver works on $ |M_h| $ and restores the sign. Negative values are before periapsis.
+ * - $ F_0 $ is an upper bound on the root, since $ e\sinh F - F $ is at least $ (e-1)\sinh F $ and at least $ (e-1)F + eF^3/6 $. The function is increasing and convex for $ F > 0 $, so Newton's method converges monotonically from there, even close to $ e = 1 $ where the derivative $ e\cosh F - 1 $ is small near periapsis.
+ * - Unlike an ellipse, a hyperbola isn't periodic: $ M_h $ isn't reduced to one turn.
+ * - {@link solveKeplerHighEccentricity} also accepts $ e > 1 $, but this solver throws when it doesn't converge instead of returning its last estimate.
+ *
+ * :::
+ *
+ * @param Mh - Hyperbolic mean anomaly $ M_h $ in **radians** (finite).
+ * @param e - Eccentricity $ e $ (finite, > 1).
+ * @param tolerance - Stop when a step is smaller than `tolerance * max(1, |F|)`. Defaults to `1e-14`.
+ * @param maxIter - Maximum number of Newton steps. Defaults to `50`.
+ * @returns The hyperbolic anomaly $ F $ in **radians**, with the sign of `Mh`.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `e <= 1`, `tolerance <= 0` or `maxIter < 1`.
+ * @throws {Error} If the iteration doesn't converge within `maxIter` steps.
+ * @group Kepler Solvers
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * const F = solveKeplerHyperbolic(12.66 as Radians, 1.44);
+ * // F ≈ 3.087, and 1.44 * sinh(F) - F ≈ 12.66
+ * ```
+ *
+ * @see {@link hyperbolicTimeOfFlight}
+ * @see https://en.wikipedia.org/wiki/Hyperbolic_trajectory#Hyperbolic_anomaly Hyperbolic anomaly
+ */
+export const solveKeplerHyperbolic = (Mh, e, tolerance = 1e-14, maxIter = 50) => {
+    for (const [name, x] of [
+        ['Mh', Mh],
+        ['e', e],
+        ['tolerance', tolerance],
+        ['maxIter', maxIter]
+    ]) {
+        if (!Number.isFinite(x))
+            throw new TypeError(`${name} must be a finite number. Received: ${x}`);
+    }
+    if (e <= 1)
+        throw new RangeError(`e must be > 1. Received: ${e}`);
+    if (tolerance <= 0)
+        throw new RangeError(`tolerance must be > 0. Received: ${tolerance}`);
+    if (maxIter < 1)
+        throw new RangeError(`maxIter must be >= 1. Received: ${maxIter}`);
+    const M = Math.abs(Mh);
+    // Start above the root, where Newton's method can't overshoot
+    let F = Math.min(Math.asinh(M / (e - 1)), Math.cbrt((6 * M) / e));
+    for (let iter = 0; iter < maxIter; iter++) {
+        // e sinh F - F - M, written so nothing cancels when e ≈ 1 and F is small
+        const f = (e - 1) * F + e * sinhMinusX(F) - M;
+        const step = f / (e * Math.cosh(F) - 1);
+        F -= step;
+        if (Math.abs(step) <= tolerance * Math.max(1, Math.abs(F)))
+            return Math.sign(Mh) * F;
+    }
+    throw new Error(`solveKeplerHyperbolic did not converge in ${maxIter} steps. Received: Mh=${Mh}, e=${e}`);
+};
+//# sourceMappingURL=solve-kepler-hyperbolic.js.map

package/dist/categories/kepler/solve-kepler-hyperbolic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solve-kepler-hyperbolic.js","sourceRoot":"","sources":["../../../src/categories/kepler/solve-kepler-hyperbolic.ts"],"names":[],"mappings":"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"}

package/dist/categories/manoeuvres/burn-time.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Compute the **burn time** needed for a given delta-v, at constant thrust and mass flow.
+ *
+ * $$
+ * t_b = \frac{m_0 - m_f}{\dot m} = \frac{m_0\, I_{sp}\, g_0}{F}\left(1 - e^{-\Delta v/(I_{sp} g_0)}\right)
+ * $$
+ *
+ * Where:
+ * - $ m_0 $ is the mass at ignition (kg)
+ * - $ \Delta v $ is the delta-v of the burn (m/s)
+ * - $ F $ is the thrust (N)
+ * - $ I_{sp} $ is the specific impulse (s)
+ * - $ g_0 $ is standard gravity (m/s²)
+ *
+ * **Units**
+ * - Inputs: `m0` in **kg**, `dv` in **m/s**, `F` in **N**, `Isp` in **s**, `g0` in **m/s²**.
+ * - Output: $ t_b $ in **s**.
+ *
+ * ::: info Notes
+ *
+ * - The propellant used, $ m_0 - m_f $, comes from the rocket equation; the burn time is that mass divided by the {@link massFlowRate}.
+ * - Assumes constant thrust and specific impulse. A throttled engine, like Apollo's descent engine, needs the burn split into steps.
+ * - `dv = 0` gives a burn time of 0.
+ *
+ * :::
+ *
+ * ::: practice Apollo 11's lunar module, leaving the Moon
+ *
+ * **439 s**
+ *
+ * _Ascent stage, 4 888 kg, for 1 850.2 m/s_
+ *
+ * The flown burn took 434.9 s, 1% less: the thrust and specific impulse used here are the pre-flight predictions.
+ *
+ * ```ts
+ * burnTime(4888, 1850.2, 15_409, 309); // ≈ 439.3 s
+ * ```
+ *
+ * :::
+ *
+ * @param m0 - Mass at ignition $ m_0 $ in **kg** (finite, > 0).
+ * @param dv - Delta-v of the burn $ \Delta v $ in **m/s** (finite, >= 0).
+ * @param F - Thrust $ F $ in **N** (finite, > 0).
+ * @param Isp - Specific impulse $ I_{sp} $ in **seconds** (finite, > 0).
+ * @param g0 - Standard gravity $ g_0 $ in **m/s²** (finite, > 0). Defaults to `9.80665`.
+ * @returns Burn time $ t_b $ in **s**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `m0 <= 0`, `dv < 0`, `F <= 0`, `Isp <= 0` or `g0 <= 0`.
+ * @group Manoeuvres
+ *
+ * @example
+ * ```ts
+ * // A 1200 kg spacecraft, 500 m/s with a 400 N engine at Isp = 320 s
+ * const t = burnTime(1200, 500, 400, 320);
+ * // t ≈ 1200 * 3138.1 / 400 * (1 - e^(-500/3138.1)) ≈ 1387 s
+ * ```
+ *
+ * @see {@link massFlowRate}
+ * @see {@link rocketDeltaVFromIsp}
+ * @see https://en.wikipedia.org/wiki/Tsiolkovsky_rocket_equation Tsiolkovsky rocket equation
+ */
+export declare const burnTime: (m0: number, dv: number, F: number, Isp: number, g0?: number) => number;
+//# sourceMappingURL=burn-time.d.ts.map

package/dist/categories/manoeuvres/burn-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"burn-time.d.ts","sourceRoot":"","sources":["../../../src/categories/manoeuvres/burn-time.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,eAAO,MAAM,QAAQ,GACnB,IAAI,MAAM,EACV,IAAI,MAAM,EACV,GAAG,MAAM,EACT,KAAK,MAAM,EACX,WAAY,KACX,MA0BF,CAAC"}