@saber-usa/node-common 1.7.2 → 1.7.3

package/src/OrbitUtils.js

@@ -1,490 +1,490 @@
-import {MU} from "./constants.js";
-import {cross, norm} from "mathjs";
-import {wrapHalfRevUnsigned, wrapOneRevUnsigned} from "./utils.js";
-
-const EARTH_MU_KM = MU / 1e9;
-
-class OrbitUtils {
-    constructor() {
-        // Prevent instantiation
-    }
-    /**
-     * Get inclination based on azimuth and latitude.
-     * @param {number} azimuthRad - Azimuth in radians
-     * @param {number} latitudeRad - Latitude in radians
-     * @return {number} Inclination in radians
-     */
-    static getInclination(azimuthRad, latitudeRad) {
-        const inclination = Math.acos(Math.cos(latitudeRad) * Math.sin(azimuthRad));
-        return wrapHalfRevUnsigned(inclination);
-    }
-
-    /**
-     * Get the azimuth based on inclination and latitude.
-     * Two results will be possible, based on whether you are Ascending from South to North or Descending from North to South.
-     * @param {number} inclinationRad - Inclination in radians
-     * @param {number} latitudeRad - Latitude in radians
-     * @param {boolean} ascending - Ascending (true) or descending (false)
-     * @return {number} Azimuth in radians
-     */
-    static getAzimuth(inclinationRad, latitudeRad, ascending = true) {
-        const azimuth = Math.asin(Math.cos(inclinationRad) / Math.cos(latitudeRad));
-        if (!ascending) {
-            return wrapOneRevUnsigned(Math.PI - azimuth);
-        }
-        return wrapOneRevUnsigned(azimuth);
-    }
-
-    /**
-     * Calculate the specific angular momentum (h) vector of an orbit.
-     * @param {Array} r - Position vector [x, y, z]
-     * @param {Array} v - Velocity vector [vx, vy, vz]
-     * @return {Array} Angular momentum vector
-     */
-    static getAngularMomentum(r, v) {
-        return cross(r, v);
-    }
-
-    /**
-     * Get mean motion (rad/sec).
-     * @param {number} a - Semi Major Axis (km)
-     * @param {number} mu - Standard gravitational parameter (km^3/s^2)
-     * @return {number} Mean motion in rad/sec
-     */
-    static getMeanMotion(a, mu = EARTH_MU_KM) {
-        return Math.sqrt(mu / Math.pow(a, 3));
-    }
-
-    /**
-     * Get the period of an orbit in seconds.
-     * @param {number} a - Semi Major Axis (km)
-     * @param {number} mu - Standard gravitational parameter (km^3/s^2)
-     * @return {number} Period in seconds
-     */
-    static getPeriod(a, mu = EARTH_MU_KM) {
-        if (a <= 0) return null;
-        return 2 * Math.PI * Math.sqrt(Math.pow(a, 3) / mu);
-    }
-
-    /**
-     * Transform an orbit to elliptical with target parameters using Brent's method.
-     * Accurate port of the C# TransformElliptical method.
-     * @param {Object} svInitial - Initial state vector {position: [x,y,z], velocity: [vx,vy,vz], epoch: Date}
-     * @param {number} incRad - Inclination in radians
-     * @param {number} raanRad - RAAN in radians
-     * @param {number} targetEcc - Target eccentricity
-     * @param {number} targetArgOfPeriapsisRad - Target argument of periapsis in radians
-     * @param {number} targetPerigeeKm - Target perigee in km
-     * @return {Object} Satellite object with new orbital elements
-     */
-    static transformElliptical(svInitial, incRad, raanRad,
-        targetEcc, targetArgOfPeriapsisRad, targetPerigeeKm) {
-        // Normalize the position vector
-        const rNorm = norm(svInitial.position);
-        const r = svInitial.position.map((x) => x / rNorm);
-
-        // Project the position vector onto the orbital plane
-        const projectedX = r[0] * Math.cos(raanRad) + r[1] * Math.sin(raanRad);
-        const projectedY = r[1] * Math.cos(raanRad) - r[0] * Math.sin(raanRad);
-
-        // Calculate the initial true anomaly using the projected coordinates and known argument of periapsis
-        let nu0 = Math.atan2(projectedY, projectedX) - targetArgOfPeriapsisRad;
-        nu0 = (nu0 + 2 * Math.PI) % (2 * Math.PI);
-
-        // Define the objective function that we want to minimize
-        const objectiveFunction = (nu) => {
-            nu = (nu + 2 * Math.PI) % (2 * Math.PI);
-
-            // Create orbital elements with the trial true anomaly
-            const semiMajorAxis = targetPerigeeKm / (1 - targetEcc);
-            const elements = {
-                semiMajorAxis: semiMajorAxis,
-                eccentricity: targetEcc,
-                inclination: incRad,
-                raan: raanRad,
-                argOfPeriapsis: targetArgOfPeriapsisRad,
-                trueAnomaly: nu,
-                epoch: svInitial.epoch,
-            };
-
-            // Convert elements to state vector
-            const trialState = this.elementsToStateVector(elements);
-
-            // Normalize the trial position vector
-            const trialRNorm = norm(trialState.position);
-            const trialR = trialState.position.map((x) => x / trialRNorm);
-
-            // Scale trial position to match initial position magnitude
-            const pScaled = trialR.map((x) => x * rNorm);
-
-            // Return the distance between initial and trial positions
-            return norm(svInitial.position.map((x, i) => x - pScaled[i]));
-        };
-
-        // Use Brent's method for minimization
-        const tolerance = 1e-6; // radians
-        const maxIterations = 1000;
-
-        // Initial bracket around the solution
-        let a = nu0 - Math.PI;
-        let b = nu0 + Math.PI;
-        let c = nu0;
-
-        let fa = objectiveFunction(a);
-        let fb = objectiveFunction(b);
-        let fc = objectiveFunction(c);
-
-        let d = 0; let e = 0; let min1; let min2;
-        let p; let q; let r1; let tol1; let xm;
-
-        for (let iter = 0; iter < maxIterations; iter++) {
-            if (Math.abs(b - a) < tolerance) {
-                // Found minimum
-                const semiMajorAxis = targetPerigeeKm / (1 - targetEcc);
-                return {
-                    semiMajorAxis: semiMajorAxis,
-                    eccentricity: targetEcc,
-                    inclination: incRad,
-                    raan: raanRad,
-                    argOfPeriapsis: targetArgOfPeriapsisRad,
-                    trueAnomaly: c,
-                    epoch: svInitial.epoch,
-                };
-            }
-
-            xm = 0.5 * (a + b);
-            tol1 = tolerance * Math.abs(c) + 1e-10;
-            min1 = Math.abs(c - a);
-            min2 = Math.abs(b - c);
-
-            if (min1 < tol1 || min2 < tol1) {
-                // Found minimum
-                const semiMajorAxis = targetPerigeeKm / (1 - targetEcc);
-                return {
-                    semiMajorAxis: semiMajorAxis,
-                    eccentricity: targetEcc,
-                    inclination: incRad,
-                    raan: raanRad,
-                    argOfPeriapsis: targetArgOfPeriapsisRad,
-                    trueAnomaly: c,
-                    epoch: svInitial.epoch,
-                };
-            }
-
-            // Construct a trial parabolic fit
-            if (Math.abs(e) >= tol1) {
-                r1 = (c - a) * (fb - fc);
-                q = (c - b) * (fa - fc);
-                p = (c - b) * q - (c - a) * r1;
-                q = 2.0 * (q - r1);
-                if (q > 0.0) p = -p;
-                q = Math.abs(q);
-                min1 = 3.0 * q * Math.abs(xm);
-                min2 = Math.abs(e * q);
-                if (2.0 * p < (min1 < min2 ? min1 : min2)) {
-                    e = d;
-                    d = p / q;
-                } else {
-                    d = xm;
-                    e = d;
-                }
-            } else {
-                d = xm;
-                e = d;
-            }
-
-            a = b;
-            fa = fb;
-            if (Math.abs(d) > tol1) {
-                b += d;
-            } else {
-                b += (xm >= 0 ? Math.abs(tol1) : -Math.abs(tol1));
-            }
-            fb = objectiveFunction(b);
-            if ((fb <= fc && c > b) || (fb >= fc && c < b)) {
-                c = a;
-                fc = fa;
-                a = b;
-                fa = fb;
-                b = c;
-                fb = fc;
-            }
-        }
-
-        throw new Error("Did not converge within maximum iterations");
-    }
-
-    /**
-     * Convert orbital elements to state vector
-     * @param {Object} elements - Orbital elements
-     * @return {Object} State vector {position, velocity}
-     */
-    static elementsToStateVector(elements) {
-        const {semiMajorAxis, eccentricity, inclination,
-            raan, argOfPeriapsis, trueAnomaly} = elements;
-        const mu = EARTH_MU_KM;
-
-        // Calculate radius
-        const rMag = semiMajorAxis * (1 - eccentricity * eccentricity)
-            / (1 + eccentricity * Math.cos(trueAnomaly));
-
-        // Position in orbital plane
-        const rOrbital = [
-            rMag * Math.cos(trueAnomaly),
-            rMag * Math.sin(trueAnomaly),
-            0,
-        ];
-
-        // Velocity in orbital plane
-        const h = Math.sqrt(mu * semiMajorAxis * (1 - eccentricity * eccentricity));
-        const vOrbital = [
-            -mu / h * Math.sin(trueAnomaly),
-            mu / h * (eccentricity + Math.cos(trueAnomaly)),
-            0,
-        ];
-
-        // Rotation matrices
-        const cosW = Math.cos(argOfPeriapsis);
-        const sinW = Math.sin(argOfPeriapsis);
-        const cosO = Math.cos(raan);
-        const sinO = Math.sin(raan);
-        const cosI = Math.cos(inclination);
-        const sinI = Math.sin(inclination);
-
-        // Transform to inertial frame
-        const r = [
-            rOrbital[0] * (cosW * cosO - sinW * cosI * sinO)
-                - rOrbital[1] * (sinW * cosO + cosW * cosI * sinO),
-            rOrbital[0] * (cosW * sinO + sinW * cosI * cosO) + rOrbital[1]
-                * (cosW * cosI * cosO - sinW * sinO),
-            rOrbital[0] * (sinW * sinI) + rOrbital[1] * (cosW * sinI),
-        ];
-
-        const v = [
-            vOrbital[0] * (cosW * cosO - sinW * cosI * sinO)
-                - vOrbital[1] * (sinW * cosO + cosW * cosI * sinO),
-            vOrbital[0] * (cosW * sinO + sinW * cosI * cosO)
-                + vOrbital[1] * (cosW * cosI * cosO - sinW * sinO),
-            vOrbital[0] * (sinW * sinI) + vOrbital[1] * (cosW * sinI),
-        ];
-
-        return {position: r, velocity: v};
-    }
-
-    /**
-     * Convert state vector (position, velocity) to classical orbital elements
-     * @param {Array} r - Position vector [x, y, z] in km
-     * @param {Array} v - Velocity vector [vx, vy, vz] in km/s
-     * @param {number} mu - Standard gravitational parameter (default: Earth)
-     * @return {Object} Orbital elements
-     */
-    static stateVectorToElements(r, v, mu = EARTH_MU_KM) {
-        const tol = 1e-9;
-
-        if (mu < 1e-30) {
-            throw new Error("Mu must be greater than 1e-30.");
-        }
-
-        // Helper functions
-        function cross(a, b) {
-            return [
-                a[1] * b[2] - a[2] * b[1],
-                a[2] * b[0] - a[0] * b[2],
-                a[0] * b[1] - a[1] * b[0],
-            ];
-        }
-
-        function dot(a, b) {
-            return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-        }
-
-        function norm(v) {
-            return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-        }
-
-        function clamp(value, min, max) {
-            return Math.min(Math.max(value, min), max);
-        }
-
-        // Calculate basic vectors
-        const h = cross(r, v);
-        const n = cross([0, 0, 1], h);
-
-        const rLength = norm(r);
-        const vLength = norm(v);
-
-        if (rLength === 0) throw new Error("Position vector must not be zero.");
-        if (vLength === 0) throw new Error("Velocity vector must not be zero.");
-
-        // Eccentricity vector calculation (corrected formula)
-        const vLengthSq = vLength * vLength;
-        const muOverR = mu / rLength;
-        const rvDot = dot(r, v);
-
-        const e = [
-            (1 / mu) * ((vLengthSq - muOverR) * r[0] - rvDot * v[0]),
-            (1 / mu) * ((vLengthSq - muOverR) * r[1] - rvDot * v[1]),
-            (1 / mu) * ((vLengthSq - muOverR) * r[2] - rvDot * v[2]),
-        ];
-
-        const zeta = 0.5 * vLengthSq - muOverR;
-
-        if (zeta === 0) throw new Error("Zeta cannot be zero.");
-
-        const eLength = norm(e);
-        if (Math.abs(1.0 - eLength) <= tol) {
-            throw new Error("Parabolic orbit conversion is not supported.");
-        }
-
-        const a = -mu / (zeta * 2);
-
-        if (Math.abs(a * (1 - eLength)) < 1e-3) {
-            throw new Error("The state results in a singular conic section "
-                + "with radius of periapsis less than 1 m.");
-        }
-
-        const hLength = norm(h);
-        if (hLength === 0) {
-            throw new Error(`Cannot convert from Cartesian to Keplerian 
-                - angular momentum is zero.`);
-        }
-
-        const i = Math.acos(h[2] / hLength);
-
-        if (i >= Math.PI - tol) {
-            throw new Error("Cannot convert orbit with inclination of 180 degrees.");
-        }
-
-        let raan = 0;
-        let w = 0;
-        let f = 0;
-
-        const nLength = norm(n);
-
-        // CASE 1: Non-circular, Inclined Orbit
-        if (eLength >= 1e-11 && i >= 1e-11 && i <= Math.PI - 1e-11) {
-            if (nLength === 0.0) {
-                throw new Error("Cannot convert from Cartesian to Keplerian "
-                    + "- line-of-nodes vector is a zero vector.");
-            }
-
-            raan = Math.acos(n[0] / nLength);
-            if (n[1] < 0) raan = 2 * Math.PI - raan;
-
-            w = Math.acos(dot(n, e) / (nLength * eLength));
-            if (e[2] < 0) w = 2 * Math.PI - w;
-
-            f = Math.acos(clamp(dot(e, r) / (eLength * rLength), -1, 1));
-            if (rvDot < 0) f = 2 * Math.PI - f;
-        } else if (eLength >= 1e-11 && (i < 1e-11 || i > Math.PI - 1e-11)) { // CASE 2: Non-circular, Equatorial Orbit
-            if (eLength === 0.0) {
-                throw new Error(`Cannot convert from Cartesian to Keplerian 
-                    - eccentricity is zero.`);
-            }
-            raan = 0;
-            w = Math.acos(e[0] / eLength);
-            if (e[1] < 0) w = 2 * Math.PI - w;
-
-            // For GMT-4446 fix (LOJ: 2014.03.21)
-            if (i > Math.PI - 1e-11) w *= -1.0;
-            if (w < 0.0) w += 2 * Math.PI;
-
-            f = Math.acos(clamp(dot(e, r) / (eLength * rLength), -1, 1));
-            if (rvDot < 0) f = 2 * Math.PI - f;
-        } else if (eLength < 1e-11 && i >= 1e-11 && i <= Math.PI - 1e-11) { // CASE 3: Circular, Inclined Orbit
-            if (nLength === 0.0) {
-                throw new Error("Cannot convert from Cartesian to Keplerian "
-                   + "- line-of-nodes vector is a zero vector.");
-            }
-            raan = Math.acos(n[0] / nLength);
-            if (n[1] < 0) raan = 2 * Math.PI - raan;
-
-            w = 0;
-
-            f = Math.acos(clamp(dot(n, r) / (nLength * rLength), -1, 1));
-            if (r[2] < 0) f = 2 * Math.PI - f;
-        } else if (eLength < 1e-11 && (i < 1e-11 || i > Math.PI - 1e-11)) { // CASE 4: Circular, Equatorial Orbit
-            raan = 0;
-            w = 0;
-            f = Math.acos(clamp(r[0] / rLength, -1, 1));
-            if (r[1] < 0) f = 2 * Math.PI - f;
-
-            // For GMT-4446 fix (LOJ: 2014.03.21)
-            if (i > Math.PI - 1e-11) f *= -1.0;
-            if (f < 0.0) f += 2 * Math.PI;
-        }
-
-        // Calculate additional orbital parameters
-        const period = 2 * Math.PI * Math.sqrt(Math.pow(Math.abs(a), 3) / mu);
-        const meanMotion = 2 * Math.PI / period;
-
-        // Convert true anomaly to mean anomaly properly
-        const eccentricAnomaly = this.trueAnomalyToEccentricAnomaly(f, eLength);
-        const meanAnomaly = this.eccentricAnomalyToMeanAnomaly(eccentricAnomaly, eLength);
-
-        return {
-            semiMajorAxis: a, // km
-            eccentricity: eLength, // dimensionless
-            inclination: i, // radians
-            raan: raan, // radians (Right Ascension of Ascending Node)
-            argOfPeriapsis: w, // radians (Argument of Periapsis)
-            trueAnomaly: f, // radians
-            meanAnomaly: meanAnomaly, // radians (simplified)
-            period: period, // seconds
-            meanMotion: meanMotion, // rad/s
-        };
-    }
-
-    /**
-     * Convert true anomaly to eccentric anomaly
-     * @param {number} nu - true anomaly
-     * @param {number} e - eccentricity
-     * @return {number} Eccentric Anomaly
-     */
-    static trueAnomalyToEccentricAnomaly(nu, e) {
-        const cosE = (e + Math.cos(nu)) / (1 + e * Math.cos(nu));
-        const sinE = Math.sqrt(1 - e * e) * Math.sin(nu) / (1 + e * Math.cos(nu));
-        return Math.atan2(sinE, cosE);
-    }
-
-    /**
-     * Convert eccentric anomaly to mean anomaly
-     * @param {number} E - Eccentric anomaly
-     * @param {number} e - eccentricity
-     * @return {number} Mean Anomaly
-     */
-    static eccentricAnomalyToMeanAnomaly(E, e) {
-        return E - e * Math.sin(E);
-    }
-
-    /**
-     * Convert mean anomaly to eccentric anomaly (Kepler's equation)
-     * @param {number} M - Mean anomaly
-     * @param {number} e - eccentricity
-     * @param {number} tolerance - numerical tolerance
-     * @return {number} Eccentric Anomaly
-     */
-    static meanAnomalyToEccentricAnomaly(M, e, tolerance = 1e-8) {
-        let E = M;
-        let delta = 1;
-        while (Math.abs(delta) > tolerance) {
-            delta = (M - E + e * Math.sin(E)) / (1 - e * Math.cos(E));
-            E += delta;
-        }
-        return E;
-    }
-
-    /**
-     * Convert eccentric anomaly to true anomaly
-     * @param {number} E - Eccentric anomaly
-     * @param {number} e - eccentricity
-     * @return {number} true anomaly
-     */
-    static eccentricAnomalyToTrueAnomaly(E, e) {
-        const cosNu = (Math.cos(E) - e) / (1 - e * Math.cos(E));
-        const sinNu = Math.sqrt(1 - e * e) * Math.sin(E) / (1 - e * Math.cos(E));
-        return Math.atan2(sinNu, cosNu);
-    }
-}
-
-export {OrbitUtils};
+import {MU} from "./constants.js";
+import {cross, norm} from "mathjs";
+import {wrapHalfRevUnsigned, wrapOneRevUnsigned} from "./utils.js";
+
+const EARTH_MU_KM = MU / 1e9;
+
+class OrbitUtils {
+    constructor() {
+        // Prevent instantiation
+    }
+    /**
+     * Get inclination based on azimuth and latitude.
+     * @param {number} azimuthRad - Azimuth in radians
+     * @param {number} latitudeRad - Latitude in radians
+     * @return {number} Inclination in radians
+     */
+    static getInclination(azimuthRad, latitudeRad) {
+        const inclination = Math.acos(Math.cos(latitudeRad) * Math.sin(azimuthRad));
+        return wrapHalfRevUnsigned(inclination);
+    }
+
+    /**
+     * Get the azimuth based on inclination and latitude.
+     * Two results will be possible, based on whether you are Ascending from South to North or Descending from North to South.
+     * @param {number} inclinationRad - Inclination in radians
+     * @param {number} latitudeRad - Latitude in radians
+     * @param {boolean} ascending - Ascending (true) or descending (false)
+     * @return {number} Azimuth in radians
+     */
+    static getAzimuth(inclinationRad, latitudeRad, ascending = true) {
+        const azimuth = Math.asin(Math.cos(inclinationRad) / Math.cos(latitudeRad));
+        if (!ascending) {
+            return wrapOneRevUnsigned(Math.PI - azimuth);
+        }
+        return wrapOneRevUnsigned(azimuth);
+    }
+
+    /**
+     * Calculate the specific angular momentum (h) vector of an orbit.
+     * @param {Array} r - Position vector [x, y, z]
+     * @param {Array} v - Velocity vector [vx, vy, vz]
+     * @return {Array} Angular momentum vector
+     */
+    static getAngularMomentum(r, v) {
+        return cross(r, v);
+    }
+
+    /**
+     * Get mean motion (rad/sec).
+     * @param {number} a - Semi Major Axis (km)
+     * @param {number} mu - Standard gravitational parameter (km^3/s^2)
+     * @return {number} Mean motion in rad/sec
+     */
+    static getMeanMotion(a, mu = EARTH_MU_KM) {
+        return Math.sqrt(mu / Math.pow(a, 3));
+    }
+
+    /**
+     * Get the period of an orbit in seconds.
+     * @param {number} a - Semi Major Axis (km)
+     * @param {number} mu - Standard gravitational parameter (km^3/s^2)
+     * @return {number} Period in seconds
+     */
+    static getPeriod(a, mu = EARTH_MU_KM) {
+        if (a <= 0) return null;
+        return 2 * Math.PI * Math.sqrt(Math.pow(a, 3) / mu);
+    }
+
+    /**
+     * Transform an orbit to elliptical with target parameters using Brent's method.
+     * Accurate port of the C# TransformElliptical method.
+     * @param {Object} svInitial - Initial state vector {position: [x,y,z], velocity: [vx,vy,vz], epoch: Date}
+     * @param {number} incRad - Inclination in radians
+     * @param {number} raanRad - RAAN in radians
+     * @param {number} targetEcc - Target eccentricity
+     * @param {number} targetArgOfPeriapsisRad - Target argument of periapsis in radians
+     * @param {number} targetPerigeeKm - Target perigee in km
+     * @return {Object} Satellite object with new orbital elements
+     */
+    static transformElliptical(svInitial, incRad, raanRad,
+        targetEcc, targetArgOfPeriapsisRad, targetPerigeeKm) {
+        // Normalize the position vector
+        const rNorm = norm(svInitial.position);
+        const r = svInitial.position.map((x) => x / rNorm);
+
+        // Project the position vector onto the orbital plane
+        const projectedX = r[0] * Math.cos(raanRad) + r[1] * Math.sin(raanRad);
+        const projectedY = r[1] * Math.cos(raanRad) - r[0] * Math.sin(raanRad);
+
+        // Calculate the initial true anomaly using the projected coordinates and known argument of periapsis
+        let nu0 = Math.atan2(projectedY, projectedX) - targetArgOfPeriapsisRad;
+        nu0 = (nu0 + 2 * Math.PI) % (2 * Math.PI);
+
+        // Define the objective function that we want to minimize
+        const objectiveFunction = (nu) => {
+            nu = (nu + 2 * Math.PI) % (2 * Math.PI);
+
+            // Create orbital elements with the trial true anomaly
+            const semiMajorAxis = targetPerigeeKm / (1 - targetEcc);
+            const elements = {
+                semiMajorAxis: semiMajorAxis,
+                eccentricity: targetEcc,
+                inclination: incRad,
+                raan: raanRad,
+                argOfPeriapsis: targetArgOfPeriapsisRad,
+                trueAnomaly: nu,
+                epoch: svInitial.epoch,
+            };
+
+            // Convert elements to state vector
+            const trialState = this.elementsToStateVector(elements);
+
+            // Normalize the trial position vector
+            const trialRNorm = norm(trialState.position);
+            const trialR = trialState.position.map((x) => x / trialRNorm);
+
+            // Scale trial position to match initial position magnitude
+            const pScaled = trialR.map((x) => x * rNorm);
+
+            // Return the distance between initial and trial positions
+            return norm(svInitial.position.map((x, i) => x - pScaled[i]));
+        };
+
+        // Use Brent's method for minimization
+        const tolerance = 1e-6; // radians
+        const maxIterations = 1000;
+
+        // Initial bracket around the solution
+        let a = nu0 - Math.PI;
+        let b = nu0 + Math.PI;
+        let c = nu0;
+
+        let fa = objectiveFunction(a);
+        let fb = objectiveFunction(b);
+        let fc = objectiveFunction(c);
+
+        let d = 0; let e = 0; let min1; let min2;
+        let p; let q; let r1; let tol1; let xm;
+
+        for (let iter = 0; iter < maxIterations; iter++) {
+            if (Math.abs(b - a) < tolerance) {
+                // Found minimum
+                const semiMajorAxis = targetPerigeeKm / (1 - targetEcc);
+                return {
+                    semiMajorAxis: semiMajorAxis,
+                    eccentricity: targetEcc,
+                    inclination: incRad,
+                    raan: raanRad,
+                    argOfPeriapsis: targetArgOfPeriapsisRad,
+                    trueAnomaly: c,
+                    epoch: svInitial.epoch,
+                };
+            }
+
+            xm = 0.5 * (a + b);
+            tol1 = tolerance * Math.abs(c) + 1e-10;
+            min1 = Math.abs(c - a);
+            min2 = Math.abs(b - c);
+
+            if (min1 < tol1 || min2 < tol1) {
+                // Found minimum
+                const semiMajorAxis = targetPerigeeKm / (1 - targetEcc);
+                return {
+                    semiMajorAxis: semiMajorAxis,
+                    eccentricity: targetEcc,
+                    inclination: incRad,
+                    raan: raanRad,
+                    argOfPeriapsis: targetArgOfPeriapsisRad,
+                    trueAnomaly: c,
+                    epoch: svInitial.epoch,
+                };
+            }
+
+            // Construct a trial parabolic fit
+            if (Math.abs(e) >= tol1) {
+                r1 = (c - a) * (fb - fc);
+                q = (c - b) * (fa - fc);
+                p = (c - b) * q - (c - a) * r1;
+                q = 2.0 * (q - r1);
+                if (q > 0.0) p = -p;
+                q = Math.abs(q);
+                min1 = 3.0 * q * Math.abs(xm);
+                min2 = Math.abs(e * q);
+                if (2.0 * p < (min1 < min2 ? min1 : min2)) {
+                    e = d;
+                    d = p / q;
+                } else {
+                    d = xm;
+                    e = d;
+                }
+            } else {
+                d = xm;
+                e = d;
+            }
+
+            a = b;
+            fa = fb;
+            if (Math.abs(d) > tol1) {
+                b += d;
+            } else {
+                b += (xm >= 0 ? Math.abs(tol1) : -Math.abs(tol1));
+            }
+            fb = objectiveFunction(b);
+            if ((fb <= fc && c > b) || (fb >= fc && c < b)) {
+                c = a;
+                fc = fa;
+                a = b;
+                fa = fb;
+                b = c;
+                fb = fc;
+            }
+        }
+
+        throw new Error("Did not converge within maximum iterations");
+    }
+
+    /**
+     * Convert orbital elements to state vector
+     * @param {Object} elements - Orbital elements
+     * @return {Object} State vector {position, velocity}
+     */
+    static elementsToStateVector(elements) {
+        const {semiMajorAxis, eccentricity, inclination,
+            raan, argOfPeriapsis, trueAnomaly} = elements;
+        const mu = EARTH_MU_KM;
+
+        // Calculate radius
+        const rMag = semiMajorAxis * (1 - eccentricity * eccentricity)
+            / (1 + eccentricity * Math.cos(trueAnomaly));
+
+        // Position in orbital plane
+        const rOrbital = [
+            rMag * Math.cos(trueAnomaly),
+            rMag * Math.sin(trueAnomaly),
+            0,
+        ];
+
+        // Velocity in orbital plane
+        const h = Math.sqrt(mu * semiMajorAxis * (1 - eccentricity * eccentricity));
+        const vOrbital = [
+            -mu / h * Math.sin(trueAnomaly),
+            mu / h * (eccentricity + Math.cos(trueAnomaly)),
+            0,
+        ];
+
+        // Rotation matrices
+        const cosW = Math.cos(argOfPeriapsis);
+        const sinW = Math.sin(argOfPeriapsis);
+        const cosO = Math.cos(raan);
+        const sinO = Math.sin(raan);
+        const cosI = Math.cos(inclination);
+        const sinI = Math.sin(inclination);
+
+        // Transform to inertial frame
+        const r = [
+            rOrbital[0] * (cosW * cosO - sinW * cosI * sinO)
+                - rOrbital[1] * (sinW * cosO + cosW * cosI * sinO),
+            rOrbital[0] * (cosW * sinO + sinW * cosI * cosO) + rOrbital[1]
+                * (cosW * cosI * cosO - sinW * sinO),
+            rOrbital[0] * (sinW * sinI) + rOrbital[1] * (cosW * sinI),
+        ];
+
+        const v = [
+            vOrbital[0] * (cosW * cosO - sinW * cosI * sinO)
+                - vOrbital[1] * (sinW * cosO + cosW * cosI * sinO),
+            vOrbital[0] * (cosW * sinO + sinW * cosI * cosO)
+                + vOrbital[1] * (cosW * cosI * cosO - sinW * sinO),
+            vOrbital[0] * (sinW * sinI) + vOrbital[1] * (cosW * sinI),
+        ];
+
+        return {position: r, velocity: v};
+    }
+
+    /**
+     * Convert state vector (position, velocity) to classical orbital elements
+     * @param {Array} r - Position vector [x, y, z] in km
+     * @param {Array} v - Velocity vector [vx, vy, vz] in km/s
+     * @param {number} mu - Standard gravitational parameter (default: Earth)
+     * @return {Object} Orbital elements
+     */
+    static stateVectorToElements(r, v, mu = EARTH_MU_KM) {
+        const tol = 1e-9;
+
+        if (mu < 1e-30) {
+            throw new Error("Mu must be greater than 1e-30.");
+        }
+
+        // Helper functions
+        function cross(a, b) {
+            return [
+                a[1] * b[2] - a[2] * b[1],
+                a[2] * b[0] - a[0] * b[2],
+                a[0] * b[1] - a[1] * b[0],
+            ];
+        }
+
+        function dot(a, b) {
+            return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+        }
+
+        function norm(v) {
+            return Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+        }
+
+        function clamp(value, min, max) {
+            return Math.min(Math.max(value, min), max);
+        }
+
+        // Calculate basic vectors
+        const h = cross(r, v);
+        const n = cross([0, 0, 1], h);
+
+        const rLength = norm(r);
+        const vLength = norm(v);
+
+        if (rLength === 0) throw new Error("Position vector must not be zero.");
+        if (vLength === 0) throw new Error("Velocity vector must not be zero.");
+
+        // Eccentricity vector calculation (corrected formula)
+        const vLengthSq = vLength * vLength;
+        const muOverR = mu / rLength;
+        const rvDot = dot(r, v);
+
+        const e = [
+            (1 / mu) * ((vLengthSq - muOverR) * r[0] - rvDot * v[0]),
+            (1 / mu) * ((vLengthSq - muOverR) * r[1] - rvDot * v[1]),
+            (1 / mu) * ((vLengthSq - muOverR) * r[2] - rvDot * v[2]),
+        ];
+
+        const zeta = 0.5 * vLengthSq - muOverR;
+
+        if (zeta === 0) throw new Error("Zeta cannot be zero.");
+
+        const eLength = norm(e);
+        if (Math.abs(1.0 - eLength) <= tol) {
+            throw new Error("Parabolic orbit conversion is not supported.");
+        }
+
+        const a = -mu / (zeta * 2);
+
+        if (Math.abs(a * (1 - eLength)) < 1e-3) {
+            throw new Error("The state results in a singular conic section "
+                + "with radius of periapsis less than 1 m.");
+        }
+
+        const hLength = norm(h);
+        if (hLength === 0) {
+            throw new Error(`Cannot convert from Cartesian to Keplerian 
+                - angular momentum is zero.`);
+        }
+
+        const i = Math.acos(h[2] / hLength);
+
+        if (i >= Math.PI - tol) {
+            throw new Error("Cannot convert orbit with inclination of 180 degrees.");
+        }
+
+        let raan = 0;
+        let w = 0;
+        let f = 0;
+
+        const nLength = norm(n);
+
+        // CASE 1: Non-circular, Inclined Orbit
+        if (eLength >= 1e-11 && i >= 1e-11 && i <= Math.PI - 1e-11) {
+            if (nLength === 0.0) {
+                throw new Error("Cannot convert from Cartesian to Keplerian "
+                    + "- line-of-nodes vector is a zero vector.");
+            }
+
+            raan = Math.acos(n[0] / nLength);
+            if (n[1] < 0) raan = 2 * Math.PI - raan;
+
+            w = Math.acos(dot(n, e) / (nLength * eLength));
+            if (e[2] < 0) w = 2 * Math.PI - w;
+
+            f = Math.acos(clamp(dot(e, r) / (eLength * rLength), -1, 1));
+            if (rvDot < 0) f = 2 * Math.PI - f;
+        } else if (eLength >= 1e-11 && (i < 1e-11 || i > Math.PI - 1e-11)) { // CASE 2: Non-circular, Equatorial Orbit
+            if (eLength === 0.0) {
+                throw new Error(`Cannot convert from Cartesian to Keplerian 
+                    - eccentricity is zero.`);
+            }
+            raan = 0;
+            w = Math.acos(e[0] / eLength);
+            if (e[1] < 0) w = 2 * Math.PI - w;
+
+            // For GMT-4446 fix (LOJ: 2014.03.21)
+            if (i > Math.PI - 1e-11) w *= -1.0;
+            if (w < 0.0) w += 2 * Math.PI;
+
+            f = Math.acos(clamp(dot(e, r) / (eLength * rLength), -1, 1));
+            if (rvDot < 0) f = 2 * Math.PI - f;
+        } else if (eLength < 1e-11 && i >= 1e-11 && i <= Math.PI - 1e-11) { // CASE 3: Circular, Inclined Orbit
+            if (nLength === 0.0) {
+                throw new Error("Cannot convert from Cartesian to Keplerian "
+                   + "- line-of-nodes vector is a zero vector.");
+            }
+            raan = Math.acos(n[0] / nLength);
+            if (n[1] < 0) raan = 2 * Math.PI - raan;
+
+            w = 0;
+
+            f = Math.acos(clamp(dot(n, r) / (nLength * rLength), -1, 1));
+            if (r[2] < 0) f = 2 * Math.PI - f;
+        } else if (eLength < 1e-11 && (i < 1e-11 || i > Math.PI - 1e-11)) { // CASE 4: Circular, Equatorial Orbit
+            raan = 0;
+            w = 0;
+            f = Math.acos(clamp(r[0] / rLength, -1, 1));
+            if (r[1] < 0) f = 2 * Math.PI - f;
+
+            // For GMT-4446 fix (LOJ: 2014.03.21)
+            if (i > Math.PI - 1e-11) f *= -1.0;
+            if (f < 0.0) f += 2 * Math.PI;
+        }
+
+        // Calculate additional orbital parameters
+        const period = 2 * Math.PI * Math.sqrt(Math.pow(Math.abs(a), 3) / mu);
+        const meanMotion = 2 * Math.PI / period;
+
+        // Convert true anomaly to mean anomaly properly
+        const eccentricAnomaly = this.trueAnomalyToEccentricAnomaly(f, eLength);
+        const meanAnomaly = this.eccentricAnomalyToMeanAnomaly(eccentricAnomaly, eLength);
+
+        return {
+            semiMajorAxis: a, // km
+            eccentricity: eLength, // dimensionless
+            inclination: i, // radians
+            raan: raan, // radians (Right Ascension of Ascending Node)
+            argOfPeriapsis: w, // radians (Argument of Periapsis)
+            trueAnomaly: f, // radians
+            meanAnomaly: meanAnomaly, // radians (simplified)
+            period: period, // seconds
+            meanMotion: meanMotion, // rad/s
+        };
+    }
+
+    /**
+     * Convert true anomaly to eccentric anomaly
+     * @param {number} nu - true anomaly
+     * @param {number} e - eccentricity
+     * @return {number} Eccentric Anomaly
+     */
+    static trueAnomalyToEccentricAnomaly(nu, e) {
+        const cosE = (e + Math.cos(nu)) / (1 + e * Math.cos(nu));
+        const sinE = Math.sqrt(1 - e * e) * Math.sin(nu) / (1 + e * Math.cos(nu));
+        return Math.atan2(sinE, cosE);
+    }
+
+    /**
+     * Convert eccentric anomaly to mean anomaly
+     * @param {number} E - Eccentric anomaly
+     * @param {number} e - eccentricity
+     * @return {number} Mean Anomaly
+     */
+    static eccentricAnomalyToMeanAnomaly(E, e) {
+        return E - e * Math.sin(E);
+    }
+
+    /**
+     * Convert mean anomaly to eccentric anomaly (Kepler's equation)
+     * @param {number} M - Mean anomaly
+     * @param {number} e - eccentricity
+     * @param {number} tolerance - numerical tolerance
+     * @return {number} Eccentric Anomaly
+     */
+    static meanAnomalyToEccentricAnomaly(M, e, tolerance = 1e-8) {
+        let E = M;
+        let delta = 1;
+        while (Math.abs(delta) > tolerance) {
+            delta = (M - E + e * Math.sin(E)) / (1 - e * Math.cos(E));
+            E += delta;
+        }
+        return E;
+    }
+
+    /**
+     * Convert eccentric anomaly to true anomaly
+     * @param {number} E - Eccentric anomaly
+     * @param {number} e - eccentricity
+     * @return {number} true anomaly
+     */
+    static eccentricAnomalyToTrueAnomaly(E, e) {
+        const cosNu = (Math.cos(E) - e) / (1 - e * Math.cos(E));
+        const sinNu = Math.sqrt(1 - e * e) * Math.sin(E) / (1 - e * Math.cos(E));
+        return Math.atan2(sinNu, cosNu);
+    }
+}
+
+export {OrbitUtils};