@interstellar-tools/equations 0.64.2 → 1.1.0

package/dist/categories/orbits/launch-azimuth-for-inclination.js

@@ -0,0 +1,87 @@
+import { norm2pi } from '../helpers/misc.js';
+/**
+ * Compute the **inertial launch azimuths** that reach an inclination from a latitude.
+ *
+ * $$
+ * \sin\beta = \frac{\cos i}{\cos\varphi}
+ * $$
+ *
+ * Where:
+ * - $ \beta $ is the inertial azimuth, clockwise from north (rad)
+ * - $ i $ is the target inclination (rad)
+ * - $ \varphi $ is the geocentric launch latitude (rad)
+ *
+ * Two azimuths reach every reachable inclination: one heading north ($ \beta $) and one heading south ($ \pi - \beta $).
+ *
+ * **Units**
+ * - Inputs: `lat` and `i` in **radians**.
+ * - Output: both azimuths in **radians**, in [0, 2π).
+ *
+ * ::: info Notes
+ *
+ * - `lat` is the **geocentric** latitude. Published latitudes are usually geodetic, which on Earth differ by up to 0.19°, and the inclination by about as much. Convert first (see [#186](https://github.com/phun-ky/interstellar-tools/issues/186)).
+ * - A site can only reach inclinations between $ |\varphi| $ and $ \pi - |\varphi| $ directly. Anything else needs a plane change, or a dogleg during ascent.
+ * - The azimuths are inertial. Over the ground, the rocket flies a slightly different heading; see {@link rotatingLaunchAzimuth}.
+ * - At $ i = |\varphi| $ the two solutions meet, due east (or due west for retrograde orbits).
+ *
+ * :::
+ *
+ * ::: practice To the ISS from Cape Canaveral
+ *
+ * **44.9°**
+ *
+ * _Inertial azimuth from Pad 39A, 28.447° N geocentric, to an orbit inclined 51.64°_
+ *
+ * Over the ground the rocket flies 42.7°, because the pad is already moving east at 409 m/s.
+ *
+ * ```ts
+ * launchAzimuthForInclination(toRad(28.447), toRad(51.64)).northbound; // ≈ 44.9°
+ * ```
+ *
+ * :::
+ *
+ * @param lat - Geocentric launch latitude $ \varphi $ in **radians** (finite, in (-π/2, π/2)).
+ * @param i - Target inclination $ i $ in **radians** (finite, in [0, π]).
+ * @returns The northbound and southbound inertial azimuths, in **radians**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `lat` is not in (-π/2, π/2), `i` is not in [0, π], or `i` can't be reached from `lat` (`i < |lat|` or `i > π - |lat|`).
+ * @group Orbits
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * const toRad = (deg: number) => ((deg * Math.PI) / 180) as Radians;
+ *
+ * // A sun-synchronous orbit (97.8°) from Vandenberg (34.7° N)
+ * const { southbound } = launchAzimuthForInclination(toRad(34.7), toRad(97.8));
+ * // southbound ≈ 189.5°: south, slightly west
+ * ```
+ *
+ * @see {@link inclinationFromLaunchAzimuth}
+ * @see https://en.wikipedia.org/wiki/Launch_azimuth Launch azimuth
+ */
+export const launchAzimuthForInclination = (lat, i) => {
+    for (const [name, v] of [
+        ['lat', lat],
+        ['i', i]
+    ]) {
+        if (!Number.isFinite(v))
+            throw new TypeError(`${name} must be a finite number. Received: ${v}`);
+    }
+    if (Math.abs(lat) >= Math.PI / 2)
+        throw new RangeError(`lat must be in (-π/2, π/2). Received: ${lat}`);
+    if (i < 0 || i > Math.PI)
+        throw new RangeError(`i must be in [0, π]. Received: ${i}`);
+    const sinBeta = Math.cos(i) / Math.cos(lat);
+    // Allow rounding at the edge, where i = |lat| exactly
+    const tolerance = 1e-12;
+    if (Math.abs(sinBeta) > 1 + tolerance)
+        throw new RangeError(`i can't be reached from lat: it must be in [|lat|, π - |lat|]. Received: i=${i}, lat=${lat}`);
+    const beta = Math.asin(Math.min(1, Math.max(-1, sinBeta)));
+    return {
+        northbound: norm2pi(beta),
+        southbound: norm2pi(Math.PI - beta)
+    };
+};
+//# sourceMappingURL=launch-azimuth-for-inclination.js.map

package/dist/categories/orbits/launch-azimuth-for-inclination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"launch-azimuth-for-inclination.js","sourceRoot":"","sources":["../../../src/categories/orbits/launch-azimuth-for-inclination.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAS7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CACzC,GAAY,EACZ,CAAU,EACe,EAAE;IAC3B,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI;QACtB,CAAC,KAAK,EAAE,GAAG,CAAC;QACZ,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,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,EAAE,GAAG,CAAC;QAC9B,MAAM,IAAI,UAAU,CAAC,yCAAyC,GAAG,EAAE,CAAC,CAAC;IAEvE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,EAAE;QACtB,MAAM,IAAI,UAAU,CAAC,kCAAkC,CAAC,EAAE,CAAC,CAAC;IAE9D,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC5C,sDAAsD;IACtD,MAAM,SAAS,GAAG,KAAK,CAAC;IAExB,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,SAAS;QACnC,MAAM,IAAI,UAAU,CAClB,8EAA8E,CAAC,SAAS,GAAG,EAAE,CAC9F,CAAC;IAEJ,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAE3D,OAAO;QACL,UAAU,EAAE,OAAO,CAAC,IAAI,CAAY;QACpC,UAAU,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,CAAY;KAC/C,CAAC;AACJ,CAAC,CAAC"}

package/dist/categories/orbits/rotating-launch-azimuth.d.ts

@@ -0,0 +1,49 @@
+import type { Radians } from '@interstellar-tools/types';
+/**
+ * Compute the **azimuth over the ground** for an inertial launch azimuth, on a rotating body.
+ *
+ * $$
+ * \tan\beta_\text{rot} = \frac{v \sin\beta - v_\text{rot}}{v \cos\beta}
+ * $$
+ *
+ * Where:
+ * - $ \beta $ is the inertial azimuth, clockwise from north (rad)
+ * - $ v $ is the inertial speed to reach, e.g. the orbital speed at insertion (m/s)
+ * - $ v_\text{rot} $ is the pad's eastward speed from the body's rotation (m/s)
+ *
+ * **Units**
+ * - Inputs: `azimuth` in **radians**, `v` and `vRot` in **m/s**.
+ * - Output: $ \beta_\text{rot} $ in **radians**, in [0, 2π).
+ *
+ * ::: info Notes
+ *
+ * - The pad is already moving east, so the rocket only has to add the difference: it steers a little further from east than the inertial azimuth.
+ * - Get $ v_\text{rot} $ from {@link surfaceRotationSpeed} and $ \beta $ from {@link launchAzimuthForInclination}.
+ * - Uses a flat, local approximation: good for the azimuth at launch, not for the whole ascent.
+ *
+ * :::
+ *
+ * @param azimuth - Inertial azimuth $ \beta $ in **radians**, clockwise from north (finite).
+ * @param v - Inertial speed $ v $ in **m/s** (finite, > 0).
+ * @param vRot - Eastward surface speed $ v_\text{rot} $ in **m/s** (finite).
+ * @returns Azimuth over the ground $ \beta_\text{rot} $ in **radians**, in [0, 2π).
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `v <= 0`, or the speed over the ground is zero (the target velocity equals the pad's).
+ * @group Orbits
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * const toRad = (deg: number) => ((deg * Math.PI) / 180) as Radians;
+ *
+ * // Due north inertially at 7.8 km/s, from a pad moving east at 409 m/s
+ * const beta = rotatingLaunchAzimuth(toRad(0), 7800, 409);
+ * // beta ≈ 357.0°: aim slightly west of north to cancel the pad's eastward speed
+ * ```
+ *
+ * @see {@link launchAzimuthForInclination}
+ * @see {@link surfaceRotationSpeed}
+ */
+export declare const rotatingLaunchAzimuth: (azimuth: Radians, v: number, vRot: number) => Radians;
+//# sourceMappingURL=rotating-launch-azimuth.d.ts.map

package/dist/categories/orbits/rotating-launch-azimuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotating-launch-azimuth.d.ts","sourceRoot":"","sources":["../../../src/categories/orbits/rotating-launch-azimuth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAIzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,qBAAqB,GAChC,SAAS,OAAO,EAChB,GAAG,MAAM,EACT,MAAM,MAAM,KACX,OAqBF,CAAC"}

package/dist/categories/orbits/rotating-launch-azimuth.js

@@ -0,0 +1,65 @@
+import { norm2pi } from '../helpers/misc.js';
+/**
+ * Compute the **azimuth over the ground** for an inertial launch azimuth, on a rotating body.
+ *
+ * $$
+ * \tan\beta_\text{rot} = \frac{v \sin\beta - v_\text{rot}}{v \cos\beta}
+ * $$
+ *
+ * Where:
+ * - $ \beta $ is the inertial azimuth, clockwise from north (rad)
+ * - $ v $ is the inertial speed to reach, e.g. the orbital speed at insertion (m/s)
+ * - $ v_\text{rot} $ is the pad's eastward speed from the body's rotation (m/s)
+ *
+ * **Units**
+ * - Inputs: `azimuth` in **radians**, `v` and `vRot` in **m/s**.
+ * - Output: $ \beta_\text{rot} $ in **radians**, in [0, 2π).
+ *
+ * ::: info Notes
+ *
+ * - The pad is already moving east, so the rocket only has to add the difference: it steers a little further from east than the inertial azimuth.
+ * - Get $ v_\text{rot} $ from {@link surfaceRotationSpeed} and $ \beta $ from {@link launchAzimuthForInclination}.
+ * - Uses a flat, local approximation: good for the azimuth at launch, not for the whole ascent.
+ *
+ * :::
+ *
+ * @param azimuth - Inertial azimuth $ \beta $ in **radians**, clockwise from north (finite).
+ * @param v - Inertial speed $ v $ in **m/s** (finite, > 0).
+ * @param vRot - Eastward surface speed $ v_\text{rot} $ in **m/s** (finite).
+ * @returns Azimuth over the ground $ \beta_\text{rot} $ in **radians**, in [0, 2π).
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `v <= 0`, or the speed over the ground is zero (the target velocity equals the pad's).
+ * @group Orbits
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * const toRad = (deg: number) => ((deg * Math.PI) / 180) as Radians;
+ *
+ * // Due north inertially at 7.8 km/s, from a pad moving east at 409 m/s
+ * const beta = rotatingLaunchAzimuth(toRad(0), 7800, 409);
+ * // beta ≈ 357.0°: aim slightly west of north to cancel the pad's eastward speed
+ * ```
+ *
+ * @see {@link launchAzimuthForInclination}
+ * @see {@link surfaceRotationSpeed}
+ */
+export const rotatingLaunchAzimuth = (azimuth, v, vRot) => {
+    for (const [name, x] of [
+        ['azimuth', azimuth],
+        ['v', v],
+        ['vRot', vRot]
+    ]) {
+        if (!Number.isFinite(x))
+            throw new TypeError(`${name} must be a finite number. Received: ${x}`);
+    }
+    if (v <= 0)
+        throw new RangeError(`v must be > 0. Received: ${v}`);
+    const east = v * Math.sin(azimuth) - vRot;
+    const north = v * Math.cos(azimuth);
+    if (Math.hypot(east, north) <= 1e-12 * v)
+        throw new RangeError('The speed over the ground is zero, so the azimuth is undefined.');
+    return norm2pi(Math.atan2(east, north));
+};
+//# sourceMappingURL=rotating-launch-azimuth.js.map

package/dist/categories/orbits/rotating-launch-azimuth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotating-launch-azimuth.js","sourceRoot":"","sources":["../../../src/categories/orbits/rotating-launch-azimuth.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CACnC,OAAgB,EAChB,CAAS,EACT,IAAY,EACH,EAAE;IACX,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI;QACtB,CAAC,SAAS,EAAE,OAAO,CAAC;QACpB,CAAC,GAAG,EAAE,CAAC,CAAC;QACR,CAAC,MAAM,EAAE,IAAI,CAAC;KACN,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,IAAI,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;IAC1C,MAAM,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAEpC,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC;QACtC,MAAM,IAAI,UAAU,CAClB,iEAAiE,CAClE,CAAC;IAEJ,OAAO,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,CAAY,CAAC;AACrD,CAAC,CAAC"}

package/dist/categories/orbits/state-to-elements.d.ts

@@ -0,0 +1,82 @@
+import type { ClassicalElementsInterface, Vector3DTupleType } from '@interstellar-tools/types';
+/**
+ * Convert a **state vector** (position and velocity) to the six **classical orbital elements**.
+ *
+ * $$
+ * \mathbf h = \mathbf r \times \mathbf v, \quad
+ * \mathbf e = \frac{\mathbf v \times \mathbf h}{\mu} - \frac{\mathbf r}{r}, \quad
+ * \mathbf n = \hat{\mathbf k} \times \mathbf h, \quad
+ * a = -\frac{\mu}{2\varepsilon}, \quad
+ * \varepsilon = \frac{v^2}{2} - \frac{\mu}{r}
+ * $$
+ *
+ * $$
+ * i = \arccos\frac{h_z}{h}, \quad
+ * \Omega = \operatorname{atan2}(n_y, n_x), \quad
+ * \omega = \angle(\mathbf n, \mathbf e), \quad
+ * \nu = \angle(\mathbf e, \mathbf r)
+ * $$
+ *
+ * where each angle $ \angle $ is measured in the direction of motion, about $ \mathbf h $.
+ *
+ * **Units**
+ * - Inputs: `r` in **m**, `v` in **m/s**, `mu` in **m³/s²**.
+ * - Output: `a` in **m**, `e` dimensionless, angles in **radians**.
+ *
+ * ::: info Notes
+ *
+ * - Works for elliptic and hyperbolic orbits. A hyperbolic orbit has a negative `a`, and `nu` in [0, 2π) like the others: the incoming branch is just below 2π.
+ * - Some angles are undefined for special orbits. Below `tolerance`, the function uses these conventions, which {@link elementsToState} reverses:
+ *   - **circular** ($ e \approx 0 $): `argp = 0`, and `nu` is measured from the ascending node (the argument of latitude);
+ *   - **equatorial** ($ i \approx 0 $ or $ \pi $): `raan = 0`, and `argp` is measured from the x axis (the longitude of periapsis);
+ *   - **circular and equatorial**: `raan = argp = 0`, and `nu` is measured from the x axis (the true longitude).
+ * - The frame is whatever inertial frame `r` and `v` are given in, centred on the body with parameter `mu`; the reference plane is its xy plane.
+ *
+ * :::
+ *
+ * ::: practice Apollo 11, leaving for the Moon
+ *
+ * **e = 0.977**
+ *
+ * _From the flown state at trans-lunar injection: 6 712.6 km from Earth's centre, 10 834.3 m/s, 7.367° above the horizontal_
+ *
+ * The AS-506 flight evaluation report gives 0.97696; the inputs here are rounded. An orbit that stretched reaches far beyond the Moon, but the Moon's gravity takes over long before.
+ *
+ * ```ts
+ * const r = 6_712_602; // m
+ * const v = 10_834.3; // m/s
+ * const gamma = toRad(7.367);
+ * stateToElements(
+ *   [r, 0, 0],
+ *   [v * Math.sin(gamma), v * Math.cos(gamma), 0],
+ *   3.986004418e14
+ * ).e; // ≈ 0.97715
+ * ```
+ *
+ * :::
+ *
+ * @param r - Position vector in **m** (finite components, not zero).
+ * @param v - Velocity vector in **m/s** (finite components).
+ * @param mu - Gravitational parameter $ \mu $ in **m³/s²** (finite, > 0).
+ * @param tolerance - Below this, `e` counts as circular and $ \sin i $ as equatorial. Defaults to `1e-10`.
+ * @returns The classical orbital elements.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `mu <= 0`, `tolerance < 0`, `r` is zero, or the motion is straight up or down (no angular momentum).
+ * @group Orbits
+ *
+ * @example
+ * ```ts
+ * // Curtis, Orbital Mechanics for Engineering Students, in km and km/s
+ * const { a, e, i, raan, argp, nu } = stateToElements(
+ *   [-6045e3, -3490e3, 2500e3],
+ *   [-3.457e3, 6.618e3, 2.533e3],
+ *   398_600e9
+ * );
+ * // e ≈ 0.1712, i ≈ 153.2°, raan ≈ 255.3°, argp ≈ 20.07°, nu ≈ 28.45°
+ * ```
+ *
+ * @see {@link elementsToState}
+ * @see https://en.wikipedia.org/wiki/Orbital_elements Orbital elements
+ */
+export declare const stateToElements: (r: Vector3DTupleType, v: Vector3DTupleType, mu: number, tolerance?: number) => ClassicalElementsInterface;
+//# sourceMappingURL=state-to-elements.d.ts.map

package/dist/categories/orbits/state-to-elements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-to-elements.d.ts","sourceRoot":"","sources":["../../../src/categories/orbits/state-to-elements.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,0BAA0B,EAE1B,iBAAiB,EAClB,MAAM,2BAA2B,CAAC;AAInC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AACH,eAAO,MAAM,eAAe,GAC1B,GAAG,iBAAiB,EACpB,GAAG,iBAAiB,EACpB,IAAI,MAAM,EACV,kBAAiB,KAChB,0BA6DF,CAAC"}

package/dist/categories/orbits/state-to-elements.js

@@ -0,0 +1,131 @@
+import { cross, dot, norm, norm2pi, scale, sub } from '../helpers/misc.js';
+/**
+ * Convert a **state vector** (position and velocity) to the six **classical orbital elements**.
+ *
+ * $$
+ * \mathbf h = \mathbf r \times \mathbf v, \quad
+ * \mathbf e = \frac{\mathbf v \times \mathbf h}{\mu} - \frac{\mathbf r}{r}, \quad
+ * \mathbf n = \hat{\mathbf k} \times \mathbf h, \quad
+ * a = -\frac{\mu}{2\varepsilon}, \quad
+ * \varepsilon = \frac{v^2}{2} - \frac{\mu}{r}
+ * $$
+ *
+ * $$
+ * i = \arccos\frac{h_z}{h}, \quad
+ * \Omega = \operatorname{atan2}(n_y, n_x), \quad
+ * \omega = \angle(\mathbf n, \mathbf e), \quad
+ * \nu = \angle(\mathbf e, \mathbf r)
+ * $$
+ *
+ * where each angle $ \angle $ is measured in the direction of motion, about $ \mathbf h $.
+ *
+ * **Units**
+ * - Inputs: `r` in **m**, `v` in **m/s**, `mu` in **m³/s²**.
+ * - Output: `a` in **m**, `e` dimensionless, angles in **radians**.
+ *
+ * ::: info Notes
+ *
+ * - Works for elliptic and hyperbolic orbits. A hyperbolic orbit has a negative `a`, and `nu` in [0, 2π) like the others: the incoming branch is just below 2π.
+ * - Some angles are undefined for special orbits. Below `tolerance`, the function uses these conventions, which {@link elementsToState} reverses:
+ *   - **circular** ($ e \approx 0 $): `argp = 0`, and `nu` is measured from the ascending node (the argument of latitude);
+ *   - **equatorial** ($ i \approx 0 $ or $ \pi $): `raan = 0`, and `argp` is measured from the x axis (the longitude of periapsis);
+ *   - **circular and equatorial**: `raan = argp = 0`, and `nu` is measured from the x axis (the true longitude).
+ * - The frame is whatever inertial frame `r` and `v` are given in, centred on the body with parameter `mu`; the reference plane is its xy plane.
+ *
+ * :::
+ *
+ * ::: practice Apollo 11, leaving for the Moon
+ *
+ * **e = 0.977**
+ *
+ * _From the flown state at trans-lunar injection: 6 712.6 km from Earth's centre, 10 834.3 m/s, 7.367° above the horizontal_
+ *
+ * The AS-506 flight evaluation report gives 0.97696; the inputs here are rounded. An orbit that stretched reaches far beyond the Moon, but the Moon's gravity takes over long before.
+ *
+ * ```ts
+ * const r = 6_712_602; // m
+ * const v = 10_834.3; // m/s
+ * const gamma = toRad(7.367);
+ * stateToElements(
+ *   [r, 0, 0],
+ *   [v * Math.sin(gamma), v * Math.cos(gamma), 0],
+ *   3.986004418e14
+ * ).e; // ≈ 0.97715
+ * ```
+ *
+ * :::
+ *
+ * @param r - Position vector in **m** (finite components, not zero).
+ * @param v - Velocity vector in **m/s** (finite components).
+ * @param mu - Gravitational parameter $ \mu $ in **m³/s²** (finite, > 0).
+ * @param tolerance - Below this, `e` counts as circular and $ \sin i $ as equatorial. Defaults to `1e-10`.
+ * @returns The classical orbital elements.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `mu <= 0`, `tolerance < 0`, `r` is zero, or the motion is straight up or down (no angular momentum).
+ * @group Orbits
+ *
+ * @example
+ * ```ts
+ * // Curtis, Orbital Mechanics for Engineering Students, in km and km/s
+ * const { a, e, i, raan, argp, nu } = stateToElements(
+ *   [-6045e3, -3490e3, 2500e3],
+ *   [-3.457e3, 6.618e3, 2.533e3],
+ *   398_600e9
+ * );
+ * // e ≈ 0.1712, i ≈ 153.2°, raan ≈ 255.3°, argp ≈ 20.07°, nu ≈ 28.45°
+ * ```
+ *
+ * @see {@link elementsToState}
+ * @see https://en.wikipedia.org/wiki/Orbital_elements Orbital elements
+ */
+export const stateToElements = (r, v, mu, tolerance = 1e-10) => {
+    for (const [name, vector] of [
+        ['r', r],
+        ['v', v]
+    ]) {
+        for (const x of vector)
+            if (!Number.isFinite(x))
+                throw new TypeError(`${name} must have finite components. Received: ${x}`);
+    }
+    for (const [name, x] of [
+        ['mu', mu],
+        ['tolerance', tolerance]
+    ]) {
+        if (!Number.isFinite(x))
+            throw new TypeError(`${name} must be a finite number. Received: ${x}`);
+    }
+    if (mu <= 0)
+        throw new RangeError(`mu must be > 0. Received: ${mu}`);
+    if (tolerance < 0)
+        throw new RangeError(`tolerance must be >= 0. Received: ${tolerance}`);
+    const rn = norm(r);
+    const vn = norm(v);
+    if (rn === 0)
+        throw new RangeError('r must not be the zero vector.');
+    const h = cross(r, v);
+    const hn = norm(h);
+    if (hn <= 1e-12 * rn * vn || hn === 0)
+        throw new RangeError('The motion is straight up or down (no angular momentum), so the orbit has no plane.');
+    const hHat = scale(h, 1 / hn);
+    const eVec = sub(scale(cross(v, h), 1 / mu), scale(r, 1 / rn));
+    const e = norm(eVec);
+    const energy = (vn * vn) / 2 - mu / rn;
+    const a = -mu / (2 * energy);
+    const i = Math.acos(Math.min(1, Math.max(-1, h[2] / hn)));
+    // The ascending node points along k × h
+    const node = [-h[1], h[0], 0];
+    const equatorial = Math.hypot(h[0], h[1]) <= tolerance * hn;
+    const circular = e <= tolerance;
+    // The angle from u to w, measured in the direction of motion
+    const angle = (u, w) => norm2pi(Math.atan2(dot(cross(u, w), hHat), dot(u, w)));
+    const reference = equatorial ? [1, 0, 0] : node;
+    return {
+        a,
+        e,
+        i: i,
+        raan: (equatorial ? 0 : norm2pi(Math.atan2(node[1], node[0]))),
+        argp: (circular ? 0 : angle(reference, eVec)),
+        nu: (circular ? angle(reference, r) : angle(eVec, r))
+    };
+};
+//# sourceMappingURL=state-to-elements.js.map

package/dist/categories/orbits/state-to-elements.js.map

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

package/dist/categories/orbits/surface-rotation-speed.d.ts

@@ -0,0 +1,61 @@
+import type { Radians } from '@interstellar-tools/types';
+/**
+ * Compute the **eastward speed** of a point on a rotating body's surface, at a latitude.
+ *
+ * $$
+ * v_\text{rot} = \omega\, R \cos\varphi
+ * $$
+ *
+ * Where:
+ * - $ \omega $ is the body's rotation rate (rad/s), sidereal, not solar
+ * - $ R $ is the point's distance from the body's centre (m)
+ * - $ \varphi $ is the geocentric latitude (rad)
+ *
+ * **Units**
+ * - Inputs: `lat` in **radians**, `R` in **m**, `omega` in **rad/s**.
+ * - Output: $ v_\text{rot} $ in **m/s**, positive eastward.
+ *
+ * ::: info Notes
+ *
+ * - A rocket launched eastward gets this speed for free; one launched westward has to cancel it first.
+ * - Earth's sidereal rotation rate is about 7.2921150 × 10⁻⁵ rad/s.
+ * - A body that rotates backwards (Venus, Uranus) has a negative `omega`, and the result is negative: westward.
+ * - $ R\cos\varphi $ is the distance from the rotation axis. On an oblate body, pass the geocentric latitude and the point's distance from the body's centre, not the equatorial radius with a geodetic latitude (see [#186](https://github.com/phun-ky/interstellar-tools/issues/186)).
+ *
+ * :::
+ *
+ * ::: practice Apollo 11, on Pad 39A
+ *
+ * **408.6 m/s**
+ *
+ * _At 28.447° N geocentric, 6 373.3 km from Earth's centre, before the engines light_
+ *
+ * At the equator it's 465.1 m/s, which is one reason Europe launches from Kourou, at 5.2° N (463 m/s).
+ *
+ * ```ts
+ * surfaceRotationSpeed(toRad(28.447), 6_373_266, 7.292115e-5); // ≈ 408.6 m/s
+ * ```
+ *
+ * :::
+ *
+ * @param lat - Geocentric latitude $ \varphi $ in **radians** (finite, in [-π/2, π/2]).
+ * @param R - Distance $ R $ from the body's centre in **m** (finite, > 0).
+ * @param omega - Rotation rate $ \omega $ in **rad/s** (finite).
+ * @returns Eastward surface speed $ v_\text{rot} $ in **m/s**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `lat` is outside [-π/2, π/2] or `R <= 0`.
+ * @group Orbits
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * // Earth's equator
+ * surfaceRotationSpeed(0 as Radians, 6_378_137, 7.292115e-5); // ≈ 465.1 m/s
+ * ```
+ *
+ * @see {@link inclinationFromLaunchAzimuth}
+ * @see {@link rotatingLaunchAzimuth}
+ */
+export declare const surfaceRotationSpeed: (lat: Radians, R: number, omega: number) => number;
+//# sourceMappingURL=surface-rotation-speed.d.ts.map

package/dist/categories/orbits/surface-rotation-speed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-rotation-speed.d.ts","sourceRoot":"","sources":["../../../src/categories/orbits/surface-rotation-speed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,eAAO,MAAM,oBAAoB,GAC/B,KAAK,OAAO,EACZ,GAAG,MAAM,EACT,OAAO,MAAM,KACZ,MAgBF,CAAC"}

package/dist/categories/orbits/surface-rotation-speed.js

@@ -0,0 +1,74 @@
+/**
+ * Compute the **eastward speed** of a point on a rotating body's surface, at a latitude.
+ *
+ * $$
+ * v_\text{rot} = \omega\, R \cos\varphi
+ * $$
+ *
+ * Where:
+ * - $ \omega $ is the body's rotation rate (rad/s), sidereal, not solar
+ * - $ R $ is the point's distance from the body's centre (m)
+ * - $ \varphi $ is the geocentric latitude (rad)
+ *
+ * **Units**
+ * - Inputs: `lat` in **radians**, `R` in **m**, `omega` in **rad/s**.
+ * - Output: $ v_\text{rot} $ in **m/s**, positive eastward.
+ *
+ * ::: info Notes
+ *
+ * - A rocket launched eastward gets this speed for free; one launched westward has to cancel it first.
+ * - Earth's sidereal rotation rate is about 7.2921150 × 10⁻⁵ rad/s.
+ * - A body that rotates backwards (Venus, Uranus) has a negative `omega`, and the result is negative: westward.
+ * - $ R\cos\varphi $ is the distance from the rotation axis. On an oblate body, pass the geocentric latitude and the point's distance from the body's centre, not the equatorial radius with a geodetic latitude (see [#186](https://github.com/phun-ky/interstellar-tools/issues/186)).
+ *
+ * :::
+ *
+ * ::: practice Apollo 11, on Pad 39A
+ *
+ * **408.6 m/s**
+ *
+ * _At 28.447° N geocentric, 6 373.3 km from Earth's centre, before the engines light_
+ *
+ * At the equator it's 465.1 m/s, which is one reason Europe launches from Kourou, at 5.2° N (463 m/s).
+ *
+ * ```ts
+ * surfaceRotationSpeed(toRad(28.447), 6_373_266, 7.292115e-5); // ≈ 408.6 m/s
+ * ```
+ *
+ * :::
+ *
+ * @param lat - Geocentric latitude $ \varphi $ in **radians** (finite, in [-π/2, π/2]).
+ * @param R - Distance $ R $ from the body's centre in **m** (finite, > 0).
+ * @param omega - Rotation rate $ \omega $ in **rad/s** (finite).
+ * @returns Eastward surface speed $ v_\text{rot} $ in **m/s**.
+ * @throws {TypeError} If any input is not a finite number.
+ * @throws {RangeError} If `lat` is outside [-π/2, π/2] or `R <= 0`.
+ * @group Orbits
+ *
+ * @example
+ * ```ts
+ * import type { Radians } from '@interstellar-tools/types';
+ *
+ * // Earth's equator
+ * surfaceRotationSpeed(0 as Radians, 6_378_137, 7.292115e-5); // ≈ 465.1 m/s
+ * ```
+ *
+ * @see {@link inclinationFromLaunchAzimuth}
+ * @see {@link rotatingLaunchAzimuth}
+ */
+export const surfaceRotationSpeed = (lat, R, omega) => {
+    for (const [name, v] of [
+        ['lat', lat],
+        ['R', R],
+        ['omega', omega]
+    ]) {
+        if (!Number.isFinite(v))
+            throw new TypeError(`${name} must be a finite number. Received: ${v}`);
+    }
+    if (Math.abs(lat) > Math.PI / 2)
+        throw new RangeError(`lat must be in [-π/2, π/2]. Received: ${lat}`);
+    if (R <= 0)
+        throw new RangeError(`R must be > 0. Received: ${R}`);
+    return omega * R * Math.cos(lat);
+};
+//# sourceMappingURL=surface-rotation-speed.js.map

package/dist/categories/orbits/surface-rotation-speed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-rotation-speed.js","sourceRoot":"","sources":["../../../src/categories/orbits/surface-rotation-speed.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,GAAY,EACZ,CAAS,EACT,KAAa,EACL,EAAE;IACV,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI;QACtB,CAAC,KAAK,EAAE,GAAG,CAAC;QACZ,CAAC,GAAG,EAAE,CAAC,CAAC;QACR,CAAC,OAAO,EAAE,KAAK,CAAC;KACR,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,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC;QAC7B,MAAM,IAAI,UAAU,CAAC,yCAAyC,GAAG,EAAE,CAAC,CAAC;IAEvE,IAAI,CAAC,IAAI,CAAC;QAAE,MAAM,IAAI,UAAU,CAAC,4BAA4B,CAAC,EAAE,CAAC,CAAC;IAElE,OAAO,KAAK,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACnC,CAAC,CAAC"}

package/dist/index.d.ts

@@ -37,24 +37,36 @@ export * from './categories/orbits/atmospheric-drag-acceleration.js';
 export * from './categories/orbits/characteristic-energy-c3.js';
 export * from './categories/orbits/circular-speed.js';
 export * from './categories/orbits/cw-hill-derivatives.js';
+export * from './categories/orbits/elements-to-state.js';
 export * from './categories/orbits/escape-speed.js';
 export * from './categories/orbits/flight-path-angle-from-true-anomaly.js';
 export * from './categories/orbits/hyperbolic-periapsis-speed.js';
+export * from './categories/orbits/inclination-from-launch-azimuth.js';
 export * from './categories/orbits/j2-argument-of-perigee-rate.js';
 export * from './categories/orbits/j2-nodal-precession-rate.js';
 export * from './categories/orbits/kepler-period.js';
+export * from './categories/orbits/launch-azimuth-for-inclination.js';
 export * from './categories/orbits/mean-motion.js';
 export * from './categories/orbits/peri-apoapsis-radii.js';
+export * from './categories/orbits/rotating-launch-azimuth.js';
 export * from './categories/orbits/specific-angular-momentum-from-elements.js';
 export * from './categories/orbits/specific-angular-momentum.js';
 export * from './categories/orbits/specific-mechanical-energy.js';
 export * from './categories/orbits/sphere-of-influence-radius.js';
+export * from './categories/orbits/state-to-elements.js';
+export * from './categories/orbits/surface-rotation-speed.js';
 export * from './categories/orbits/vis-viva-speed.js';
+export * from './categories/manoeuvres/burn-time.js';
 export * from './categories/manoeuvres/combine-burns-delta-v.js';
 export * from './categories/manoeuvres/gravity-assist-turning-angle.js';
+export * from './categories/manoeuvres/gravity-loss.js';
 export * from './categories/manoeuvres/hohmann-transfer.js';
+export * from './categories/manoeuvres/initial-mass-for-delta-v.js';
+export * from './categories/manoeuvres/mass-flow-rate.js';
 export * from './categories/manoeuvres/oberth-energy-gain.js';
 export * from './categories/manoeuvres/plane-change-delta-v.js';
 export * from './categories/manoeuvres/rocket-delta-v-from-isp.js';
 export * from './categories/manoeuvres/rocket-delta-v-from-ve.js';
+export * from './categories/manoeuvres/rocket-thrust.js';
+export * from './categories/manoeuvres/thrust-to-weight.js';
 //# 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,qCAAqC,CAAC;AAEpD,cAAc,kCAAkC,CAAC;AAIjD,cAAc,8DAA8D,CAAC;AAE7E,cAAc,kEAAkE,CAAC;AAEjF,cAAc,wDAAwD,CAAC;AAEvE,cAAc,8DAA8D,CAAC;AAE7E,cAAc,qDAAqD,CAAC;AAEpE,cAAc,4DAA4D,CAAC;AAI3E,cAAc,wCAAwC,CAAC;AAEvD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,+BAA+B,CAAC;AAE9C,cAAc,kCAAkC,CAAC;AAEjD,cAAc,8BAA8B,CAAC;AAE7C,cAAc,iDAAiD,CAAC;AAEhE,cAAc,iCAAiC,CAAC;AAEhD,cAAc,+BAA+B,CAAC;AAE9C,cAAc,+BAA+B,CAAC;AAE9C,cAAc,qCAAqC,CAAC;AAIpD,cAAc,gDAAgD,CAAC;AAE/D,cAAc,sCAAsC,CAAC;AAErD,cAAc,qDAAqD,CAAC;AAEpE,cAAc,gDAAgD,CAAC;AAI/D,cAAc,+CAA+C,CAAC;AAE9D,cAAc,uDAAuD,CAAC;AAEtE,cAAc,oDAAoD,CAAC;AAEnE,cAAc,qCAAqC,CAAC;AAIpD,cAAc,8CAA8C,CAAC;AAE7D,cAAc,uCAAuC,CAAC;AAEtD,cAAc,6CAA6C,CAAC;AAE5D,cAAc,iDAAiD,CAAC;AAIhE,cAAc,sDAAsD,CAAC;AAErE,cAAc,iDAAiD,CAAC;AAEhE,cAAc,uCAAuC,CAAC;AAEtD,cAAc,4CAA4C,CAAC;AAE3D,cAAc,qCAAqC,CAAC;AAEpD,cAAc,4DAA4D,CAAC;AAE3E,cAAc,mDAAmD,CAAC;AAElE,cAAc,oDAAoD,CAAC;AAEnE,cAAc,iDAAiD,CAAC;AAEhE,cAAc,sCAAsC,CAAC;AAErD,cAAc,oCAAoC,CAAC;AAEnD,cAAc,4CAA4C,CAAC;AAE3D,cAAc,gEAAgE,CAAC;AAE/E,cAAc,kDAAkD,CAAC;AAEjE,cAAc,mDAAmD,CAAC;AAElE,cAAc,mDAAmD,CAAC;AAElE,cAAc,uCAAuC,CAAC;AAItD,cAAc,kDAAkD,CAAC;AAEjE,cAAc,yDAAyD,CAAC;AAExE,cAAc,6CAA6C,CAAC;AAE5D,cAAc,+CAA+C,CAAC;AAE9D,cAAc,iDAAiD,CAAC;AAEhE,cAAc,oDAAoD,CAAC;AAEnE,cAAc,mDAAmD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,qCAAqC,CAAC;AAEpD,cAAc,kCAAkC,CAAC;AAIjD,cAAc,8DAA8D,CAAC;AAE7E,cAAc,kEAAkE,CAAC;AAEjF,cAAc,wDAAwD,CAAC;AAEvE,cAAc,8DAA8D,CAAC;AAE7E,cAAc,qDAAqD,CAAC;AAEpE,cAAc,4DAA4D,CAAC;AAI3E,cAAc,wCAAwC,CAAC;AAEvD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,+BAA+B,CAAC;AAE9C,cAAc,kCAAkC,CAAC;AAEjD,cAAc,8BAA8B,CAAC;AAE7C,cAAc,iDAAiD,CAAC;AAEhE,cAAc,iCAAiC,CAAC;AAEhD,cAAc,+BAA+B,CAAC;AAE9C,cAAc,+BAA+B,CAAC;AAE9C,cAAc,qCAAqC,CAAC;AAIpD,cAAc,gDAAgD,CAAC;AAE/D,cAAc,sCAAsC,CAAC;AAErD,cAAc,qDAAqD,CAAC;AAEpE,cAAc,gDAAgD,CAAC;AAI/D,cAAc,+CAA+C,CAAC;AAE9D,cAAc,uDAAuD,CAAC;AAEtE,cAAc,oDAAoD,CAAC;AAEnE,cAAc,qCAAqC,CAAC;AAIpD,cAAc,8CAA8C,CAAC;AAE7D,cAAc,uCAAuC,CAAC;AAEtD,cAAc,6CAA6C,CAAC;AAE5D,cAAc,iDAAiD,CAAC;AAIhE,cAAc,sDAAsD,CAAC;AAErE,cAAc,iDAAiD,CAAC;AAEhE,cAAc,uCAAuC,CAAC;AAEtD,cAAc,4CAA4C,CAAC;AAE3D,cAAc,0CAA0C,CAAC;AAEzD,cAAc,qCAAqC,CAAC;AAEpD,cAAc,4DAA4D,CAAC;AAE3E,cAAc,mDAAmD,CAAC;AAElE,cAAc,wDAAwD,CAAC;AAEvE,cAAc,oDAAoD,CAAC;AAEnE,cAAc,iDAAiD,CAAC;AAEhE,cAAc,sCAAsC,CAAC;AAErD,cAAc,uDAAuD,CAAC;AAEtE,cAAc,oCAAoC,CAAC;AAEnD,cAAc,4CAA4C,CAAC;AAE3D,cAAc,gDAAgD,CAAC;AAE/D,cAAc,gEAAgE,CAAC;AAE/E,cAAc,kDAAkD,CAAC;AAEjE,cAAc,mDAAmD,CAAC;AAElE,cAAc,mDAAmD,CAAC;AAElE,cAAc,0CAA0C,CAAC;AAEzD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,uCAAuC,CAAC;AAItD,cAAc,sCAAsC,CAAC;AAErD,cAAc,kDAAkD,CAAC;AAEjE,cAAc,yDAAyD,CAAC;AAExE,cAAc,yCAAyC,CAAC;AAExD,cAAc,6CAA6C,CAAC;AAE5D,cAAc,qDAAqD,CAAC;AAEpE,cAAc,2CAA2C,CAAC;AAE1D,cAAc,+CAA+C,CAAC;AAE9D,cAAc,iDAAiD,CAAC;AAEhE,cAAc,oDAAoD,CAAC;AAEnE,cAAc,mDAAmD,CAAC;AAElE,cAAc,0CAA0C,CAAC;AAEzD,cAAc,6CAA6C,CAAC"}