@interstellar-tools/equations 1.0.0 → 1.2.0

package/dist/categories/manoeuvres/burn-time.js

@@ -0,0 +1,87 @@
+/**
+ * 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 const burnTime = (m0, dv, F, Isp, g0 = 9.80665) => {
+    for (const [name, v] of [
+        ['m0', m0],
+        ['dv', dv],
+        ['F', F],
+        ['Isp', Isp],
+        ['g0', g0]
+    ]) {
+        if (!Number.isFinite(v))
+            throw new TypeError(`${name} must be a finite number. Received: ${v}`);
+    }
+    if (m0 <= 0)
+        throw new RangeError(`m0 must be > 0. Received: ${m0}`);
+    if (dv < 0)
+        throw new RangeError(`dv must be >= 0. Received: ${dv}`);
+    if (F <= 0)
+        throw new RangeError(`F must be > 0. Received: ${F}`);
+    if (Isp <= 0)
+        throw new RangeError(`Isp must be > 0. Received: ${Isp}`);
+    if (g0 <= 0)
+        throw new RangeError(`g0 must be > 0. Received: ${g0}`);
+    const ve = Isp * g0;
+    // -expm1(-x) = 1 - e^(-x), accurate for small burns
+    return ((m0 * ve) / F) * -Math.expm1(-dv / ve);
+};
+//# sourceMappingURL=burn-time.js.map

package/dist/categories/manoeuvres/burn-time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"burn-time.js","sourceRoot":"","sources":["../../../src/categories/manoeuvres/burn-time.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CACtB,EAAU,EACV,EAAU,EACV,CAAS,EACT,GAAW,EACX,EAAE,GAAG,OAAO,EACJ,EAAE;IACV,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI;QACtB,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,GAAG,EAAE,CAAC,CAAC;QACR,CAAC,KAAK,EAAE,GAAG,CAAC;QACZ,CAAC,IAAI,EAAE,EAAE,CAAC;KACF,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,EAAE,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,6BAA6B,EAAE,EAAE,CAAC,CAAC;IAErE,IAAI,EAAE,GAAG,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,8BAA8B,EAAE,EAAE,CAAC,CAAC;IAErE,IAAI,CAAC,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,4BAA4B,CAAC,EAAE,CAAC,CAAC;IAElE,IAAI,GAAG,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,8BAA8B,GAAG,EAAE,CAAC,CAAC;IAExE,IAAI,EAAE,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,6BAA6B,EAAE,EAAE,CAAC,CAAC;IAErE,MAAM,EAAE,GAAG,GAAG,GAAG,EAAE,CAAC;IAEpB,oDAAoD;IACpD,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;AACjD,CAAC,CAAC"}

package/dist/categories/manoeuvres/gravity-loss.d.ts

@@ -0,0 +1,48 @@
+import type { Radians } from '@interstellar-tools/types';
+/**
+ * Compute the **gravity loss** of a burn from samples of gravity and flight-path angle.
+ *
+ * $$
+ * \Delta v_g = \int_0^{t_b} g \sin\gamma \, dt
+ * $$
+ *
+ * integrated with the trapezoidal rule over equally spaced samples.
+ *
+ * Where:
+ * - $ g $ is the local gravitational acceleration (m/s²)
+ * - $ \gamma $ is the flight-path angle above the local horizontal (rad)
+ * - $ t_b $ is the burn time (s)
+ *
+ * **Units**
+ * - Inputs: `g` in **m/s²**, `gamma` in **radians**, `dt` in **s**.
+ * - Output: $ \Delta v_g $ in **m/s**.
+ *
+ * ::: info Notes
+ *
+ * - Thrust spent holding a rocket up against gravity doesn't speed it up. The loss is largest for a vertical climb ($ \gamma = 90° $) and zero for a horizontal burn ($ \gamma = 0 $).
+ * - The delta-v a rocket must carry is its orbital delta-v plus its gravity, drag and steering losses.
+ * - Pass `g` as one number when it's constant over the burn, or as samples matching `gamma`.
+ *
+ * :::
+ *
+ * @param g - Gravitational acceleration in **m/s²**: one value, or one sample per entry of `gamma` (finite, >= 0).
+ * @param gamma - Flight-path angles $ \gamma $ in **radians**, sampled every `dt` seconds (at least 2 samples, each finite).
+ * @param dt - Time between samples in **s** (finite, > 0).
+ * @returns Gravity loss $ \Delta v_g $ in **m/s**. Negative when the vehicle is mostly descending.
+ * @throws {TypeError} If any input is not a finite number, or `g` and `gamma` have different lengths.
+ * @throws {RangeError} If `gamma` has fewer than 2 samples, `dt <= 0` or any `g < 0`.
+ * @group Manoeuvres
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * // A 10 s vertical climb in constant Earth gravity
+ * const vertical = Array.from({ length: 11 }, () => (Math.PI / 2) as Radians);
+ * gravityLoss(9.80665, vertical, 1); // ≈ 98.07 m/s
+ * ```
+ *
+ * @see https://en.wikipedia.org/wiki/Gravity_drag Gravity drag
+ */
+export declare const gravityLoss: (g: number | readonly number[], gamma: readonly Radians[], dt: number) => number;
+//# sourceMappingURL=gravity-loss.d.ts.map

package/dist/categories/manoeuvres/gravity-loss.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gravity-loss.d.ts","sourceRoot":"","sources":["../../../src/categories/manoeuvres/gravity-loss.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,eAAO,MAAM,WAAW,GACtB,GAAG,MAAM,GAAG,SAAS,MAAM,EAAE,EAC7B,OAAO,SAAS,OAAO,EAAE,EACzB,IAAI,MAAM,KACT,MA2CF,CAAC"}

package/dist/categories/manoeuvres/gravity-loss.js

@@ -0,0 +1,74 @@
+/**
+ * Compute the **gravity loss** of a burn from samples of gravity and flight-path angle.
+ *
+ * $$
+ * \Delta v_g = \int_0^{t_b} g \sin\gamma \, dt
+ * $$
+ *
+ * integrated with the trapezoidal rule over equally spaced samples.
+ *
+ * Where:
+ * - $ g $ is the local gravitational acceleration (m/s²)
+ * - $ \gamma $ is the flight-path angle above the local horizontal (rad)
+ * - $ t_b $ is the burn time (s)
+ *
+ * **Units**
+ * - Inputs: `g` in **m/s²**, `gamma` in **radians**, `dt` in **s**.
+ * - Output: $ \Delta v_g $ in **m/s**.
+ *
+ * ::: info Notes
+ *
+ * - Thrust spent holding a rocket up against gravity doesn't speed it up. The loss is largest for a vertical climb ($ \gamma = 90° $) and zero for a horizontal burn ($ \gamma = 0 $).
+ * - The delta-v a rocket must carry is its orbital delta-v plus its gravity, drag and steering losses.
+ * - Pass `g` as one number when it's constant over the burn, or as samples matching `gamma`.
+ *
+ * :::
+ *
+ * @param g - Gravitational acceleration in **m/s²**: one value, or one sample per entry of `gamma` (finite, >= 0).
+ * @param gamma - Flight-path angles $ \gamma $ in **radians**, sampled every `dt` seconds (at least 2 samples, each finite).
+ * @param dt - Time between samples in **s** (finite, > 0).
+ * @returns Gravity loss $ \Delta v_g $ in **m/s**. Negative when the vehicle is mostly descending.
+ * @throws {TypeError} If any input is not a finite number, or `g` and `gamma` have different lengths.
+ * @throws {RangeError} If `gamma` has fewer than 2 samples, `dt <= 0` or any `g < 0`.
+ * @group Manoeuvres
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * // A 10 s vertical climb in constant Earth gravity
+ * const vertical = Array.from({ length: 11 }, () => (Math.PI / 2) as Radians);
+ * gravityLoss(9.80665, vertical, 1); // ≈ 98.07 m/s
+ * ```
+ *
+ * @see https://en.wikipedia.org/wiki/Gravity_drag Gravity drag
+ */
+export const gravityLoss = (g, gamma, dt) => {
+    if (!Number.isFinite(dt))
+        throw new TypeError(`dt must be a finite number. Received: ${dt}`);
+    if (dt <= 0)
+        throw new RangeError(`dt must be > 0. Received: ${dt}`);
+    if (gamma.length < 2)
+        throw new RangeError(`gamma must have at least 2 samples. Received: ${gamma.length}`);
+    if (typeof g !== 'number' && g.length !== gamma.length)
+        throw new TypeError(`g must be a number or have one sample per gamma. Received: ${g.length} for ${gamma.length}`);
+    const at = (i) => {
+        const gi = typeof g === 'number' ? g : g[i];
+        if (!Number.isFinite(gi))
+            throw new TypeError(`g must be finite. Received: ${gi} at ${i}`);
+        if (gi < 0)
+            throw new RangeError(`g must be >= 0. Received: ${gi} at ${i}`);
+        if (!Number.isFinite(gamma[i]))
+            throw new TypeError(`gamma must be finite. Received: ${gamma[i]} at ${i}`);
+        return gi * Math.sin(gamma[i]);
+    };
+    let loss = 0;
+    let previous = at(0);
+    for (let i = 1; i < gamma.length; i++) {
+        const current = at(i);
+        loss += ((previous + current) / 2) * dt;
+        previous = current;
+    }
+    return loss;
+};
+//# sourceMappingURL=gravity-loss.js.map

package/dist/categories/manoeuvres/gravity-loss.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gravity-loss.js","sourceRoot":"","sources":["../../../src/categories/manoeuvres/gravity-loss.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,CAA6B,EAC7B,KAAyB,EACzB,EAAU,EACF,EAAE;IACV,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,SAAS,CAAC,yCAAyC,EAAE,EAAE,CAAC,CAAC;IAErE,IAAI,EAAE,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,6BAA6B,EAAE,EAAE,CAAC,CAAC;IAErE,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;QAClB,MAAM,IAAI,UAAU,CAClB,iDAAiD,KAAK,CAAC,MAAM,EAAE,CAChE,CAAC;IAEJ,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,MAAM,KAAK,KAAK,CAAC,MAAM;QACpD,MAAM,IAAI,SAAS,CACjB,8DAA8D,CAAC,CAAC,MAAM,QAAQ,KAAK,CAAC,MAAM,EAAE,CAC7F,CAAC;IAEJ,MAAM,EAAE,GAAG,CAAC,CAAS,EAAE,EAAE;QACvB,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAE5C,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;YACtB,MAAM,IAAI,SAAS,CAAC,+BAA+B,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;QAEnE,IAAI,EAAE,GAAG,CAAC;YAAE,MAAM,IAAI,UAAU,CAAC,6BAA6B,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;QAE5E,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YAC5B,MAAM,IAAI,SAAS,CACjB,mCAAmC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,CACtD,CAAC;QAEJ,OAAO,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACjC,CAAC,CAAC;IAEF,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,IAAI,QAAQ,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;IAErB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,OAAO,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QAEtB,IAAI,IAAI,CAAC,CAAC,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC;QACxC,QAAQ,GAAG,OAAO,CAAC;IACrB,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC,CAAC"}

package/dist/categories/manoeuvres/initial-mass-for-delta-v.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Compute the **mass needed at ignition** to give a final mass a delta-v: the rocket equation solved for $ m_0 $.
+ *
+ * $$
+ * m_0 = m_f\, e^{\Delta v/(I_{sp}\, g_0)}
+ * $$
+ *
+ * Where:
+ * - $ m_f $ is the mass left after the burn (kg)
+ * - $ \Delta v $ is the delta-v of the burn (m/s)
+ * - $ I_{sp} $ is the specific impulse (s)
+ * - $ g_0 $ is standard gravity (m/s²)
+ *
+ * **Units**
+ * - Inputs: `mf` in **kg**, `dv` in **m/s**, `Isp` in **s**, `g0` in **m/s²**.
+ * - Output: $ m_0 $ in **kg**.
+ *
+ * ::: info Notes
+ *
+ * - The factor $ e^{\Delta v/(I_{sp} g_0)} $ is the price of the burn: every kilogram left after it costs that many kilograms before it.
+ * - For a sequence of burns, work backwards from the last one: each burn's $ m_0 $ is the previous burn's $ m_f $.
+ * - This is the ideal rocket equation: the result counts propellant, not the tanks and engines that hold and burn it.
+ *
+ * :::
+ *
+ * ::: practice Apollo 11's lunar module, before landing
+ *
+ * **9 905 kg**
+ *
+ * _To land with a 4 888 kg ascent stage, for 2 112.3 m/s at 305 s_
+ *
+ * The real lunar module weighed 15 279 kg at undocking: the rest is the descent stage's own structure, engine and legs.
+ *
+ * ```ts
+ * initialMassForDeltaV(4888, 2112.3, 305); // ≈ 9905 kg
+ * ```
+ *
+ * :::
+ *
+ * @param mf - Mass after the burn $ m_f $ in **kg** (finite, > 0).
+ * @param dv - Delta-v of the burn $ \Delta v $ in **m/s** (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 Mass at ignition $ m_0 $ in **kg**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `mf <= 0`, `dv < 0`, `Isp <= 0` or `g0 <= 0`.
+ * @group Manoeuvres
+ *
+ * @example
+ * ```ts
+ * // 800 kg left after a 1270 m/s burn at Isp = 320 s
+ * const m0 = initialMassForDeltaV(800, 1270, 320);
+ * // m0 ≈ 800 * e^(1270 / 3138.1) ≈ 1200 kg
+ * ```
+ *
+ * @see {@link rocketDeltaVFromIsp}
+ * @see https://en.wikipedia.org/wiki/Tsiolkovsky_rocket_equation Tsiolkovsky rocket equation
+ */
+export declare const initialMassForDeltaV: (mf: number, dv: number, Isp: number, g0?: number) => number;
+//# sourceMappingURL=initial-mass-for-delta-v.d.ts.map

package/dist/categories/manoeuvres/initial-mass-for-delta-v.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initial-mass-for-delta-v.d.ts","sourceRoot":"","sources":["../../../src/categories/manoeuvres/initial-mass-for-delta-v.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,eAAO,MAAM,oBAAoB,GAC/B,IAAI,MAAM,EACV,IAAI,MAAM,EACV,KAAK,MAAM,EACX,WAAY,KACX,MAoBF,CAAC"}

package/dist/categories/manoeuvres/initial-mass-for-delta-v.js

@@ -0,0 +1,79 @@
+/**
+ * Compute the **mass needed at ignition** to give a final mass a delta-v: the rocket equation solved for $ m_0 $.
+ *
+ * $$
+ * m_0 = m_f\, e^{\Delta v/(I_{sp}\, g_0)}
+ * $$
+ *
+ * Where:
+ * - $ m_f $ is the mass left after the burn (kg)
+ * - $ \Delta v $ is the delta-v of the burn (m/s)
+ * - $ I_{sp} $ is the specific impulse (s)
+ * - $ g_0 $ is standard gravity (m/s²)
+ *
+ * **Units**
+ * - Inputs: `mf` in **kg**, `dv` in **m/s**, `Isp` in **s**, `g0` in **m/s²**.
+ * - Output: $ m_0 $ in **kg**.
+ *
+ * ::: info Notes
+ *
+ * - The factor $ e^{\Delta v/(I_{sp} g_0)} $ is the price of the burn: every kilogram left after it costs that many kilograms before it.
+ * - For a sequence of burns, work backwards from the last one: each burn's $ m_0 $ is the previous burn's $ m_f $.
+ * - This is the ideal rocket equation: the result counts propellant, not the tanks and engines that hold and burn it.
+ *
+ * :::
+ *
+ * ::: practice Apollo 11's lunar module, before landing
+ *
+ * **9 905 kg**
+ *
+ * _To land with a 4 888 kg ascent stage, for 2 112.3 m/s at 305 s_
+ *
+ * The real lunar module weighed 15 279 kg at undocking: the rest is the descent stage's own structure, engine and legs.
+ *
+ * ```ts
+ * initialMassForDeltaV(4888, 2112.3, 305); // ≈ 9905 kg
+ * ```
+ *
+ * :::
+ *
+ * @param mf - Mass after the burn $ m_f $ in **kg** (finite, > 0).
+ * @param dv - Delta-v of the burn $ \Delta v $ in **m/s** (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 Mass at ignition $ m_0 $ in **kg**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `mf <= 0`, `dv < 0`, `Isp <= 0` or `g0 <= 0`.
+ * @group Manoeuvres
+ *
+ * @example
+ * ```ts
+ * // 800 kg left after a 1270 m/s burn at Isp = 320 s
+ * const m0 = initialMassForDeltaV(800, 1270, 320);
+ * // m0 ≈ 800 * e^(1270 / 3138.1) ≈ 1200 kg
+ * ```
+ *
+ * @see {@link rocketDeltaVFromIsp}
+ * @see https://en.wikipedia.org/wiki/Tsiolkovsky_rocket_equation Tsiolkovsky rocket equation
+ */
+export const initialMassForDeltaV = (mf, dv, Isp, g0 = 9.80665) => {
+    for (const [name, v] of [
+        ['mf', mf],
+        ['dv', dv],
+        ['Isp', Isp],
+        ['g0', g0]
+    ]) {
+        if (!Number.isFinite(v))
+            throw new TypeError(`${name} must be a finite number. Received: ${v}`);
+    }
+    if (mf <= 0)
+        throw new RangeError(`mf must be > 0. Received: ${mf}`);
+    if (dv < 0)
+        throw new RangeError(`dv must be >= 0. Received: ${dv}`);
+    if (Isp <= 0)
+        throw new RangeError(`Isp must be > 0. Received: ${Isp}`);
+    if (g0 <= 0)
+        throw new RangeError(`g0 must be > 0. Received: ${g0}`);
+    return mf * Math.exp(dv / (Isp * g0));
+};
+//# sourceMappingURL=initial-mass-for-delta-v.js.map

package/dist/categories/manoeuvres/initial-mass-for-delta-v.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initial-mass-for-delta-v.js","sourceRoot":"","sources":["../../../src/categories/manoeuvres/initial-mass-for-delta-v.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,EAAU,EACV,EAAU,EACV,GAAW,EACX,EAAE,GAAG,OAAO,EACJ,EAAE;IACV,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI;QACtB,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,KAAK,EAAE,GAAG,CAAC;QACZ,CAAC,IAAI,EAAE,EAAE,CAAC;KACF,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,EAAE,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,6BAA6B,EAAE,EAAE,CAAC,CAAC;IAErE,IAAI,EAAE,GAAG,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,8BAA8B,EAAE,EAAE,CAAC,CAAC;IAErE,IAAI,GAAG,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,8BAA8B,GAAG,EAAE,CAAC,CAAC;IAExE,IAAI,EAAE,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,6BAA6B,EAAE,EAAE,CAAC,CAAC;IAErE,OAAO,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC;AACxC,CAAC,CAAC"}

package/dist/categories/manoeuvres/mass-flow-rate.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Compute the **mass flow rate** of a rocket engine from its thrust and specific impulse.
+ *
+ * $$
+ * \dot m = \frac{F}{I_{sp}\, g_0}
+ * $$
+ *
+ * Where:
+ * - $ F $ is the thrust (N)
+ * - $ I_{sp} $ is the specific impulse (s)
+ * - $ g_0 $ is standard gravity (m/s²)
+ *
+ * **Units**
+ * - Inputs: `F` in **N**, `Isp` in **s**, `g0` in **m/s²**.
+ * - Output: $ \dot m $ in **kg/s**.
+ *
+ * ::: info Notes
+ *
+ * - $ I_{sp}\, g_0 $ is the effective exhaust velocity $ v_e $, so this is $ F = \dot m\, v_e $ solved for $ \dot m $.
+ * - `g0` defaults to **9.80665 m/s²** (standard gravity). It converts the units of $ I_{sp} $; it is not the local gravity.
+ *
+ * :::
+ *
+ * ::: practice Apollo 11's lunar module, leaving the Moon
+ *
+ * **5.09 kg/s**
+ *
+ * _Ascent engine, 15 409 N at 309 s_
+ *
+ * The ascent stage burned about 5 kg of propellant a second for its 7-minute climb to lunar orbit.
+ *
+ * ```ts
+ * massFlowRate(15_409, 309); // ≈ 5.085 kg/s
+ * ```
+ *
+ * :::
+ *
+ * @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 Mass flow rate $ \dot m $ in **kg/s**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `F <= 0`, `Isp <= 0` or `g0 <= 0`.
+ * @group Manoeuvres
+ *
+ * @example
+ * ```ts
+ * // A 1 kN thruster with Isp = 300 s
+ * const mDot = massFlowRate(1000, 300);
+ * // mDot ≈ 1000 / (300 * 9.80665) ≈ 0.340 kg/s
+ * ```
+ *
+ * @see {@link burnTime}
+ * @see {@link rocketThrust}
+ */
+export declare const massFlowRate: (F: number, Isp: number, g0?: number) => number;
+//# sourceMappingURL=mass-flow-rate.d.ts.map

package/dist/categories/manoeuvres/mass-flow-rate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mass-flow-rate.d.ts","sourceRoot":"","sources":["../../../src/categories/manoeuvres/mass-flow-rate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,eAAO,MAAM,YAAY,GAAI,GAAG,MAAM,EAAE,KAAK,MAAM,EAAE,WAAY,KAAG,MAiBnE,CAAC"}

package/dist/categories/manoeuvres/mass-flow-rate.js

@@ -0,0 +1,73 @@
+/**
+ * Compute the **mass flow rate** of a rocket engine from its thrust and specific impulse.
+ *
+ * $$
+ * \dot m = \frac{F}{I_{sp}\, g_0}
+ * $$
+ *
+ * Where:
+ * - $ F $ is the thrust (N)
+ * - $ I_{sp} $ is the specific impulse (s)
+ * - $ g_0 $ is standard gravity (m/s²)
+ *
+ * **Units**
+ * - Inputs: `F` in **N**, `Isp` in **s**, `g0` in **m/s²**.
+ * - Output: $ \dot m $ in **kg/s**.
+ *
+ * ::: info Notes
+ *
+ * - $ I_{sp}\, g_0 $ is the effective exhaust velocity $ v_e $, so this is $ F = \dot m\, v_e $ solved for $ \dot m $.
+ * - `g0` defaults to **9.80665 m/s²** (standard gravity). It converts the units of $ I_{sp} $; it is not the local gravity.
+ *
+ * :::
+ *
+ * ::: practice Apollo 11's lunar module, leaving the Moon
+ *
+ * **5.09 kg/s**
+ *
+ * _Ascent engine, 15 409 N at 309 s_
+ *
+ * The ascent stage burned about 5 kg of propellant a second for its 7-minute climb to lunar orbit.
+ *
+ * ```ts
+ * massFlowRate(15_409, 309); // ≈ 5.085 kg/s
+ * ```
+ *
+ * :::
+ *
+ * @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 Mass flow rate $ \dot m $ in **kg/s**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `F <= 0`, `Isp <= 0` or `g0 <= 0`.
+ * @group Manoeuvres
+ *
+ * @example
+ * ```ts
+ * // A 1 kN thruster with Isp = 300 s
+ * const mDot = massFlowRate(1000, 300);
+ * // mDot ≈ 1000 / (300 * 9.80665) ≈ 0.340 kg/s
+ * ```
+ *
+ * @see {@link burnTime}
+ * @see {@link rocketThrust}
+ */
+export const massFlowRate = (F, Isp, g0 = 9.80665) => {
+    for (const [name, v] of [
+        ['F', F],
+        ['Isp', Isp],
+        ['g0', g0]
+    ]) {
+        if (!Number.isFinite(v))
+            throw new TypeError(`${name} must be a finite number. Received: ${v}`);
+    }
+    if (F <= 0)
+        throw new RangeError(`F must be > 0. Received: ${F}`);
+    if (Isp <= 0)
+        throw new RangeError(`Isp must be > 0. Received: ${Isp}`);
+    if (g0 <= 0)
+        throw new RangeError(`g0 must be > 0. Received: ${g0}`);
+    return F / (Isp * g0);
+};
+//# sourceMappingURL=mass-flow-rate.js.map

package/dist/categories/manoeuvres/mass-flow-rate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mass-flow-rate.js","sourceRoot":"","sources":["../../../src/categories/manoeuvres/mass-flow-rate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAS,EAAE,GAAW,EAAE,EAAE,GAAG,OAAO,EAAU,EAAE;IAC3E,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI;QACtB,CAAC,GAAG,EAAE,CAAC,CAAC;QACR,CAAC,KAAK,EAAE,GAAG,CAAC;QACZ,CAAC,IAAI,EAAE,EAAE,CAAC;KACF,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,IAAI,GAAG,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,8BAA8B,GAAG,EAAE,CAAC,CAAC;IAExE,IAAI,EAAE,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,6BAA6B,EAAE,EAAE,CAAC,CAAC;IAErE,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC;AACxB,CAAC,CAAC"}

package/dist/categories/manoeuvres/rocket-thrust.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Compute the **thrust** of a rocket engine from its exhaust, including the pressure term.
+ *
+ * $$
+ * F = \dot m\, v_e + (p_e - p_a)\, A_e
+ * $$
+ *
+ * Where:
+ * - $ \dot m $ is the mass flow rate (kg/s)
+ * - $ v_e $ is the exhaust velocity at the nozzle exit (m/s)
+ * - $ p_e $ is the pressure at the nozzle exit (Pa)
+ * - $ p_a $ is the ambient pressure (Pa), 0 in vacuum
+ * - $ A_e $ is the nozzle exit area (m²)
+ *
+ * **Units**
+ * - Inputs: `mDot` in **kg/s**, `ve` in **m/s**, `pe` and `pa` in **Pa**, `Ae` in **m²**.
+ * - Output: $ F $ in **N**.
+ *
+ * ::: info Notes
+ *
+ * - The same engine gives more thrust in vacuum than at sea level: $ p_a $ pushes back on the nozzle exit.
+ * - A nozzle with $ p_e < p_a $ is over-expanded, and the pressure term reduces the thrust.
+ * - With $ p_e = p_a $ the thrust is $ \dot m\, v_e $, and $ v_e $ equals $ I_{sp}\, g_0 $.
+ *
+ * :::
+ *
+ * @param mDot - Mass flow rate $ \dot m $ in **kg/s** (finite, >= 0).
+ * @param ve - Exhaust velocity $ v_e $ in **m/s** (finite, >= 0).
+ * @param pe - Nozzle exit pressure $ p_e $ in **Pa** (finite, >= 0).
+ * @param pa - Ambient pressure $ p_a $ in **Pa** (finite, >= 0).
+ * @param Ae - Nozzle exit area $ A_e $ in **m²** (finite, >= 0).
+ * @returns Thrust $ F $ in **N**. Can be negative for a badly over-expanded nozzle with little flow.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If any input is negative.
+ * @group Manoeuvres
+ *
+ * @example
+ * ```ts
+ * // 250 kg/s at 3000 m/s, exit at 70 kPa through a 1.2 m² nozzle
+ * const vacuum = rocketThrust(250, 3000, 70_000, 0, 1.2); // 834 000 N
+ * const seaLevel = rocketThrust(250, 3000, 70_000, 101_325, 1.2); // ≈ 712 410 N
+ * ```
+ *
+ * @see {@link massFlowRate}
+ * @see https://en.wikipedia.org/wiki/Rocket_engine_nozzle Rocket engine nozzle (thrust equation)
+ */
+export declare const rocketThrust: (mDot: number, ve: number, pe: number, pa: number, Ae: number) => number;
+//# sourceMappingURL=rocket-thrust.d.ts.map

package/dist/categories/manoeuvres/rocket-thrust.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rocket-thrust.d.ts","sourceRoot":"","sources":["../../../src/categories/manoeuvres/rocket-thrust.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,YAAY,GACvB,MAAM,MAAM,EACZ,IAAI,MAAM,EACV,IAAI,MAAM,EACV,IAAI,MAAM,EACV,IAAI,MAAM,KACT,MAeF,CAAC"}

package/dist/categories/manoeuvres/rocket-thrust.js

@@ -0,0 +1,62 @@
+/**
+ * Compute the **thrust** of a rocket engine from its exhaust, including the pressure term.
+ *
+ * $$
+ * F = \dot m\, v_e + (p_e - p_a)\, A_e
+ * $$
+ *
+ * Where:
+ * - $ \dot m $ is the mass flow rate (kg/s)
+ * - $ v_e $ is the exhaust velocity at the nozzle exit (m/s)
+ * - $ p_e $ is the pressure at the nozzle exit (Pa)
+ * - $ p_a $ is the ambient pressure (Pa), 0 in vacuum
+ * - $ A_e $ is the nozzle exit area (m²)
+ *
+ * **Units**
+ * - Inputs: `mDot` in **kg/s**, `ve` in **m/s**, `pe` and `pa` in **Pa**, `Ae` in **m²**.
+ * - Output: $ F $ in **N**.
+ *
+ * ::: info Notes
+ *
+ * - The same engine gives more thrust in vacuum than at sea level: $ p_a $ pushes back on the nozzle exit.
+ * - A nozzle with $ p_e < p_a $ is over-expanded, and the pressure term reduces the thrust.
+ * - With $ p_e = p_a $ the thrust is $ \dot m\, v_e $, and $ v_e $ equals $ I_{sp}\, g_0 $.
+ *
+ * :::
+ *
+ * @param mDot - Mass flow rate $ \dot m $ in **kg/s** (finite, >= 0).
+ * @param ve - Exhaust velocity $ v_e $ in **m/s** (finite, >= 0).
+ * @param pe - Nozzle exit pressure $ p_e $ in **Pa** (finite, >= 0).
+ * @param pa - Ambient pressure $ p_a $ in **Pa** (finite, >= 0).
+ * @param Ae - Nozzle exit area $ A_e $ in **m²** (finite, >= 0).
+ * @returns Thrust $ F $ in **N**. Can be negative for a badly over-expanded nozzle with little flow.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If any input is negative.
+ * @group Manoeuvres
+ *
+ * @example
+ * ```ts
+ * // 250 kg/s at 3000 m/s, exit at 70 kPa through a 1.2 m² nozzle
+ * const vacuum = rocketThrust(250, 3000, 70_000, 0, 1.2); // 834 000 N
+ * const seaLevel = rocketThrust(250, 3000, 70_000, 101_325, 1.2); // ≈ 712 410 N
+ * ```
+ *
+ * @see {@link massFlowRate}
+ * @see https://en.wikipedia.org/wiki/Rocket_engine_nozzle Rocket engine nozzle (thrust equation)
+ */
+export const rocketThrust = (mDot, ve, pe, pa, Ae) => {
+    for (const [name, v] of [
+        ['mDot', mDot],
+        ['ve', ve],
+        ['pe', pe],
+        ['pa', pa],
+        ['Ae', Ae]
+    ]) {
+        if (!Number.isFinite(v))
+            throw new TypeError(`${name} must be a finite number. Received: ${v}`);
+        if (v < 0)
+            throw new RangeError(`${name} must be >= 0. Received: ${v}`);
+    }
+    return mDot * ve + (pe - pa) * Ae;
+};
+//# sourceMappingURL=rocket-thrust.js.map

package/dist/categories/manoeuvres/rocket-thrust.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rocket-thrust.js","sourceRoot":"","sources":["../../../src/categories/manoeuvres/rocket-thrust.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAC1B,IAAY,EACZ,EAAU,EACV,EAAU,EACV,EAAU,EACV,EAAU,EACF,EAAE;IACV,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI;QACtB,CAAC,MAAM,EAAE,IAAI,CAAC;QACd,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,IAAI,EAAE,EAAE,CAAC;QACV,CAAC,IAAI,EAAE,EAAE,CAAC;KACF,EAAE,CAAC;QACX,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;YACrB,MAAM,IAAI,SAAS,CAAC,GAAG,IAAI,uCAAuC,CAAC,EAAE,CAAC,CAAC;QAEzE,IAAI,CAAC,GAAG,CAAC;YAAE,MAAM,IAAI,UAAU,CAAC,GAAG,IAAI,4BAA4B,CAAC,EAAE,CAAC,CAAC;IAC1E,CAAC;IAED,OAAO,IAAI,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC;AACpC,CAAC,CAAC"}