@interstellar-tools/equations 0.1.2 → 0.3.0

package/dist/{eccentric-to-true-anomaly.d.ts → categories/anomalies/eccentric-to-true-anomaly.d.ts}

@@ -27,7 +27,7 @@ import { Radians } from '@interstellar-tools/types';
  * @param {number} e - Orbital eccentricity ($0 \leq e < 1$).
  * @returns {Radians} True anomaly ($V$) in radians.
  *
- * @throws {RangeError} If **eccentricity** is out of the range $0 \leq e \leq 1$.
+ * @throws {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError | RangeError} If **eccentricity** is out of the range $0 \leq e \leq 1$.
  *
  * @example
  * ```ts
@@ -37,7 +37,7 @@ import { Radians } from '@interstellar-tools/types';
  * ```
  *
  * @see [True Anomaly (Wikipedia)](https://en.wikipedia.org/wiki/True_anomaly)
- * @category Anomaly
+ * @group Anomalies
  */
 export declare const eccentricToTrueAnomaly: (E: Radians, e: number) => Radians;
 //# sourceMappingURL=eccentric-to-true-anomaly.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"eccentric-to-true-anomaly.d.ts","sourceRoot":"","sources":["../../../src/categories/anomalies/eccentric-to-true-anomaly.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,sBAAsB,GAAI,GAAG,OAAO,EAAE,GAAG,MAAM,KAAG,OAiC9D,CAAC"}

package/dist/{eccentric-to-true-anomaly.js → categories/anomalies/eccentric-to-true-anomaly.js}

@@ -26,7 +26,7 @@
  * @param {number} e - Orbital eccentricity ($0 \leq e < 1$).
  * @returns {Radians} True anomaly ($V$) in radians.
  *
- * @throws {RangeError} If **eccentricity** is out of the range $0 \leq e \leq 1$.
+ * @throws {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError | RangeError} If **eccentricity** is out of the range $0 \leq e \leq 1$.
  *
  * @example
  * ```ts
@@ -36,7 +36,7 @@
  * ```
  *
  * @see [True Anomaly (Wikipedia)](https://en.wikipedia.org/wiki/True_anomaly)
- * @category Anomaly
+ * @group Anomalies
  */
 export const eccentricToTrueAnomaly = (E, e) => {
     // Validate eccentricity range

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

@@ -0,0 +1 @@
+{"version":3,"file":"eccentric-to-true-anomaly.js","sourceRoot":"","sources":["../../../src/categories/anomalies/eccentric-to-true-anomaly.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAU,EAAE,CAAS,EAAW,EAAE;IACvE,8BAA8B;IAC9B,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;QACnB,MAAM,IAAI,UAAU,CAClB,yBAAyB,CAAC,6CAA6C,CACxE,CAAC;IACJ,CAAC;IAED,gCAAgC;IAChC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACZ,OAAO,CAAC,CAAC,CAAC,4DAA4D;IACxE,CAAC;IAED,iCAAiC;IACjC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACZ,OAAO,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,uCAAuC;IACtE,CAAC;IAED,0CAA0C;IAC1C,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,0CAA0C;IAEjE,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC;QACxC,OAAO,IAAI,CAAC,EAAE,CAAC,CAAC,+BAA+B;IACjD,CAAC;IAED,0EAA0E;IAC1E,OAAO,CACL,CAAC;QACD,IAAI,CAAC,KAAK,CACR,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,EAClC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CACnC,CACF,CAAC;AACJ,CAAC,CAAC"}

package/dist/{compute-mean-anomaly.d.ts → categories/anomalies/mean-to-eccentric-anomaly.d.ts}

@@ -21,11 +21,11 @@ import type { CelestialBodyType, Radians, TemporalInterface } from '@interstella
  * @param {TemporalInterface} timeStep - The time step over which to compute the change.
  * @returns {Radians} The computed mean anomaly in radians.
  *
- * @throws {RangeError} If the body's eccentricity is outside the range $0 \leq e < 1$.
+ * @throws {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError | RangeError} If the body's eccentricity is outside the range $0 \leq e < 1$.
  *
  * @example
  * ```ts
- * import { computeMeanAnomaly } from './compute-mean-anomaly';
+ * import { meanToEccentricAnomaly } from './mean-to-eccentric-anomaly';
  *
  * const mars: CelestialBodyType = {
  *   name: 'Mars',
@@ -35,13 +35,13 @@ import type { CelestialBodyType, Radians, TemporalInterface } from '@interstella
  * };
  *
  * const timeStep: TemporalInterface = { value: 1, unit: 'day' }; // 1-day step
- * const meanAnomaly = computeMeanAnomaly(mars, timeStep);
+ * const meanAnomaly = meanToEccentricAnomaly(mars, timeStep);
  * console.log(meanAnomaly); // Output: Computed mean anomaly in radians
  * ```
  *
  * @see [Mean Anomaly (Wikipedia)](https://en.wikipedia.org/wiki/Mean_anomaly)
  * @see [Orbital Mechanics (NASA)](https://solarsystem.nasa.gov/basics/chapter2-2/)
- * @category Anomaly
+ * @group Anomalies
  */
-export declare const computeMeanAnomaly: (body: CelestialBodyType, timeStep: TemporalInterface) => Radians;
-//# sourceMappingURL=compute-mean-anomaly.d.ts.map
+export declare const meanToEccentricAnomaly: (body: CelestialBodyType, timeStep: TemporalInterface) => Radians;
+//# sourceMappingURL=mean-to-eccentric-anomaly.d.ts.map

package/dist/categories/anomalies/mean-to-eccentric-anomaly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mean-to-eccentric-anomaly.d.ts","sourceRoot":"","sources":["../../../src/categories/anomalies/mean-to-eccentric-anomaly.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,iBAAiB,EACjB,OAAO,EACP,iBAAiB,EAClB,MAAM,2BAA2B,CAAC;AAQnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,eAAO,MAAM,sBAAsB,GACjC,MAAM,iBAAiB,EACvB,UAAU,iBAAiB,KAC1B,OAoCF,CAAC"}

package/dist/{compute-mean-anomaly.js → categories/anomalies/mean-to-eccentric-anomaly.js}

@@ -1,19 +1,9 @@
 import { TWO_PI } from '@interstellar-tools/constants';
 import { convertTemporalUnit } from '@interstellar-tools/temporal';
-import { trueAnomalyToMeanAnomaly } from './true-anomaly-to-mean-anomaly';
-import { wrapAngle } from './wrap-angle';
-const EPSILON = 1e-15; // Increased tolerance for high eccentricity
-/**
- * Compares two floating-point numbers for equality within a tolerance.
- *
- * @param {number} a - First number to compare.
- * @param {number} b - Second number to compare.
- * @param {number} [epsilon=EPSILON] - Tolerance for floating-point precision.
- * @returns {boolean} `true` if values are approximately equal.
- */
-const areEqual = (a, b, epsilon = EPSILON) => {
-    return Math.abs(a - b) < epsilon * Math.max(1, Math.abs(a), Math.abs(b));
-};
+import { wrapAngle } from '../angle/wrap-angle';
+import { trueToMeanAnomaly } from './true-to-mean-anomaly';
+import { areEqual } from './utils/are-equal';
+/* node:coverage disable */
 /**
  * Computes the **mean anomaly** ($M$) of a celestial body for a given time step.
  *
@@ -36,11 +26,11 @@ const areEqual = (a, b, epsilon = EPSILON) => {
  * @param {TemporalInterface} timeStep - The time step over which to compute the change.
  * @returns {Radians} The computed mean anomaly in radians.
  *
- * @throws {RangeError} If the body's eccentricity is outside the range $0 \leq e < 1$.
+ * @throws {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError | RangeError} If the body's eccentricity is outside the range $0 \leq e < 1$.
  *
  * @example
  * ```ts
- * import { computeMeanAnomaly } from './compute-mean-anomaly';
+ * import { meanToEccentricAnomaly } from './mean-to-eccentric-anomaly';
  *
  * const mars: CelestialBodyType = {
  *   name: 'Mars',
@@ -50,15 +40,16 @@ const areEqual = (a, b, epsilon = EPSILON) => {
  * };
  *
  * const timeStep: TemporalInterface = { value: 1, unit: 'day' }; // 1-day step
- * const meanAnomaly = computeMeanAnomaly(mars, timeStep);
+ * const meanAnomaly = meanToEccentricAnomaly(mars, timeStep);
  * console.log(meanAnomaly); // Output: Computed mean anomaly in radians
  * ```
  *
  * @see [Mean Anomaly (Wikipedia)](https://en.wikipedia.org/wiki/Mean_anomaly)
  * @see [Orbital Mechanics (NASA)](https://solarsystem.nasa.gov/basics/chapter2-2/)
- * @category Anomaly
+ * @group Anomalies
  */
-export const computeMeanAnomaly = (body, timeStep) => {
+/* node:coverage enable */
+export const meanToEccentricAnomaly = (body, timeStep) => {
     const { e, angle, period } = body;
     if (e < 0 || e >= 1) {
         throw new RangeError(`Invalid eccentricity: ${e}. Eccentricity must be in the range [0, 1].`);
@@ -67,7 +58,7 @@ export const computeMeanAnomaly = (body, timeStep) => {
     const periodInDays = convertTemporalUnit(period, 'd').value;
     const meanMotion = TWO_PI / Math.abs(periodInDays);
     // Convert true anomaly (V) to mean anomaly (M0) if necessary
-    const M0 = e === 0 ? angle : trueAnomalyToMeanAnomaly(angle, e);
+    const M0 = e === 0 ? angle : trueToMeanAnomaly(angle, e);
     if (timeStep.value === 0) {
         return M0;
     }
@@ -83,4 +74,4 @@ export const computeMeanAnomaly = (body, timeStep) => {
     }
     return newM;
 };
-//# sourceMappingURL=compute-mean-anomaly.js.map
+//# sourceMappingURL=mean-to-eccentric-anomaly.js.map

package/dist/categories/anomalies/mean-to-eccentric-anomaly.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mean-to-eccentric-anomaly.js","sourceRoot":"","sources":["../../../src/categories/anomalies/mean-to-eccentric-anomaly.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AACvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAOnE,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEhD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,2BAA2B;AAC3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,0BAA0B;AAC1B,MAAM,CAAC,MAAM,sBAAsB,GAAG,CACpC,IAAuB,EACvB,QAA2B,EAClB,EAAE;IACX,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAElC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACpB,MAAM,IAAI,UAAU,CAClB,yBAAyB,CAAC,6CAA6C,CACxE,CAAC;IACJ,CAAC;IAED,iDAAiD;IACjD,MAAM,YAAY,GAAG,mBAAmB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC;IAC5D,MAAM,UAAU,GAAG,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IACnD,6DAA6D;IAC7D,MAAM,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,iBAAiB,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAEzD,IAAI,QAAQ,CAAC,KAAK,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,2DAA2D;IAC3D,MAAM,WAAW,GAAG,IAAI,CAAC,CAAC,4BAA4B;IACtD,MAAM,iBAAiB,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,6CAA6C;IAC1F,MAAM,aAAa,GAAG,IAAI,CAAC,GAAG,CAC5B,WAAW,EACX,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,CACrE,CAAC;IACF,wEAAwE;IACxE,MAAM,KAAK,GAAG,EAAE,CAAC;IAEjB,IAAI,IAAI,GAAG,SAAS,CAAC,EAAE,GAAG,UAAU,GAAG,aAAa,CAAC,CAAC;IAEtD,IAAI,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC;QAC1B,IAAI,GAAG,KAAK,CAAC;IACf,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC,CAAC"}

package/dist/{true-anomaly-to-mean-anomaly.d.ts → categories/anomalies/true-to-mean-anomaly.d.ts}

@@ -46,12 +46,12 @@
  *
  * @example
  * ```ts
- * import { trueAnomalyToMeanAnomaly } from './true-anomaly-to-mean-anomaly';
+ * import { trueToMeanAnomaly } from './true-anomaly-to-mean-anomaly';
  *
  * // Example 1: Standard elliptical orbit
  * const V = Math.PI / 3; // 60 degrees in radians
  * const e = 0.1; // Eccentricity
- * console.log(trueAnomalyToMeanAnomaly(V, e)); // Output: Mean anomaly in radians
+ * console.log(trueToMeanAnomaly(V, e)); // Output: Mean anomaly in radians
  * ```
  *
  * @example
@@ -59,7 +59,7 @@
  * // Example 2: Retrograde motion handling
  * const V_retrograde = -Math.PI / 2; // -90 degrees
  * const e_retrograde = 0.2;
- * console.log(trueAnomalyToMeanAnomaly(V_retrograde, e_retrograde));
+ * console.log(trueToMeanAnomaly(V_retrograde, e_retrograde));
  * ```
  *
  * ---
@@ -68,7 +68,7 @@
  * @see [True Anomaly (Wikipedia)](https://en.wikipedia.org/wiki/True_anomaly)
  * @see [Mean Anomaly (Wikipedia)](https://en.wikipedia.org/wiki/Mean_anomaly)
  * @see [Orbital Eccentricity (Wikipedia)](https://en.wikipedia.org/wiki/Orbital_eccentricity)
- * @category Anomaly
+ * @group Anomalies
  */
-export declare const trueAnomalyToMeanAnomaly: (V: number, e: number) => number;
-//# sourceMappingURL=true-anomaly-to-mean-anomaly.d.ts.map
+export declare const trueToMeanAnomaly: (V: number, e: number) => number;
+//# sourceMappingURL=true-to-mean-anomaly.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"true-to-mean-anomaly.d.ts","sourceRoot":"","sources":["../../../src/categories/anomalies/true-to-mean-anomaly.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,eAAO,MAAM,iBAAiB,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAuBxD,CAAC"}

package/dist/{true-anomaly-to-mean-anomaly.js → categories/anomalies/true-to-mean-anomaly.js}

@@ -1,4 +1,4 @@
-import { wrapAngle } from './wrap-angle';
+import { wrapAngle } from '../angle/wrap-angle';
 /**
  * Converts **true anomaly** ($\nu$) to **mean anomaly** ($M$) using Kepler's equation.
  *
@@ -47,12 +47,12 @@ import { wrapAngle } from './wrap-angle';
  *
  * @example
  * ```ts
- * import { trueAnomalyToMeanAnomaly } from './true-anomaly-to-mean-anomaly';
+ * import { trueToMeanAnomaly } from './true-anomaly-to-mean-anomaly';
  *
  * // Example 1: Standard elliptical orbit
  * const V = Math.PI / 3; // 60 degrees in radians
  * const e = 0.1; // Eccentricity
- * console.log(trueAnomalyToMeanAnomaly(V, e)); // Output: Mean anomaly in radians
+ * console.log(trueToMeanAnomaly(V, e)); // Output: Mean anomaly in radians
  * ```
  *
  * @example
@@ -60,7 +60,7 @@ import { wrapAngle } from './wrap-angle';
  * // Example 2: Retrograde motion handling
  * const V_retrograde = -Math.PI / 2; // -90 degrees
  * const e_retrograde = 0.2;
- * console.log(trueAnomalyToMeanAnomaly(V_retrograde, e_retrograde));
+ * console.log(trueToMeanAnomaly(V_retrograde, e_retrograde));
  * ```
  *
  * ---
@@ -69,9 +69,9 @@ import { wrapAngle } from './wrap-angle';
  * @see [True Anomaly (Wikipedia)](https://en.wikipedia.org/wiki/True_anomaly)
  * @see [Mean Anomaly (Wikipedia)](https://en.wikipedia.org/wiki/Mean_anomaly)
  * @see [Orbital Eccentricity (Wikipedia)](https://en.wikipedia.org/wiki/Orbital_eccentricity)
- * @category Anomaly
+ * @group Anomalies
  */
-export const trueAnomalyToMeanAnomaly = (V, e) => {
+export const trueToMeanAnomaly = (V, e) => {
     if (e < 0 || e >= 1) {
         throw new RangeError('Eccentricity (e) must be in the range 0 ≤ e < 1 for elliptical orbits.');
     }
@@ -88,4 +88,4 @@ export const trueAnomalyToMeanAnomaly = (V, e) => {
     // Ensure M is always in the range [0, 2π]
     return wrapAngle(M);
 };
-//# sourceMappingURL=true-anomaly-to-mean-anomaly.js.map
+//# sourceMappingURL=true-to-mean-anomaly.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"true-to-mean-anomaly.js","sourceRoot":"","sources":["../../../src/categories/anomalies/true-to-mean-anomaly.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAS,EAAE,CAAS,EAAU,EAAE;IAChE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACpB,MAAM,IAAI,UAAU,CAClB,wEAAwE,CACzE,CAAC;IACJ,CAAC;IAED,8EAA8E;IAC9E,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACjC,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAE5C,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC;IAE7C,yDAAyD;IACzD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,EAAE,EAAE,CAAC;QAChC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC;IACvC,CAAC;IAED,oDAAoD;IACpD,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAE9B,0CAA0C;IAC1C,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC;AACtB,CAAC,CAAC"}

package/dist/categories/anomalies/utils/are-equal.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Compares two floating-point numbers for equality within a tolerance.
+ *
+ * @param {number} a - First number to compare.
+ * @param {number} b - Second number to compare.
+ * @param {number} [epsilon=EPSILON] - Tolerance for floating-point precision.
+ * @returns {boolean} `true` if values are approximately equal.
+ */
+export declare const areEqual: (a: number, b: number, epsilon?: number) => boolean;
+//# sourceMappingURL=are-equal.d.ts.map

package/dist/categories/anomalies/utils/are-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"are-equal.d.ts","sourceRoot":"","sources":["../../../../src/categories/anomalies/utils/are-equal.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,GACnB,GAAG,MAAM,EACT,GAAG,MAAM,EACT,UAAS,MAAgB,KACxB,OAEF,CAAC"}

package/dist/categories/anomalies/utils/are-equal.js

@@ -0,0 +1,13 @@
+const EPSILON = 1e-15; // Increased tolerance for high eccentricity
+/**
+ * Compares two floating-point numbers for equality within a tolerance.
+ *
+ * @param {number} a - First number to compare.
+ * @param {number} b - Second number to compare.
+ * @param {number} [epsilon=EPSILON] - Tolerance for floating-point precision.
+ * @returns {boolean} `true` if values are approximately equal.
+ */
+export const areEqual = (a, b, epsilon = EPSILON) => {
+    return Math.abs(a - b) < epsilon * Math.max(1, Math.abs(a), Math.abs(b));
+};
+//# sourceMappingURL=are-equal.js.map

package/dist/categories/anomalies/utils/are-equal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"are-equal.js","sourceRoot":"","sources":["../../../../src/categories/anomalies/utils/are-equal.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,4CAA4C;AAEnE;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CACtB,CAAS,EACT,CAAS,EACT,UAAkB,OAAO,EAChB,EAAE;IACX,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3E,CAAC,CAAC"}

package/dist/categories/gravity/acceleration-on1-by2.d.ts

@@ -0,0 +1,66 @@
+import type { Vector3DTupleType } from '@interstellar-tools/types';
+/**
+ * Gravitational **acceleration** of body 1 due to body 2 (vector, m/s²).
+ *
+ * **Definitions**
+ *
+ * $$
+ * \mathbf r=\mathbf r_2-\mathbf r_1,\quad
+ * r=\lVert\mathbf r\rVert,\quad
+ * \hat{\mathbf r}=\frac{\mathbf r}{r}
+ * $$
+ *
+ * **Acceleration field**
+ *
+ * $$
+ * \mathbf a_{1\leftarrow2}
+ * = \frac{\mathbf F_{1\leftarrow2}}{m_1}
+ * = G\,\frac{m_2}{r^2}\,\hat{\mathbf r}
+ * $$
+ *
+ * **Units**
+ * - Inputs: masses in **kg**, positions in **m**, ($ G $) in **m³·kg⁻¹·s⁻²**.
+ * - Output: acceleration in **m/s²**.
+ *
+ * ::: info
+ *
+ * - Implemented via `gravitationalForce(1, m2, r1, r2, G)`, so the returned vector equals the force on a **1 kg** test mass (i.e., the acceleration).
+ * - Direction points **from body 1 toward body 2**: ($  \hat{\mathbf r}  $).
+ *
+ * :::
+ *
+ * **Invariants (within FP tolerance)**
+ * - `||a|| = G*m2/r^2`
+ * - `a = ||a|| * r̂`
+ *
+ * @param {number} m2 Mass of body 2 (kg).
+ * @param {Vector3DTupleType} r1 Position of body 1 `[x, y, z]` in meters.
+ * @param {Vector3DTupleType} r2 Position of body 2 `[x, y, z]` in meters.
+ * @param {number} [G=G_SI] Gravitational constant.
+ * @returns {Vector3DTupleType} Acceleration of body 1 due to body 2 (m/s²).
+ *
+ * @example
+ * ```ts
+ * // Acceleration of a satellite due to Earth at ~7000 km from Earth's center
+ * const mSat = 500;                       // kg (any value; a is independent of mSat)
+ * const mEarth = 5.972e24;                // kg
+ * const rSat:   [number, number, number] = [7.0e6, 0, 0]; // m
+ * const rEarth: [number, number, number] = [0, 0, 0];
+ *
+ * const a = accelerationOn1By2(mSat, mEarth, rSat, rEarth);
+ * // ≈ [-8.14, 0, 0] m/s² (toward Earth)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Derive force from acceleration (F = m1 * a)
+ * const m1 = 1200; // kg spacecraft
+ * const a = accelerationOn1By2(m1, mEarth, rSat, rEarth);
+ * const F: [number, number, number] = [a[0]*m1, a[1]*m1, a[2]*m1]; // newtons
+ * ```
+ *
+ * @see https://en.wikipedia.org/wiki/Newton%27s_law_of_universal_gravitation
+ * @group Gravity
+ */
+export declare const accelerationOn1By2: (m2: number, r1: Vector3DTupleType, r2: Vector3DTupleType, G?: number) => Vector3DTupleType;
+//# sourceMappingURL=acceleration-on1-by2.d.ts.map

package/dist/categories/gravity/acceleration-on1-by2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acceleration-on1-by2.d.ts","sourceRoot":"","sources":["../../../src/categories/gravity/acceleration-on1-by2.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAInE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,eAAO,MAAM,kBAAkB,GAC7B,IAAI,MAAM,EACV,IAAI,iBAAiB,EACrB,IAAI,iBAAiB,EACrB,IAAG,MAAa,KACf,iBASF,CAAC"}

package/dist/categories/gravity/acceleration-on1-by2.js

@@ -0,0 +1,75 @@
+import { G_SI } from '@interstellar-tools/constants';
+import { gravitationalForce } from './gravitational-force';
+/**
+ * Gravitational **acceleration** of body 1 due to body 2 (vector, m/s²).
+ *
+ * **Definitions**
+ *
+ * $$
+ * \mathbf r=\mathbf r_2-\mathbf r_1,\quad
+ * r=\lVert\mathbf r\rVert,\quad
+ * \hat{\mathbf r}=\frac{\mathbf r}{r}
+ * $$
+ *
+ * **Acceleration field**
+ *
+ * $$
+ * \mathbf a_{1\leftarrow2}
+ * = \frac{\mathbf F_{1\leftarrow2}}{m_1}
+ * = G\,\frac{m_2}{r^2}\,\hat{\mathbf r}
+ * $$
+ *
+ * **Units**
+ * - Inputs: masses in **kg**, positions in **m**, ($ G $) in **m³·kg⁻¹·s⁻²**.
+ * - Output: acceleration in **m/s²**.
+ *
+ * ::: info
+ *
+ * - Implemented via `gravitationalForce(1, m2, r1, r2, G)`, so the returned vector equals the force on a **1 kg** test mass (i.e., the acceleration).
+ * - Direction points **from body 1 toward body 2**: ($  \hat{\mathbf r}  $).
+ *
+ * :::
+ *
+ * **Invariants (within FP tolerance)**
+ * - `||a|| = G*m2/r^2`
+ * - `a = ||a|| * r̂`
+ *
+ * @param {number} m2 Mass of body 2 (kg).
+ * @param {Vector3DTupleType} r1 Position of body 1 `[x, y, z]` in meters.
+ * @param {Vector3DTupleType} r2 Position of body 2 `[x, y, z]` in meters.
+ * @param {number} [G=G_SI] Gravitational constant.
+ * @returns {Vector3DTupleType} Acceleration of body 1 due to body 2 (m/s²).
+ *
+ * @example
+ * ```ts
+ * // Acceleration of a satellite due to Earth at ~7000 km from Earth's center
+ * const mSat = 500;                       // kg (any value; a is independent of mSat)
+ * const mEarth = 5.972e24;                // kg
+ * const rSat:   [number, number, number] = [7.0e6, 0, 0]; // m
+ * const rEarth: [number, number, number] = [0, 0, 0];
+ *
+ * const a = accelerationOn1By2(mSat, mEarth, rSat, rEarth);
+ * // ≈ [-8.14, 0, 0] m/s² (toward Earth)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Derive force from acceleration (F = m1 * a)
+ * const m1 = 1200; // kg spacecraft
+ * const a = accelerationOn1By2(m1, mEarth, rSat, rEarth);
+ * const F: [number, number, number] = [a[0]*m1, a[1]*m1, a[2]*m1]; // newtons
+ * ```
+ *
+ * @see https://en.wikipedia.org/wiki/Newton%27s_law_of_universal_gravitation
+ * @group Gravity
+ */
+export const accelerationOn1By2 = (m2, r1, r2, G = G_SI) => {
+    const { direction, magnitude } = gravitationalForce(1, m2, r1, r2, G); // |F| on 1 kg == |a|
+    const a = [
+        direction[0] * magnitude,
+        direction[1] * magnitude,
+        direction[2] * magnitude
+    ];
+    return a;
+};
+//# sourceMappingURL=acceleration-on1-by2.js.map

package/dist/categories/gravity/acceleration-on1-by2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"acceleration-on1-by2.js","sourceRoot":"","sources":["../../../src/categories/gravity/acceleration-on1-by2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,+BAA+B,CAAC;AAGrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,EAAU,EACV,EAAqB,EACrB,EAAqB,EACrB,IAAY,IAAI,EACG,EAAE;IACrB,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,kBAAkB,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,qBAAqB;IAC5F,MAAM,CAAC,GAAsB;QAC3B,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS;QACxB,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS;QACxB,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS;KACzB,CAAC;IAEF,OAAO,CAAC,CAAC;AACX,CAAC,CAAC"}

package/dist/categories/gravity/force-on1-by2.d.ts

@@ -0,0 +1,87 @@
+import type { Vector3DTupleType } from '@interstellar-tools/types';
+/**
+ * Gravitational **force vector** on body 1 due to body 2 (newtons, N).
+ *
+ * **Definitions**
+ *
+ * $$
+ * \mathbf r=\mathbf r_2-\mathbf r_1,\quad
+ * r=\lVert\mathbf r\rVert,\quad
+ * \hat{\mathbf r}=\frac{\mathbf r}{r}
+ * $$
+ *
+ * **Newton's law (vector form)**
+ *
+ * $$
+ * \mathbf F_{1\leftarrow2}
+ * = G\,\frac{m_1 m_2}{r^2}\,\hat{\mathbf r}
+ * $$
+ *
+ * **Magnitude & Components**
+ *
+ * $$
+ * \lVert\mathbf F\rVert=G\,\frac{m_1 m_2}{r^2},\qquad
+ * \mathbf F=\langle F_x,F_y,F_z\rangle=\lVert\mathbf F\rVert\,\hat{\mathbf r}
+ * $$
+ *
+ * $$
+ * F_x=\lVert\mathbf F\rVert\,\hat r_x,\quad
+ * F_y=\lVert\mathbf F\rVert\,\hat r_y,\quad
+ * F_z=\lVert\mathbf F\rVert\,\hat r_z
+ * $$
+ *
+ * **Newton's 3rd law (context)**
+ *
+ * $$
+ * \mathbf F_{1\leftarrow2}=-\,\mathbf F_{2\leftarrow1}
+ * $$
+ *
+ * **Units**
+ * - Inputs: masses in **kg**, positions in **m**, ($ G $) in **m³·kg⁻¹·s⁻²**.
+ * - Output: force vector in **newtons (N)**.
+ *
+ * ::: info
+ *
+ * - The returned vector points **from body 1 toward body 2** (i.e., along ($  \hat{\mathbf r}  $)).
+ * - Internally delegates to `gravitationalForce(m1, m2, r1, r2, G)` and returns its
+ *   direction-scaled magnitude as a 3-tuple.
+ * - For acceleration instead of force, use `accelerationOn1By2` or compute ($  \mathbf a=\mathbf F/m_1  $).
+ *
+ * :::
+ *
+ * **Invariants (within FP tolerance)**
+ * - `||F|| = G*m1*m2/r^2`
+ * - `F = ||F|| * r̂`
+ *
+ * @param {number} m1 Mass of body 1 (kg).
+ * @param {number} m2 Mass of body 2 (kg).
+ * @param {Vector3DTupleType} r1 Position of body 1 `[x, y, z]` in meters.
+ * @param {Vector3DTupleType} r2 Position of body 2 `[x, y, z]` in meters.
+ * @param {number} [G=G_SI] Gravitational constant.
+ * @returns {Vector3DTupleType} Force on body 1 due to body 2, in newtons `[Fx, Fy, Fz]`.
+ *
+ * @throws {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error | Error} Propagated from `gravitationalForce` if inputs are invalid (non-finite/negative masses, coincident positions ($ r=0 $), or non-positive ($ G $)).
+ *
+ * @example
+ * ```ts
+ * // Earth–Sun at ~1 AU (force on Earth due to Sun)
+ * const mEarth = 5.972e24;  // kg
+ * const mSun   = 1.9885e30; // kg
+ * const rEarth: [number, number, number] = [0, 0, 0];
+ * const rSun  : [number, number, number] = [1.495978707e11, 0, 0]; // m
+ *
+ * const F = forceOn1By2(mEarth, mSun, rEarth, rSun); // N
+ * const Fmag = Math.hypot(F[0], F[1], F[2]); // ≈ 3.54e22 N
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Derive acceleration from the returned force: a = F / m1
+ * const a: [number, number, number] = [F[0]/mEarth, F[1]/mEarth, F[2]/mEarth]; // m/s^2
+ * ```
+ *
+ * @see https://en.wikipedia.org/wiki/Newton%27s_law_of_universal_gravitation
+ * @group Gravity
+ */
+export declare const forceOn1By2: (m1: number, m2: number, r1: Vector3DTupleType, r2: Vector3DTupleType, G?: number) => Vector3DTupleType;
+//# sourceMappingURL=force-on1-by2.d.ts.map

package/dist/categories/gravity/force-on1-by2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"force-on1-by2.d.ts","sourceRoot":"","sources":["../../../src/categories/gravity/force-on1-by2.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAInE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AACH,eAAO,MAAM,WAAW,GACtB,IAAI,MAAM,EACV,IAAI,MAAM,EACV,IAAI,iBAAiB,EACrB,IAAI,iBAAiB,EACrB,IAAG,MAAa,KACf,iBASF,CAAC"}

package/dist/categories/gravity/force-on1-by2.js

@@ -0,0 +1,96 @@
+import { G_SI } from '@interstellar-tools/constants';
+import { gravitationalForce } from './gravitational-force';
+/**
+ * Gravitational **force vector** on body 1 due to body 2 (newtons, N).
+ *
+ * **Definitions**
+ *
+ * $$
+ * \mathbf r=\mathbf r_2-\mathbf r_1,\quad
+ * r=\lVert\mathbf r\rVert,\quad
+ * \hat{\mathbf r}=\frac{\mathbf r}{r}
+ * $$
+ *
+ * **Newton's law (vector form)**
+ *
+ * $$
+ * \mathbf F_{1\leftarrow2}
+ * = G\,\frac{m_1 m_2}{r^2}\,\hat{\mathbf r}
+ * $$
+ *
+ * **Magnitude & Components**
+ *
+ * $$
+ * \lVert\mathbf F\rVert=G\,\frac{m_1 m_2}{r^2},\qquad
+ * \mathbf F=\langle F_x,F_y,F_z\rangle=\lVert\mathbf F\rVert\,\hat{\mathbf r}
+ * $$
+ *
+ * $$
+ * F_x=\lVert\mathbf F\rVert\,\hat r_x,\quad
+ * F_y=\lVert\mathbf F\rVert\,\hat r_y,\quad
+ * F_z=\lVert\mathbf F\rVert\,\hat r_z
+ * $$
+ *
+ * **Newton's 3rd law (context)**
+ *
+ * $$
+ * \mathbf F_{1\leftarrow2}=-\,\mathbf F_{2\leftarrow1}
+ * $$
+ *
+ * **Units**
+ * - Inputs: masses in **kg**, positions in **m**, ($ G $) in **m³·kg⁻¹·s⁻²**.
+ * - Output: force vector in **newtons (N)**.
+ *
+ * ::: info
+ *
+ * - The returned vector points **from body 1 toward body 2** (i.e., along ($  \hat{\mathbf r}  $)).
+ * - Internally delegates to `gravitationalForce(m1, m2, r1, r2, G)` and returns its
+ *   direction-scaled magnitude as a 3-tuple.
+ * - For acceleration instead of force, use `accelerationOn1By2` or compute ($  \mathbf a=\mathbf F/m_1  $).
+ *
+ * :::
+ *
+ * **Invariants (within FP tolerance)**
+ * - `||F|| = G*m1*m2/r^2`
+ * - `F = ||F|| * r̂`
+ *
+ * @param {number} m1 Mass of body 1 (kg).
+ * @param {number} m2 Mass of body 2 (kg).
+ * @param {Vector3DTupleType} r1 Position of body 1 `[x, y, z]` in meters.
+ * @param {Vector3DTupleType} r2 Position of body 2 `[x, y, z]` in meters.
+ * @param {number} [G=G_SI] Gravitational constant.
+ * @returns {Vector3DTupleType} Force on body 1 due to body 2, in newtons `[Fx, Fy, Fz]`.
+ *
+ * @throws {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error | Error} Propagated from `gravitationalForce` if inputs are invalid (non-finite/negative masses, coincident positions ($ r=0 $), or non-positive ($ G $)).
+ *
+ * @example
+ * ```ts
+ * // Earth–Sun at ~1 AU (force on Earth due to Sun)
+ * const mEarth = 5.972e24;  // kg
+ * const mSun   = 1.9885e30; // kg
+ * const rEarth: [number, number, number] = [0, 0, 0];
+ * const rSun  : [number, number, number] = [1.495978707e11, 0, 0]; // m
+ *
+ * const F = forceOn1By2(mEarth, mSun, rEarth, rSun); // N
+ * const Fmag = Math.hypot(F[0], F[1], F[2]); // ≈ 3.54e22 N
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Derive acceleration from the returned force: a = F / m1
+ * const a: [number, number, number] = [F[0]/mEarth, F[1]/mEarth, F[2]/mEarth]; // m/s^2
+ * ```
+ *
+ * @see https://en.wikipedia.org/wiki/Newton%27s_law_of_universal_gravitation
+ * @group Gravity
+ */
+export const forceOn1By2 = (m1, m2, r1, r2, G = G_SI) => {
+    const { direction, magnitude } = gravitationalForce(m1, m2, r1, r2, G); // |F|
+    const F = [
+        direction[0] * magnitude,
+        direction[1] * magnitude,
+        direction[2] * magnitude
+    ];
+    return F;
+};
+//# sourceMappingURL=force-on1-by2.js.map

package/dist/categories/gravity/force-on1-by2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"force-on1-by2.js","sourceRoot":"","sources":["../../../src/categories/gravity/force-on1-by2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,+BAA+B,CAAC;AAGrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,EAAU,EACV,EAAU,EACV,EAAqB,EACrB,EAAqB,EACrB,IAAY,IAAI,EACG,EAAE;IACrB,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,kBAAkB,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM;IAC9E,MAAM,CAAC,GAAsB;QAC3B,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS;QACxB,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS;QACxB,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS;KACzB,CAAC;IAEF,OAAO,CAAC,CAAC;AACX,CAAC,CAAC"}