@interstellar-tools/equations 0.9.0 → 0.11.0

package/dist/categories/manoeuvres/combine-burns-delta-v.js

@@ -0,0 +1,93 @@
+/* node:coverage disable */
+/**
+ * **Combine non-collinear burns** (vector law / law of cosines for velocities).
+ *
+ * **Definition**
+ *
+ * $$
+ * \Delta v=\sqrt{v_1^2+v_2^2-2\,v_1 v_2\cos\Delta\theta}
+ * $$
+ *
+ * where:
+ * - ($ v_1 $) and ($ v_2 $) are the **magnitudes** of two impulsive burns, and
+ * - ($ \Delta\theta $) is the **angle between their directions** (radians).
+ *
+ * **Units**
+ * - Inputs: ($ v_1,v_2 $) in **m/s**, ($ \Delta\theta $) in **radians**.
+ * - Output: ($ \Delta v $) in **m/s**.
+ *
+ * **Domain**
+ * - ($ v_1 \ge 0,\ v_2 \ge 0,\ \Delta\theta \in [0,\pi] $).
+ *
+ * ::: info Notes
+ *
+ * - Special cases:
+ *   - ($ \Delta\theta=0 $) (same direction) → ($ \Delta v = |v_1 - v_2| $).
+ *   - ($ \Delta\theta=\pi $) (opposite) → ($ \Delta v = v_1 + v_2 $).
+ * - This computes the **single equivalent impulse** from two burns applied
+ *   with mutual angle ($ \Delta\theta $) (i.e., magnitude of the vector sum).
+ *
+ * :::
+ *
+ * @param {number} v1 Magnitude of burn 1 (m/s). Must be finite and ≥ 0.
+ * @param {number} v2 Magnitude of burn 2 (m/s). Must be finite and ≥ 0.
+ * @param {Radians} deltaTheta Angle between burn directions (radians), in [0, π].
+ * @returns {number} Equivalent single ($ \Delta v $) (m/s).
+ * @throws {TypeError}  If any input is not a number.
+ * @throws {RangeError} If inputs are non-finite or out of domain.
+ * @group Manoeuvres
+ * @example
+ * ```ts
+ * import { combineBurnsDeltaV } from "@interstellar-tools/equations";
+ * import type { Radians } from "@interstellar-tools/types";
+ *
+ * // Helper: degrees → branded radians
+ * const toRadians = (deg: number): Radians => ((deg * Math.PI) / 180) as Radians;
+ *
+ * // Two burns (magnitudes in m/s)
+ * const v1 = 500;   // first impulse
+ * const v2 = 300;   // second impulse
+ *
+ * // 1) Same direction (Δθ = 0°) → Δv = |v1 - v2|
+ * const dv_same = combineBurnsDeltaV(v1, v2, toRadians(0));
+ * console.log("Δθ = 0°   → Δv =", dv_same.toFixed(3), "m/s");
+ *
+ * // 2) Opposite directions (Δθ = 180°) → Δv = v1 + v2
+ * const dv_opp = combineBurnsDeltaV(v1, v2, toRadians(180));
+ * console.log("Δθ = 180° → Δv =", dv_opp.toFixed(3), "m/s");
+ *
+ * // 3) General non-collinear case (e.g., Δθ = 60°)
+ * const dv_60 = combineBurnsDeltaV(v1, v2, toRadians(60));
+ * console.log("Δθ = 60°  → Δv =", dv_60.toFixed(3), "m/s");
+ *
+ * // 4) Another example (Δθ = 25°)
+ * const dv_25 = combineBurnsDeltaV(1200, 800, toRadians(25));
+ * console.log("Δθ = 25°  → Δv =", dv_25.toFixed(3), "m/s");
+ * ```
+ */
+/* node:coverage enable */
+export const combineBurnsDeltaV = (v1, v2, deltaTheta) => {
+    if (typeof v1 !== 'number' || typeof v2 !== 'number')
+        throw new TypeError('v1 and v2 must be numbers (m/s).');
+    if (typeof deltaTheta !== 'number')
+        throw new TypeError('deltaTheta must be a number (radians).');
+    if (!Number.isFinite(v1) || v1 < 0)
+        throw new RangeError('v1 must be finite and ≥ 0 (m/s).');
+    if (!Number.isFinite(v2) || v2 < 0)
+        throw new RangeError('v2 must be finite and ≥ 0 (m/s).');
+    if (!Number.isFinite(deltaTheta))
+        throw new RangeError('deltaTheta must be finite (radians).');
+    if (deltaTheta < 0 || deltaTheta > Math.PI)
+        throw new RangeError('deltaTheta must be in [0, π] radians.');
+    const c = Math.cos(deltaTheta);
+    const radicand = v1 * v1 + v2 * v2 - 2 * v1 * v2 * c;
+    // FP guard: clamp tiny negative to zero
+    if (radicand < 0) {
+        const tol = 1e-12 * (v1 * v1 + v2 * v2);
+        if (radicand > -tol)
+            return 0;
+        throw new RangeError(`Numerically invalid radicand for given inputs (v1=${v1}, v2=${v2}, Δθ=${deltaTheta}).`);
+    }
+    return Math.sqrt(radicand);
+};
+//# sourceMappingURL=combine-burns-delta-v.js.map

package/dist/categories/manoeuvres/combine-burns-delta-v.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"combine-burns-delta-v.js","sourceRoot":"","sources":["../../../src/categories/manoeuvres/combine-burns-delta-v.ts"],"names":[],"mappings":"AAEA,2BAA2B;AAC3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,0BAA0B;AAC1B,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,EAAU,EACV,EAAU,EACV,UAAmB,EACX,EAAE;IACV,IAAI,OAAO,EAAE,KAAK,QAAQ,IAAI,OAAO,EAAE,KAAK,QAAQ;QAClD,MAAM,IAAI,SAAS,CAAC,kCAAkC,CAAC,CAAC;IAE1D,IAAI,OAAO,UAAU,KAAK,QAAQ;QAChC,MAAM,IAAI,SAAS,CAAC,wCAAwC,CAAC,CAAC;IAEhE,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;QAChC,MAAM,IAAI,UAAU,CAAC,kCAAkC,CAAC,CAAC;IAE3D,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;QAChC,MAAM,IAAI,UAAU,CAAC,kCAAkC,CAAC,CAAC;IAE3D,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC;QAC9B,MAAM,IAAI,UAAU,CAAC,sCAAsC,CAAC,CAAC;IAE/D,IAAI,UAAU,GAAG,CAAC,IAAI,UAAU,GAAG,IAAI,CAAC,EAAE;QACxC,MAAM,IAAI,UAAU,CAAC,uCAAuC,CAAC,CAAC;IAEhE,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,UAAoB,CAAC,CAAC;IACzC,MAAM,QAAQ,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IAErD,wCAAwC;IACxC,IAAI,QAAQ,GAAG,CAAC,EAAE,CAAC;QACjB,MAAM,GAAG,GAAG,KAAK,GAAG,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC;QAExC,IAAI,QAAQ,GAAG,CAAC,GAAG;YAAE,OAAO,CAAC,CAAC;QAE9B,MAAM,IAAI,UAAU,CAClB,qDAAqD,EAAE,QAAQ,EAAE,QAAQ,UAAU,IAAI,CACxF,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AAC7B,CAAC,CAAC"}

package/dist/categories/manoeuvres/hohmann-transfer.d.ts

@@ -0,0 +1,74 @@
+export type HohmannTransferReturnType = {
+    at: number;
+    dv1: number;
+    dv2: number;
+    dvTotal: number;
+    tTransfer: number;
+    dir1: 'prograde' | 'retrograde' | 'none';
+    dir2: 'prograde' | 'retrograde' | 'none';
+};
+/**
+ * **Hohmann transfer** (coplanar, circular ($ r_1 \to r_2 $)).
+ *
+ * **Definitions**
+ *
+ * $$
+ * a_t=\frac{r_1+r_2}{2}
+ * $$
+ * $$
+ * \Delta v_1=\sqrt{\frac{\mu}{r_1}}\!\left(\sqrt{\frac{2r_2}{r_1+r_2}}-1\right),\qquad
+ * \Delta v_2=\sqrt{\frac{\mu}{r_2}}\!\left(1-\sqrt{\frac{2r_1}{r_1+r_2}}\right)
+ * $$
+ * $$
+ * \Delta v_{\text{total}}=\Delta v_1+\Delta v_2,\qquad
+ * t_t=\pi \sqrt{\frac{a_t^3}{\mu}}
+ * $$
+ *
+ * **Conventions**
+ * - Inputs in **SI**: ($ r_1,r_2 $) in **meters**, ($ \mu $) in **m³/s²**.
+ * - The returned ($ \Delta v_1,\Delta v_2 $) are **magnitudes** (non-negative).
+ *   Their **signs** (prograde/retrograde) are provided separately for clarity.
+ * - Works for ($ r_2>r_1 $) (raise) and ($ r_2<r_1 $) (lower). If ($ r_1=r_2 $): ($ \Delta v $)s are 0 and ($ t_t $) is half the circular period.
+ *
+ * **Domain**
+ * - ($ r_1>0,\ r_2>0,\ \mu>0 $)
+ *
+ * @param {number} r1 Initial circular-orbit radius (m).
+ * @param {number} r2 Target circular-orbit radius (m).
+ * @param {number} mu Standard gravitational parameter ($ \mu $) (m³/s²).
+ * @returns {HohmannTransferReturnType}
+ * Object with transfer semi-major axis `at` (m), burn magnitudes `dv1`, `dv2`, their sum `dvTotal` (m/s), transfer time `tTransfer` (s),
+ * and burn directions `dir1`, `dir2`.
+ *
+ * @throws {TypeError}  If an input is not a number.
+ * @throws {RangeError} If ($ r_1\le 0 $), ($ r_2\le 0 $), or ($ \mu\le 0 $), or a value is non-finite.
+ *
+ * @group Manoeuvres
+ */
+export declare const hohmannTransfer: (r1: number, r2: number, mu: number) => HohmannTransferReturnType;
+/**
+ * Convenience: compute only the **semi-major axis** ($ a_t $) (m) of the Hohmann transfer.
+ *
+ * $$ a_t=\frac{r_1+r_2}{2} $$
+ *
+ * @param {number} r1 Initial circular-orbit radius (m).
+ * @param {number} r2 Target circular-orbit radius (m).
+ * @returns {number} ($ a_t $) (m).
+ * @throws {TypeError|RangeError} On invalid inputs.
+ * @group Manoeuvres
+ */
+export declare const hohmannSemiMajorAxis: (r1: number, r2: number) => number;
+/**
+ * Convenience: compute only the **transfer time** ($ t_t $) (s).
+ *
+ * $$ t_t=\pi \sqrt{\frac{a_t^3}{\mu}} $$
+ *
+ * @param {number} r1 Initial radius (m).
+ * @param {number} r2 Target radius (m).
+ * @param {number} mu Gravitational parameter (m³/s²).
+ * @returns {number} Transfer time ($ t_t $) (s).
+ * @throws {TypeError|RangeError} On invalid inputs.
+ * @group Manoeuvres
+ */
+export declare const hohmannTransferTime: (r1: number, r2: number, mu: number) => number;
+//# sourceMappingURL=hohmann-transfer.d.ts.map

package/dist/categories/manoeuvres/hohmann-transfer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hohmann-transfer.d.ts","sourceRoot":"","sources":["../../../src/categories/manoeuvres/hohmann-transfer.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,yBAAyB,GAAG;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,UAAU,GAAG,YAAY,GAAG,MAAM,CAAC;IACzC,IAAI,EAAE,UAAU,GAAG,YAAY,GAAG,MAAM,CAAC;CAC1C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,eAAe,GAC1B,IAAI,MAAM,EACV,IAAI,MAAM,EACV,IAAI,MAAM,KACT,yBAkDF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,GAAI,IAAI,MAAM,EAAE,IAAI,MAAM,KAAG,MAU7D,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,GAC9B,IAAI,MAAM,EACV,IAAI,MAAM,EACV,IAAI,MAAM,KACT,MASF,CAAC"}

package/dist/categories/manoeuvres/hohmann-transfer.js

@@ -0,0 +1,120 @@
+/**
+ * **Hohmann transfer** (coplanar, circular ($ r_1 \to r_2 $)).
+ *
+ * **Definitions**
+ *
+ * $$
+ * a_t=\frac{r_1+r_2}{2}
+ * $$
+ * $$
+ * \Delta v_1=\sqrt{\frac{\mu}{r_1}}\!\left(\sqrt{\frac{2r_2}{r_1+r_2}}-1\right),\qquad
+ * \Delta v_2=\sqrt{\frac{\mu}{r_2}}\!\left(1-\sqrt{\frac{2r_1}{r_1+r_2}}\right)
+ * $$
+ * $$
+ * \Delta v_{\text{total}}=\Delta v_1+\Delta v_2,\qquad
+ * t_t=\pi \sqrt{\frac{a_t^3}{\mu}}
+ * $$
+ *
+ * **Conventions**
+ * - Inputs in **SI**: ($ r_1,r_2 $) in **meters**, ($ \mu $) in **m³/s²**.
+ * - The returned ($ \Delta v_1,\Delta v_2 $) are **magnitudes** (non-negative).
+ *   Their **signs** (prograde/retrograde) are provided separately for clarity.
+ * - Works for ($ r_2>r_1 $) (raise) and ($ r_2<r_1 $) (lower). If ($ r_1=r_2 $): ($ \Delta v $)s are 0 and ($ t_t $) is half the circular period.
+ *
+ * **Domain**
+ * - ($ r_1>0,\ r_2>0,\ \mu>0 $)
+ *
+ * @param {number} r1 Initial circular-orbit radius (m).
+ * @param {number} r2 Target circular-orbit radius (m).
+ * @param {number} mu Standard gravitational parameter ($ \mu $) (m³/s²).
+ * @returns {HohmannTransferReturnType}
+ * Object with transfer semi-major axis `at` (m), burn magnitudes `dv1`, `dv2`, their sum `dvTotal` (m/s), transfer time `tTransfer` (s),
+ * and burn directions `dir1`, `dir2`.
+ *
+ * @throws {TypeError}  If an input is not a number.
+ * @throws {RangeError} If ($ r_1\le 0 $), ($ r_2\le 0 $), or ($ \mu\le 0 $), or a value is non-finite.
+ *
+ * @group Manoeuvres
+ */
+export const hohmannTransfer = (r1, r2, mu) => {
+    // Type & range checks
+    if (typeof r1 !== 'number' ||
+        typeof r2 !== 'number' ||
+        typeof mu !== 'number') {
+        throw new TypeError('r1, r2, and mu must be numbers.');
+    }
+    if (!Number.isFinite(r1) || !Number.isFinite(r2) || !Number.isFinite(mu)) {
+        throw new RangeError('r1, r2, and mu must be finite.');
+    }
+    if (r1 <= 0 || r2 <= 0 || mu <= 0) {
+        throw new RangeError('r1 and r2 must be > 0 (m), mu must be > 0 (m^3/s^2).');
+    }
+    const at = 0.5 * (r1 + r2);
+    // Circular speeds at the endpoints
+    const v1c = Math.sqrt(mu / r1);
+    const v2c = Math.sqrt(mu / r2);
+    // Transfer-ellipse speeds at peri/apo
+    const vPeriTrans = Math.sqrt(mu * (2 / r1 - 1 / at)); // speed at r1 on transfer
+    const vApoTrans = Math.sqrt(mu * (2 / r2 - 1 / at)); // speed at r2 on transfer
+    // Signed burns relative to local circular velocity direction.
+    // Positive => prograde (speed up), negative => retrograde (slow down).
+    const signedDv1 = vPeriTrans - v1c;
+    const signedDv2 = v2c - vApoTrans;
+    const dv1 = Math.abs(signedDv1);
+    const dv2 = Math.abs(signedDv2);
+    const dvTotal = dv1 + dv2;
+    const dir1 = Math.abs(signedDv1) < 1e-15
+        ? 'none'
+        : signedDv1 > 0
+            ? 'prograde'
+            : 'retrograde';
+    const dir2 = Math.abs(signedDv2) < 1e-15
+        ? 'none'
+        : signedDv2 > 0
+            ? 'prograde'
+            : 'retrograde';
+    // Half the period of the transfer ellipse
+    const tTransfer = Math.PI * Math.sqrt((at * at * at) / mu);
+    return { at, dv1, dv2, dvTotal, tTransfer, dir1, dir2 };
+};
+/**
+ * Convenience: compute only the **semi-major axis** ($ a_t $) (m) of the Hohmann transfer.
+ *
+ * $$ a_t=\frac{r_1+r_2}{2} $$
+ *
+ * @param {number} r1 Initial circular-orbit radius (m).
+ * @param {number} r2 Target circular-orbit radius (m).
+ * @returns {number} ($ a_t $) (m).
+ * @throws {TypeError|RangeError} On invalid inputs.
+ * @group Manoeuvres
+ */
+export const hohmannSemiMajorAxis = (r1, r2) => {
+    if (typeof r1 !== 'number' || typeof r2 !== 'number')
+        throw new TypeError('r1 and r2 must be numbers.');
+    if (!Number.isFinite(r1) || !Number.isFinite(r2))
+        throw new RangeError('r1 and r2 must be finite.');
+    if (r1 <= 0 || r2 <= 0)
+        throw new RangeError('r1 and r2 must be > 0 (m).');
+    return 0.5 * (r1 + r2);
+};
+/**
+ * Convenience: compute only the **transfer time** ($ t_t $) (s).
+ *
+ * $$ t_t=\pi \sqrt{\frac{a_t^3}{\mu}} $$
+ *
+ * @param {number} r1 Initial radius (m).
+ * @param {number} r2 Target radius (m).
+ * @param {number} mu Gravitational parameter (m³/s²).
+ * @returns {number} Transfer time ($ t_t $) (s).
+ * @throws {TypeError|RangeError} On invalid inputs.
+ * @group Manoeuvres
+ */
+export const hohmannTransferTime = (r1, r2, mu) => {
+    const at = hohmannSemiMajorAxis(r1, r2);
+    if (typeof mu !== 'number')
+        throw new TypeError('mu must be a number.');
+    if (!Number.isFinite(mu) || mu <= 0)
+        throw new RangeError('mu must be finite and > 0 (m^3/s^2).');
+    return Math.PI * Math.sqrt((at * at * at) / mu);
+};
+//# sourceMappingURL=hohmann-transfer.js.map

package/dist/categories/manoeuvres/hohmann-transfer.js.map

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

package/dist/categories/manoeuvres/oberth-energy-gain.d.ts

@@ -0,0 +1,66 @@
+/**
+ * **Oberth effect (specific energy gain near periapsis)**.
+ *
+ * **Approximation**
+ *
+ * $$
+ * \Delta \varepsilon \;\approx\; v\,\Delta v
+ * $$
+ *
+ * where:
+ * - ($ v $) is the instantaneous **speed** at the burn point (typically periapsis),
+ * - ($ \Delta v $) is the **impulsive** prograde burn magnitude,
+ * - ($ \Delta \varepsilon $) is the change in **specific mechanical energy** (J/kg ≡ m²/s²).
+ *
+ * **Units**
+ * - Inputs: ($ v $) in **m/s**, ($ \Delta v $) in **m/s**.
+ * - Output: ($ \Delta \varepsilon $) in **J/kg** (m²/s²).
+ *
+ * ::: info Notes
+ *
+ * - This approximation assumes a **small**, **prograde** impulse (aligned with velocity) and
+ *   neglects higher-order terms ($ \tfrac{1}{2}(\Delta v)^2 $).
+ * - A more general small-angle form is ($ \Delta \varepsilon \approx v\,\Delta v\cos\phi $),
+ *   where ($ \phi $) is the angle between the velocity vector and the burn direction.
+ *
+ * :::
+ *
+ * @param {number} v  Instantaneous speed at burn point (m/s). Must be finite and ≥ 0.
+ * @param {number} dv Impulsive prograde Δv magnitude (m/s). Must be finite and ≥ 0.
+ * @returns {number} Specific energy gain ($ \Delta \varepsilon $) (J/kg).
+ * @throws {TypeError}  If inputs are not numbers.
+ * @throws {RangeError} If inputs are non-finite or negative.
+ * @group Manoeuvres
+ * @example
+ * ```ts
+ * import { oberthEnergyGain, circularSpeed } from "@interstellar-tools/equations";
+ *
+ * // Earth's GM (μ) in m^3/s^2
+ * const muEarth = 3.986004418e14;
+ *
+ * // Example: small prograde burn at LEO periapsis (~400 km altitude)
+ * const rLEO = 6378e3 + 400e3;      // m
+ * const vLEO = circularSpeed(rLEO, muEarth); // m/s ≈ 7670
+ *
+ * // Suppose guidance commands a small impulsive burn Δv = 50 m/s at periapsis
+ * const dv = 50; // m/s
+ *
+ * // Oberth approximation: Δε ≈ v · Δv  (specific energy gain, J/kg ≡ m^2/s^2)
+ * const deltaEps = oberthEnergyGain(vLEO, dv);
+ *
+ * // For intuition, translate Δε to an approximate change in semi-major axis (elliptic case):
+ * // ε = -μ/(2a)  ⇒  Δa ≈ (a^2 / μ) · Δε (valid for small changes around circular LEO)
+ * const aLEO = rLEO; // circular → a = r
+ * const deltaA = (aLEO * aLEO / muEarth) * deltaEps; // meters
+ *
+ * console.log(`LEO speed v ≈ ${vLEO.toFixed(1)} m/s`);
+ * console.log(`Prograde Δv  = ${dv.toFixed(1)} m/s`);
+ * console.log(`Specific energy gain Δε ≈ ${deltaEps.toFixed(0)} J/kg`);
+ * console.log(`Approx. semi-major axis change Δa ≈ ${deltaA.toFixed(0)} m`);
+ *
+ * // Tip: If the burn is not perfectly prograde by angle φ (in radians),
+ * // scale by cos φ: Δε ≈ v · Δv · cos φ  (small-angle approximation).
+ * ```
+ */
+export declare const oberthEnergyGain: (v: number, dv: number) => number;
+//# sourceMappingURL=oberth-energy-gain.d.ts.map

package/dist/categories/manoeuvres/oberth-energy-gain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oberth-energy-gain.d.ts","sourceRoot":"","sources":["../../../src/categories/manoeuvres/oberth-energy-gain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,eAAO,MAAM,gBAAgB,GAAI,GAAG,MAAM,EAAE,IAAI,MAAM,KAAG,MAexD,CAAC"}

package/dist/categories/manoeuvres/oberth-energy-gain.js

@@ -0,0 +1,78 @@
+/**
+ * **Oberth effect (specific energy gain near periapsis)**.
+ *
+ * **Approximation**
+ *
+ * $$
+ * \Delta \varepsilon \;\approx\; v\,\Delta v
+ * $$
+ *
+ * where:
+ * - ($ v $) is the instantaneous **speed** at the burn point (typically periapsis),
+ * - ($ \Delta v $) is the **impulsive** prograde burn magnitude,
+ * - ($ \Delta \varepsilon $) is the change in **specific mechanical energy** (J/kg ≡ m²/s²).
+ *
+ * **Units**
+ * - Inputs: ($ v $) in **m/s**, ($ \Delta v $) in **m/s**.
+ * - Output: ($ \Delta \varepsilon $) in **J/kg** (m²/s²).
+ *
+ * ::: info Notes
+ *
+ * - This approximation assumes a **small**, **prograde** impulse (aligned with velocity) and
+ *   neglects higher-order terms ($ \tfrac{1}{2}(\Delta v)^2 $).
+ * - A more general small-angle form is ($ \Delta \varepsilon \approx v\,\Delta v\cos\phi $),
+ *   where ($ \phi $) is the angle between the velocity vector and the burn direction.
+ *
+ * :::
+ *
+ * @param {number} v  Instantaneous speed at burn point (m/s). Must be finite and ≥ 0.
+ * @param {number} dv Impulsive prograde Δv magnitude (m/s). Must be finite and ≥ 0.
+ * @returns {number} Specific energy gain ($ \Delta \varepsilon $) (J/kg).
+ * @throws {TypeError}  If inputs are not numbers.
+ * @throws {RangeError} If inputs are non-finite or negative.
+ * @group Manoeuvres
+ * @example
+ * ```ts
+ * import { oberthEnergyGain, circularSpeed } from "@interstellar-tools/equations";
+ *
+ * // Earth's GM (μ) in m^3/s^2
+ * const muEarth = 3.986004418e14;
+ *
+ * // Example: small prograde burn at LEO periapsis (~400 km altitude)
+ * const rLEO = 6378e3 + 400e3;      // m
+ * const vLEO = circularSpeed(rLEO, muEarth); // m/s ≈ 7670
+ *
+ * // Suppose guidance commands a small impulsive burn Δv = 50 m/s at periapsis
+ * const dv = 50; // m/s
+ *
+ * // Oberth approximation: Δε ≈ v · Δv  (specific energy gain, J/kg ≡ m^2/s^2)
+ * const deltaEps = oberthEnergyGain(vLEO, dv);
+ *
+ * // For intuition, translate Δε to an approximate change in semi-major axis (elliptic case):
+ * // ε = -μ/(2a)  ⇒  Δa ≈ (a^2 / μ) · Δε (valid for small changes around circular LEO)
+ * const aLEO = rLEO; // circular → a = r
+ * const deltaA = (aLEO * aLEO / muEarth) * deltaEps; // meters
+ *
+ * console.log(`LEO speed v ≈ ${vLEO.toFixed(1)} m/s`);
+ * console.log(`Prograde Δv  = ${dv.toFixed(1)} m/s`);
+ * console.log(`Specific energy gain Δε ≈ ${deltaEps.toFixed(0)} J/kg`);
+ * console.log(`Approx. semi-major axis change Δa ≈ ${deltaA.toFixed(0)} m`);
+ *
+ * // Tip: If the burn is not perfectly prograde by angle φ (in radians),
+ * // scale by cos φ: Δε ≈ v · Δv · cos φ  (small-angle approximation).
+ * ```
+ */
+export const oberthEnergyGain = (v, dv) => {
+    if (typeof v !== 'number' || typeof dv !== 'number') {
+        throw new TypeError('v and dv must be numbers (m/s).');
+    }
+    if (!Number.isFinite(v) || v < 0) {
+        throw new RangeError('v must be finite and ≥ 0 (m/s).');
+    }
+    if (!Number.isFinite(dv) || dv < 0) {
+        throw new RangeError('dv must be finite and ≥ 0 (m/s).');
+    }
+    // Δε ≈ v · Δv  (prograde, small-Δv approximation)
+    return v * dv;
+};
+//# sourceMappingURL=oberth-energy-gain.js.map

package/dist/categories/manoeuvres/oberth-energy-gain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oberth-energy-gain.js","sourceRoot":"","sources":["../../../src/categories/manoeuvres/oberth-energy-gain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAS,EAAE,EAAU,EAAU,EAAE;IAChE,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,EAAE,KAAK,QAAQ,EAAE,CAAC;QACpD,MAAM,IAAI,SAAS,CAAC,iCAAiC,CAAC,CAAC;IACzD,CAAC;IAED,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,UAAU,CAAC,iCAAiC,CAAC,CAAC;IAC1D,CAAC;IAED,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC;QACnC,MAAM,IAAI,UAAU,CAAC,kCAAkC,CAAC,CAAC;IAC3D,CAAC;IAED,kDAAkD;IAClD,OAAO,CAAC,GAAG,EAAE,CAAC;AAChB,CAAC,CAAC"}

package/dist/categories/manoeuvres/plane-change-delta-v.d.ts

@@ -0,0 +1,57 @@
+import type { Radians } from '@interstellar-tools/types';
+/**
+ * **Inclination (plane) change** Δv at speed ($ v $).
+ *
+ * **Definition**
+ *
+ * $$
+ * \Delta v = 2\,v\,\sin\!\left(\frac{\Delta i}{2}\right)
+ * $$
+ *
+ * **Units**
+ * - Inputs: ($ v $) in **m/s**, ($ \Delta i $) in **radians**.
+ * - Output: ($ \Delta v $) in **m/s**.
+ *
+ * ::: info Notes
+ *
+ * - Valid for an **instantaneous** plane change (impulsive) performed at speed ($ v $)
+ *   (e.g., at a node). For best efficiency, perform at **apogee** (lowest speed) when possible.
+ * - Domain for ($ \Delta i $) is ( $[0,\pi] $) (0–180°). Larger angles can be reduced modulo ($ 2\pi $).
+ *
+ * :::
+ *
+ * @param {number} v  Current speed magnitude (m/s). Must be finite and ≥ 0.
+ * @param {Radians} deltaI  Inclination change angle Δi (radians). Must be finite and 0 ≤ Δi ≤ π.
+ * @returns {number} Required impulsive Δv (m/s).
+ * @throws {TypeError}  If `v` is not a number or `deltaI` not a number (radians).
+ * @throws {RangeError} If `v` is non-finite or < 0; if `deltaI` is non-finite or outside [0, π].
+ * @group Manoeuvres
+ * @example
+ * ```ts
+ * import { planeChangeDeltaV, circularSpeed } from "@interstellar-tools/equations";
+ * import type { Radians } from "@interstellar-tools/types";
+ *
+ * // Helper: degrees → radians (branded)
+ * const toRadians = (deg: number): Radians => ((deg * Math.PI) / 180) as Radians;
+ *
+ * // Earth’s GM (μ) in m^3/s^2
+ * const muEarth = 3.986004418e14;
+ *
+ * // Example: instantaneous plane change at LEO (~400 km altitude)
+ * const rLEO = 6378e3 + 400e3; // meters
+ * const vLEO = circularSpeed(rLEO, muEarth); // m/s
+ *
+ * // Change from 28.5° (Kennedy inclination) to equatorial (0°) → Δi = 28.5°
+ * const deltaI = toRadians(28.5);
+ * const dv_LEO = planeChangeDeltaV(vLEO, deltaI);
+ *
+ * console.log(`LEO speed: ${vLEO.toFixed(1)} m/s`);
+ * console.log(`Δi: 28.5°  →  Δv ≈ ${dv_LEO.toFixed(1)} m/s`);
+ *
+ * // Another quick check: a modest 10° plane change at the same altitude
+ * const dv_10deg = planeChangeDeltaV(vLEO, toRadians(10));
+ * console.log(`Δi: 10°    →  Δv ≈ ${dv_10deg.toFixed(1)} m/s`);
+ * ```
+ */
+export declare const planeChangeDeltaV: (v: number, deltaI: Radians) => number;
+//# sourceMappingURL=plane-change-delta-v.d.ts.map

package/dist/categories/manoeuvres/plane-change-delta-v.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plane-change-delta-v.d.ts","sourceRoot":"","sources":["../../../src/categories/manoeuvres/plane-change-delta-v.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,eAAO,MAAM,iBAAiB,GAAI,GAAG,MAAM,EAAE,QAAQ,OAAO,KAAG,MAiB9D,CAAC"}

package/dist/categories/manoeuvres/plane-change-delta-v.js

@@ -0,0 +1,69 @@
+/**
+ * **Inclination (plane) change** Δv at speed ($ v $).
+ *
+ * **Definition**
+ *
+ * $$
+ * \Delta v = 2\,v\,\sin\!\left(\frac{\Delta i}{2}\right)
+ * $$
+ *
+ * **Units**
+ * - Inputs: ($ v $) in **m/s**, ($ \Delta i $) in **radians**.
+ * - Output: ($ \Delta v $) in **m/s**.
+ *
+ * ::: info Notes
+ *
+ * - Valid for an **instantaneous** plane change (impulsive) performed at speed ($ v $)
+ *   (e.g., at a node). For best efficiency, perform at **apogee** (lowest speed) when possible.
+ * - Domain for ($ \Delta i $) is ( $[0,\pi] $) (0–180°). Larger angles can be reduced modulo ($ 2\pi $).
+ *
+ * :::
+ *
+ * @param {number} v  Current speed magnitude (m/s). Must be finite and ≥ 0.
+ * @param {Radians} deltaI  Inclination change angle Δi (radians). Must be finite and 0 ≤ Δi ≤ π.
+ * @returns {number} Required impulsive Δv (m/s).
+ * @throws {TypeError}  If `v` is not a number or `deltaI` not a number (radians).
+ * @throws {RangeError} If `v` is non-finite or < 0; if `deltaI` is non-finite or outside [0, π].
+ * @group Manoeuvres
+ * @example
+ * ```ts
+ * import { planeChangeDeltaV, circularSpeed } from "@interstellar-tools/equations";
+ * import type { Radians } from "@interstellar-tools/types";
+ *
+ * // Helper: degrees → radians (branded)
+ * const toRadians = (deg: number): Radians => ((deg * Math.PI) / 180) as Radians;
+ *
+ * // Earth’s GM (μ) in m^3/s^2
+ * const muEarth = 3.986004418e14;
+ *
+ * // Example: instantaneous plane change at LEO (~400 km altitude)
+ * const rLEO = 6378e3 + 400e3; // meters
+ * const vLEO = circularSpeed(rLEO, muEarth); // m/s
+ *
+ * // Change from 28.5° (Kennedy inclination) to equatorial (0°) → Δi = 28.5°
+ * const deltaI = toRadians(28.5);
+ * const dv_LEO = planeChangeDeltaV(vLEO, deltaI);
+ *
+ * console.log(`LEO speed: ${vLEO.toFixed(1)} m/s`);
+ * console.log(`Δi: 28.5°  →  Δv ≈ ${dv_LEO.toFixed(1)} m/s`);
+ *
+ * // Another quick check: a modest 10° plane change at the same altitude
+ * const dv_10deg = planeChangeDeltaV(vLEO, toRadians(10));
+ * console.log(`Δi: 10°    →  Δv ≈ ${dv_10deg.toFixed(1)} m/s`);
+ * ```
+ */
+export const planeChangeDeltaV = (v, deltaI) => {
+    if (typeof v !== 'number')
+        throw new TypeError('v must be a number (m/s).');
+    if (!Number.isFinite(v) || v < 0)
+        throw new RangeError('v must be finite and ≥ 0 (m/s).');
+    if (typeof deltaI !== 'number')
+        throw new TypeError('deltaI must be a number (radians).');
+    if (!Number.isFinite(deltaI))
+        throw new RangeError('deltaI must be finite (radians).');
+    if (deltaI < 0 || deltaI > Math.PI)
+        throw new RangeError('deltaI must be in [0, π] radians.');
+    // Δv = 2 v sin(Δi / 2)
+    return 2 * v * Math.sin(deltaI / 2);
+};
+//# sourceMappingURL=plane-change-delta-v.js.map

package/dist/categories/manoeuvres/plane-change-delta-v.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plane-change-delta-v.js","sourceRoot":"","sources":["../../../src/categories/manoeuvres/plane-change-delta-v.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAS,EAAE,MAAe,EAAU,EAAE;IACtE,IAAI,OAAO,CAAC,KAAK,QAAQ;QAAE,MAAM,IAAI,SAAS,CAAC,2BAA2B,CAAC,CAAC;IAE5E,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;QAC9B,MAAM,IAAI,UAAU,CAAC,iCAAiC,CAAC,CAAC;IAE1D,IAAI,OAAO,MAAM,KAAK,QAAQ;QAC5B,MAAM,IAAI,SAAS,CAAC,oCAAoC,CAAC,CAAC;IAE5D,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC;QAC1B,MAAM,IAAI,UAAU,CAAC,kCAAkC,CAAC,CAAC;IAE3D,IAAI,MAAM,GAAG,CAAC,IAAI,MAAM,GAAG,IAAI,CAAC,EAAE;QAChC,MAAM,IAAI,UAAU,CAAC,mCAAmC,CAAC,CAAC;IAE5D,uBAAuB;IACvB,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAE,MAAiB,GAAG,CAAC,CAAC,CAAC;AAClD,CAAC,CAAC"}

package/dist/index.d.ts

@@ -5,23 +5,27 @@
  */
 export * from './categories/angle/compute-angle';
 export * from './categories/angle/wrap-angle';
-export * from './categories/anomalies/mean-to-eccentric-anomaly';
 export * from './categories/anomalies/eccentric-to-true-anomaly';
+export * from './categories/anomalies/mean-to-eccentric-anomaly';
 export * from './categories/anomalies/true-to-mean-anomaly';
-export * from './categories/kepler/solve-kepler';
-export * from './categories/kepler/solve-kepler-newton-raphson';
 export * from './categories/kepler/solve-kepler-bisection';
 export * from './categories/kepler/solve-kepler-high-eccentricity';
-export * from './categories/gravity/gravitational-parameter';
-export * from './categories/gravity/gravitational-force';
-export * from './categories/gravity/force-on1-by2';
+export * from './categories/kepler/solve-kepler-newton-raphson';
+export * from './categories/kepler/solve-kepler';
 export * from './categories/gravity/acceleration-on1-by2';
-export * from './categories/orbits/vis-viva-speed';
+export * from './categories/gravity/force-on1-by2';
+export * from './categories/gravity/gravitational-force';
+export * from './categories/gravity/gravitational-parameter';
 export * from './categories/orbits/circular-speed';
 export * from './categories/orbits/escape-speed';
+export * from './categories/orbits/flight-path-angle-from-true-anomaly';
 export * from './categories/orbits/kepler-period';
-export * from './categories/orbits/specific-angular-momentum';
 export * from './categories/orbits/specific-angular-momentum-from-elements';
+export * from './categories/orbits/specific-angular-momentum';
 export * from './categories/orbits/specific-mechanical-energy';
-export * from './categories/orbits/flight-path-angle-from-true-anomaly';
+export * from './categories/orbits/vis-viva-speed';
+export * from './categories/manoeuvres/combine-burns-delta-v';
+export * from './categories/manoeuvres/hohmann-transfer';
+export * from './categories/manoeuvres/oberth-energy-gain';
+export * from './categories/manoeuvres/plane-change-delta-v';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,kCAAkC,CAAC;AAEjD,cAAc,+BAA+B,CAAC;AAG9C,cAAc,kDAAkD,CAAC;AAEjE,cAAc,kDAAkD,CAAC;AAEjE,cAAc,6CAA6C,CAAC;AAG5D,cAAc,kCAAkC,CAAC;AAEjD,cAAc,iDAAiD,CAAC;AAEhE,cAAc,4CAA4C,CAAC;AAE3D,cAAc,oDAAoD,CAAC;AAGnE,cAAc,8CAA8C,CAAC;AAE7D,cAAc,0CAA0C,CAAC;AAEzD,cAAc,oCAAoC,CAAC;AAEnD,cAAc,2CAA2C,CAAC;AAG1D,cAAc,oCAAoC,CAAC;AAEnD,cAAc,oCAAoC,CAAC;AAEnD,cAAc,kCAAkC,CAAC;AAEjD,cAAc,mCAAmC,CAAC;AAElD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,6DAA6D,CAAC;AAE5E,cAAc,gDAAgD,CAAC;AAE/D,cAAc,yDAAyD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,kCAAkC,CAAC;AAEjD,cAAc,+BAA+B,CAAC;AAI9C,cAAc,kDAAkD,CAAC;AAEjE,cAAc,kDAAkD,CAAC;AAEjE,cAAc,6CAA6C,CAAC;AAI5D,cAAc,4CAA4C,CAAC;AAE3D,cAAc,oDAAoD,CAAC;AAEnE,cAAc,iDAAiD,CAAC;AAEhE,cAAc,kCAAkC,CAAC;AAIjD,cAAc,2CAA2C,CAAC;AAE1D,cAAc,oCAAoC,CAAC;AAEnD,cAAc,0CAA0C,CAAC;AAEzD,cAAc,8CAA8C,CAAC;AAI7D,cAAc,oCAAoC,CAAC;AAEnD,cAAc,kCAAkC,CAAC;AAEjD,cAAc,yDAAyD,CAAC;AAExE,cAAc,mCAAmC,CAAC;AAElD,cAAc,6DAA6D,CAAC;AAE5E,cAAc,+CAA+C,CAAC;AAE9D,cAAc,gDAAgD,CAAC;AAE/D,cAAc,oCAAoC,CAAC;AAInD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,0CAA0C,CAAC;AAEzD,cAAc,4CAA4C,CAAC;AAE3D,cAAc,8CAA8C,CAAC"}