OrbitalElements | DME Component Libraries for Java 2024 r2

java.lang.Object
- agi.foundation.coordinates.OrbitalElements

```
public final class OrbitalElements
extends Object
```
Provides functions which can be used to perform calculations and conversions relating orbital elements.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static double`	`computeEccentricity(double radiusOfPeriapsis, double inverseSemimajorAxis)` Calculates the eccentricity of the orbit.
`static double`	`computeMeanMotion(double radiusOfPeriapsis, double eccentricity, double gravitationalParameter)` Calculates the mean motion of the orbit.
`static double`	`computePeriod(double inverseSemimajorAxis, double gravitationalParameter)` Calculates the period of the orbit.
`static double`	`computeRadiusOfApoapsis(double radiusOfPeriapsis, double eccentricity)` Calculates the radius of apoapsis of the orbit.
`static double`	`computeRadiusOfPeriapsis(double semilatusRectum, double eccentricity)` Calculates the radius of periapsis of the orbit.
`static double`	`computeSemilatusRectum(double radiusOfPeriapsis, double eccentricity)` Calculates the semilatus rectum of the orbit.
`static double`	`computeSemimajorAxis(double radiusOfPeriapsis, double eccentricity)` Calculates the semimajor axis of the orbit.
`static double`	`computeTimeOfFlight(double initialTrueAnomaly, double finalTrueAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter)` Calculates the time of flight between two true anomalies.
`static double`	`convertEccentricAnomalyToMeanAnomaly(double eccentricAnomaly, double eccentricity)` Tries to convert the eccentric anomaly to the mean anomaly.
`static double`	`convertEccentricAnomalyToTimeFromPeriapsis(double eccentricAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter)` Converts the eccentric anomaly to the time of flight from the corresponding periapsis passage in seconds.
`static double`	`convertEccentricAnomalyToTrueAnomaly(double eccentricAnomaly, double eccentricity)` Converts the eccentric anomaly to the true anomaly.
`static double`	`convertHyperbolicAnomalyToMeanAnomaly(double hyperbolicAnomaly, double eccentricity)` Converts the hyperbolic anomaly to the mean anomaly.
`static double`	`convertHyperbolicAnomalyToTimeFromPeriapsis(double hyperbolicAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter)` Converts the hyperbolic anomaly to the time of flight from the corresponding periapsis passage in seconds.
`static double`	`convertHyperbolicAnomalyToTrueAnomaly(double hyperbolicAnomaly, double eccentricity)` Converts the hyperbolic anomaly to the true anomaly.
`static double`	`convertMeanAnomalyToEccentricAnomaly(double meanAnomaly, double eccentricity)` Converts the mean anomaly to the eccentric anomaly.
`static double`	`convertMeanAnomalyToHyperbolicAnomaly(double meanAnomaly, double eccentricity)` Tries to convert the mean anomaly to the hyperbolic anomaly.
`static double`	`convertMeanAnomalyToParabolicAnomaly(double meanAnomaly, double eccentricity)` Converts the mean anomaly to the parabolic anomaly.
`static double`	`convertMeanAnomalyToTimeFromPeriapsis(double meanAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter)` Converts the mean anomaly to the time of flight from the corresponding periapsis passage in seconds.
`static double`	`convertMeanAnomalyToTimeSincePreviousPeriapsis(double meanAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter)` Converts the mean anomaly to the time of flight since the previous periapsis passage in seconds.
`static double`	`convertMeanAnomalyToTimeUntilNextPeriapsis(double meanAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter)` Converts the mean anomaly to the time of flight until the next periapsis passage in seconds.
`static double`	`convertMeanAnomalyToTrueAnomaly(double meanAnomaly, double eccentricity)` Converts the mean anomaly to the true anomaly.
`static double`	`convertParabolicAnomalyToMeanAnomaly(double parabolicAnomaly, double eccentricity)` Converts the parabolic anomaly to the mean anomaly.
`static double`	`convertParabolicAnomalyToTimeFromPeriapsis(double parabolicAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter)` Converts the parabolic anomaly to the time of flight from the corresponding periapsis passage in seconds.
`static double`	`convertParabolicAnomalyToTrueAnomaly(double parabolicAnomaly, double eccentricity)` Converts the parabolic anomaly to the true anomaly.
`static double`	`convertTimeFromPeriapsisToEccentricAnomaly(double timeFromPeriapsis, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter)` Converts the time from periapsis passage to eccentric anomaly.
`static double`	`convertTimeFromPeriapsisToHyperbolicAnomaly(double timeFromPeriapsis, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter)` Converts the time from periapsis passage to hyperbolic anomaly.
`static double`	`convertTimeFromPeriapsisToMeanAnomaly(double timeFromPeriapsis, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter)` Converts the time from periapsis passage to mean anomaly.
`static double`	`convertTimeFromPeriapsisToParabolicAnomaly(double timeFromPeriapsis, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter)` Converts the time from periapsis passage to parabolic anomaly.
`static double`	`convertTimeFromPeriapsisToTrueAnomaly(double timeFromPeriapsis, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter)` Converts the time from periapsis passage to true anomaly.
`static double`	`convertTrueAnomalyToEccentricAnomaly(double trueAnomaly, double eccentricity)` Converts the true anomaly to the eccentric anomaly.
`static double`	`convertTrueAnomalyToHyperbolicAnomaly(double trueAnomaly, double eccentricity)` Converts the true anomaly to the hyperbolic anomaly.
`static double`	`convertTrueAnomalyToMeanAnomaly(double trueAnomaly, double eccentricity)` Converts the true anomaly to the mean anomaly.
`static double`	`convertTrueAnomalyToParabolicAnomaly(double trueAnomaly, double eccentricity)` Converts the true anomaly to the parabolic anomaly.
`static double`	`convertTrueAnomalyToTimeFromPeriapsis(double trueAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter)` Converts the true anomaly to the time of flight from the corresponding periapsis passage in seconds.
`static double`	`convertTrueAnomalyToTimeSincePreviousPeriapsis(double trueAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter)` Converts the true anomaly to the time of flight since the previous periapsis passage in seconds.
`static double`	`convertTrueAnomalyToTimeUntilNextPeriapsis(double trueAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter)` Converts the true anomaly to the time of flight until the next periapsis passage in seconds.
`static Matrix3By3`	`perifocalToCartesianMatrix(double argumentOfPeriapsis, double inclination, double ascendingNodeRightAscension)` Calculates the transformation matrix from the perifocal axes to the inertial axes.
`static boolean`	`tryComputeEccentricity(double radiusOfPeriapsis, double inverseSemimajorAxis, double[] eccentricity)` Tries to calculate the eccentricity of the orbit.
`static boolean`	`tryComputeMeanMotion(double radiusOfPeriapsis, double eccentricity, double gravitationalParameter, double[] meanMotion)` Tries to calculate the mean motion of the orbit.
`static boolean`	`tryComputePeriod(double inverseSemimajorAxis, double gravitationalParameter, double[] period)` Tries to calculate the period of the orbit.
`static boolean`	`tryComputeRadiusOfApoapsis(double radiusOfPeriapsis, double eccentricity, double[] radiusOfApoapsis)` Tries to calculate the radius of apoapsis of the orbit.
`static boolean`	`tryComputeRadiusOfPeriapsis(double semilatusRectum, double eccentricity, double[] radiusOfPeriapsis)` Tries to calculate the radius of periapsis of the orbit.
`static boolean`	`tryComputeSemilatusRectum(double radiusOfPeriapsis, double eccentricity, double[] semilatusRectum)` Tries to calculate the semilatus rectum of the orbit.
`static boolean`	`tryComputeSemimajorAxis(double radiusOfPeriapsis, double eccentricity, double[] semimajorAxis)` Tries to calculate the semimajor axis of the orbit.
`static boolean`	`tryComputeTimeOfFlight(double initialTrueAnomaly, double finalTrueAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter, double[] timeOfFlight)` Tries to calculate the time of flight between two true anomalies.
`static boolean`	`tryConvertEccentricAnomalyToMeanAnomaly(double eccentricAnomaly, double eccentricity, double[] meanAnomaly)` Tries to convert the eccentric anomaly to the mean anomaly.
`static boolean`	`tryConvertEccentricAnomalyToTimeFromPeriapsis(double eccentricAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter, double[] timeFromPeriapsis)` Tries to convert the eccentric anomaly to the time of flight from the corresponding periapsis passage in seconds.
`static boolean`	`tryConvertEccentricAnomalyToTrueAnomaly(double eccentricAnomaly, double eccentricity, double[] trueAnomaly)` Tries to convert the eccentric anomaly to the true anomaly.
`static boolean`	`tryConvertHyperbolicAnomalyToMeanAnomaly(double hyperbolicAnomaly, double eccentricity, double[] meanAnomaly)` Tries to convert the hyperbolic anomaly to the mean anomaly.
`static boolean`	`tryConvertHyperbolicAnomalyToTimeFromPeriapsis(double hyperbolicAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter, double[] timeFromPeriapsis)` Tries to convert the hyperbolic anomaly to the time of flight from the corresponding periapsis passage in seconds.
`static boolean`	`tryConvertHyperbolicAnomalyToTrueAnomaly(double hyperbolicAnomaly, double eccentricity, double[] trueAnomaly)` Tries to convert the hyperbolic anomaly to the true anomaly.
`static boolean`	`tryConvertMeanAnomalyToEccentricAnomaly(double meanAnomaly, double eccentricity, double[] eccentricAnomaly)` Tries to convert the mean anomaly to the eccentric anomaly.
`static boolean`	`tryConvertMeanAnomalyToHyperbolicAnomaly(double meanAnomaly, double eccentricity, double[] hyperbolicAnomaly)` Tries to convert the mean anomaly to the hyperbolic anomaly.
`static boolean`	`tryConvertMeanAnomalyToParabolicAnomaly(double meanAnomaly, double eccentricity, double[] parabolicAnomaly)` Tries to convert the mean anomaly to the parabolic anomaly.
`static boolean`	`tryConvertMeanAnomalyToTimeFromPeriapsis(double meanAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter, double[] timeFromPeriapsis)` Tries to convert the mean anomaly to the time of flight from the corresponding periapsis passage in seconds.
`static boolean`	`tryConvertMeanAnomalyToTimeSincePreviousPeriapsis(double meanAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter, double[] timeSincePreviousPeriapsis)` Tries to convert the mean anomaly to the time of flight since the previous periapsis passage in seconds.
`static boolean`	`tryConvertMeanAnomalyToTimeUntilNextPeriapsis(double meanAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter, double[] timeUntilNextPeriapsis)` Tries to convert the mean anomaly to the time of flight until the next periapsis passage in seconds.
`static boolean`	`tryConvertMeanAnomalyToTrueAnomaly(double meanAnomaly, double eccentricity, double[] trueAnomaly)` Tries to convert the mean anomaly to the true anomaly.
`static boolean`	`tryConvertParabolicAnomalyToMeanAnomaly(double parabolicAnomaly, double eccentricity, double[] meanAnomaly)` Tries to convert the parabolic anomaly to the mean anomaly.
`static boolean`	`tryConvertParabolicAnomalyToTimeFromPeriapsis(double parabolicAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter, double[] timeFromPeriapsis)` Tries to convert the parabolic anomaly to the time of flight from the corresponding periapsis passage in seconds.
`static boolean`	`tryConvertParabolicAnomalyToTrueAnomaly(double parabolicAnomaly, double eccentricity, double[] trueAnomaly)` Tries to convert the parabolic anomaly to the true anomaly.
`static boolean`	`tryConvertTimeFromPeriapsisToEccentricAnomaly(double timeFromPeriapsis, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter, double[] eccentricAnomaly)` Tries to convert the time from periapsis passage to eccentric anomaly.
`static boolean`	`tryConvertTimeFromPeriapsisToHyperbolicAnomaly(double timeFromPeriapsis, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter, double[] hyperbolicAnomaly)` Tries to convert the time from periapsis passage to hyperbolic anomaly.
`static boolean`	`tryConvertTimeFromPeriapsisToMeanAnomaly(double timeFromPeriapsis, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter, double[] meanAnomaly)` Tries to convert the time from periapsis passage to mean anomaly.
`static boolean`	`tryConvertTimeFromPeriapsisToParabolicAnomaly(double timeFromPeriapsis, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter, double[] parabolicAnomaly)` Tries to convert the time from periapsis passage to parabolic anomaly.
`static boolean`	`tryConvertTimeFromPeriapsisToTrueAnomaly(double timeFromPeriapsis, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter, double[] trueAnomaly)` Tries to convert the time from periapsis passage to true anomaly.
`static boolean`	`tryConvertTrueAnomalyToEccentricAnomaly(double trueAnomaly, double eccentricity, double[] eccentricAnomaly)` Tries to convert the true anomaly to the eccentric anomaly.
`static boolean`	`tryConvertTrueAnomalyToHyperbolicAnomaly(double trueAnomaly, double eccentricity, double[] hyperbolicAnomaly)` Tries to convert the true anomaly to the hyperbolic anomaly.
`static boolean`	`tryConvertTrueAnomalyToMeanAnomaly(double trueAnomaly, double eccentricity, double[] meanAnomaly)` Tries to convert the true anomaly to the mean anomaly.
`static boolean`	`tryConvertTrueAnomalyToParabolicAnomaly(double trueAnomaly, double eccentricity, double[] parabolicAnomaly)` Tries to convert the true anomaly to the parabolic anomaly.
`static boolean`	`tryConvertTrueAnomalyToTimeFromPeriapsis(double trueAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter, double[] timeFromPeriapsis)` True to convert the true anomaly to the time of flight from the corresponding periapsis passage in seconds.
`static boolean`	`tryConvertTrueAnomalyToTimeSincePreviousPeriapsis(double trueAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter, double[] timeSincePreviousPeriapsis)` Tries to convert the true anomaly to the time of flight since the previous periapsis passage in seconds.
`static boolean`	`tryConvertTrueAnomalyToTimeUntilNextPeriapsis(double trueAnomaly, double radiusOfPeriapsis, double eccentricity, double gravitationalParameter, double[] timeUntilNextPeriapsis)` Tries to convert the true anomaly to the time of flight until the next periapsis passage in seconds.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - perifocalToCartesianMatrix
```
@Nonnull
public static Matrix3By3 perifocalToCartesianMatrix(double argumentOfPeriapsis,
                                                              double inclination,
                                                              double ascendingNodeRightAscension)
```
    Calculates the transformation matrix from the perifocal axes to the inertial axes.
    
    Parameters:
    
    argumentOfPeriapsis - The argument of periapsis (radians).
    
    inclination - The inclination (radians).
    
    ascendingNodeRightAscension - The right ascension of the ascending node (radians).
    
    Returns:
    
    The transformation matrix to convert from the perifocal coordinate system to inertial cartesian coordinates.
  - tryComputeEccentricity
```
public static boolean tryComputeEccentricity(double radiusOfPeriapsis,
                                             double inverseSemimajorAxis,
                                             @Nonnull
                                             double[] eccentricity)
```
    Tries to calculate the eccentricity of the orbit. radiusOfPeriapsis and inverseSemimajorAxis must have consistent units.
    
    Parameters:
    
    radiusOfPeriapsis - The radius of periapsis.
    
    inverseSemimajorAxis - The inverse of the semimajor axis.
    
    eccentricity - On input, an array with one element. On return, the array is populated with the eccentricity of the orbit.
    
    Returns:
    
    false if radiusOfPeriapsis is negative or zero; otherwise true.
  - computeEccentricity
```
public static double computeEccentricity(double radiusOfPeriapsis,
                                         double inverseSemimajorAxis)
```
    Calculates the eccentricity of the orbit. radiusOfPeriapsis and inverseSemimajorAxis must have consistent units.
    
    Parameters:
    
    radiusOfPeriapsis - The radius of periapsis.
    
    inverseSemimajorAxis - The inverse of the semimajor axis.
    
    Returns:
    
    The eccentricity of the orbit.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when radiusOfPeriapsis is negative or zero.
  - tryComputeSemilatusRectum
```
public static boolean tryComputeSemilatusRectum(double radiusOfPeriapsis,
                                                double eccentricity,
                                                @Nonnull
                                                double[] semilatusRectum)
```
    Tries to calculate the semilatus rectum of the orbit.
    The result will be given in the same units as radiusOfPeriapsis.
    
    Parameters:
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    semilatusRectum - On input, an array with one element. On return, the array is populated with the semilatus rectum of the orbit.
    
    Returns:
    
    false if eccentricity is negative or radiusOfPeriapsis is negative or zero; otherwise true.
  - computeSemilatusRectum
```
public static double computeSemilatusRectum(double radiusOfPeriapsis,
                                            double eccentricity)
```
    Calculates the semilatus rectum of the orbit.
    The result will be given in the same units as radiusOfPeriapsis.
    
    Parameters:
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    Returns:
    
    The semilatus rectum of the orbit.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is negative or radiusOfPeriapsis is negative or zero.
  - tryComputeSemimajorAxis
```
public static boolean tryComputeSemimajorAxis(double radiusOfPeriapsis,
                                              double eccentricity,
                                              @Nonnull
                                              double[] semimajorAxis)
```
    Tries to calculate the semimajor axis of the orbit.
    The result will be given in the same units as radiusOfPeriapsis.
    
    Parameters:
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    semimajorAxis - On input, an array with one element. On return, the array is populated with the semimajor axis of the orbit.
    
    Returns:
    
    false if eccentricity is negative or radiusOfPeriapsis is negative or zero; otherwise true.
  - computeSemimajorAxis
```
public static double computeSemimajorAxis(double radiusOfPeriapsis,
                                          double eccentricity)
```
    Calculates the semimajor axis of the orbit.
    The result will be given in the same units as radiusOfPeriapsis.
    
    Parameters:
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    Returns:
    
    The semimajor axis of the orbit.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is negative or radiusOfPeriapsis is negative or zero.
  - tryComputeRadiusOfPeriapsis
```
public static boolean tryComputeRadiusOfPeriapsis(double semilatusRectum,
                                                  double eccentricity,
                                                  @Nonnull
                                                  double[] radiusOfPeriapsis)
```
    Tries to calculate the radius of periapsis of the orbit.
    The result will be given in the same units as semilatusRectum.
    
    Parameters:
    
    semilatusRectum - The semilatus rectum of the orbit (distance).
    
    eccentricity - The eccentricity of the orbit.
    
    radiusOfPeriapsis - On input, an array with one element. On return, the array is populated with the radius of periapsis of the orbit.
    
    Returns:
    
    false if eccentricity is negative or semilatusRectum is negative or zero; otherwise true.
  - computeRadiusOfPeriapsis
```
public static double computeRadiusOfPeriapsis(double semilatusRectum,
                                              double eccentricity)
```
    Calculates the radius of periapsis of the orbit.
    The result will be given in the same units as semilatusRectum.
    
    Parameters:
    
    semilatusRectum - The semilatus rectum of the orbit (distance).
    
    eccentricity - The eccentricity of the orbit.
    
    Returns:
    
    The radius of periapsis of the orbit.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is negative or semilatusRectum is negative or zero.
  - tryComputeRadiusOfApoapsis
```
public static boolean tryComputeRadiusOfApoapsis(double radiusOfPeriapsis,
                                                 double eccentricity,
                                                 @Nonnull
                                                 double[] radiusOfApoapsis)
```
    Tries to calculate the radius of apoapsis of the orbit.
    The result will be given in the same units as radiusOfPeriapsis.
    
    Parameters:
    
    radiusOfPeriapsis - The radius of periapsis of the orbit (distance).
    
    eccentricity - The eccentricity of the orbit.
    
    radiusOfApoapsis - On input, an array with one element. On return, the array is populated with the radius of apoapsis of the orbit.
    
    Returns:
    
    false if eccentricity is negative or radiusOfPeriapsis is negative or zero; otherwise true.
  - computeRadiusOfApoapsis
```
public static double computeRadiusOfApoapsis(double radiusOfPeriapsis,
                                             double eccentricity)
```
    Calculates the radius of apoapsis of the orbit.
    The result will be given in the same units as radiusOfPeriapsis.
    
    Parameters:
    
    radiusOfPeriapsis - The radius of periapsis of the orbit (distance).
    
    eccentricity - The eccentricity of the orbit.
    
    Returns:
    
    The radius of apoapsis of the orbit.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is negative or radiusOfPeriapsis is negative or zero.
  - tryComputePeriod
```
public static boolean tryComputePeriod(double inverseSemimajorAxis,
                                       double gravitationalParameter,
                                       @Nonnull
                                       double[] period)
```
    Tries to calculate the period of the orbit.
    inverseSemimajorAxis and gravitationalParameter must have consistent units and the units of the resulting period will correspond with the units of the input parameters.
    
    Parameters:
    
    inverseSemimajorAxis - The inverse of the semimajor axis (distance).
    
    gravitationalParameter - The gravitational parameter (distance cubed per time squared).
    
    period - On input, an array with one element. On return, the array is populated with the period of the orbit.
    
    Returns:
    
    false if gravitationalParameter is negative or zero; otherwise true.
  - computePeriod
```
public static double computePeriod(double inverseSemimajorAxis,
                                   double gravitationalParameter)
```
    Calculates the period of the orbit.
    inverseSemimajorAxis and gravitationalParameter must have consistent units and the units of the resulting period will correspond with the units of the input parameters.
    
    Parameters:
    
    inverseSemimajorAxis - The inverse of the semimajor axis (distance).
    
    gravitationalParameter - The gravitational parameter (distance cubed per time squared).
    
    Returns:
    
    The period of the orbit.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when gravitationalParameter is negative or zero.
  - tryComputeMeanMotion
```
public static boolean tryComputeMeanMotion(double radiusOfPeriapsis,
                                           double eccentricity,
                                           double gravitationalParameter,
                                           @Nonnull
                                           double[] meanMotion)
```
    Tries to calculate the mean motion of the orbit.
    
    Parameters:
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter.
    
    meanMotion - On input, an array with one element. On return, the array is populated with the mean motion of the orbit.
    
    Returns:
    
    false if eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero; otherwise true.
  - computeMeanMotion
```
public static double computeMeanMotion(double radiusOfPeriapsis,
                                       double eccentricity,
                                       double gravitationalParameter)
```
    Calculates the mean motion of the orbit.
    
    Parameters:
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter.
    
    Returns:
    
    The mean motion of the orbit.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero.
  - tryConvertTrueAnomalyToEccentricAnomaly
```
public static boolean tryConvertTrueAnomalyToEccentricAnomaly(double trueAnomaly,
                                                              double eccentricity,
                                                              @Nonnull
                                                              double[] eccentricAnomaly)
```
    Tries to convert the true anomaly to the eccentric anomaly.
    
    Parameters:
    
    trueAnomaly - The true anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    eccentricAnomaly - On input, an array with one element. On return, the array is populated with the eccentric anomaly.
    
    Returns:
    
    false if eccentricity is negative or greater than or equal to one (indicating that the orbit is not closed); otherwise true.
  - convertTrueAnomalyToEccentricAnomaly
```
public static double convertTrueAnomalyToEccentricAnomaly(double trueAnomaly,
                                                          double eccentricity)
```
    Converts the true anomaly to the eccentric anomaly.
    
    Parameters:
    
    trueAnomaly - The true anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    Returns:
    
    The eccentric anomaly.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is greater than or equal to one (indicating that the orbit is not closed), or if it is negative.
  - tryConvertEccentricAnomalyToTrueAnomaly
```
public static boolean tryConvertEccentricAnomalyToTrueAnomaly(double eccentricAnomaly,
                                                              double eccentricity,
                                                              @Nonnull
                                                              double[] trueAnomaly)
```
    Tries to convert the eccentric anomaly to the true anomaly.
    
    Parameters:
    
    eccentricAnomaly - The eccentric anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    trueAnomaly - On input, an array with one element. On return, the array is populated with the true anomaly.
    
    Returns:
    
    false if eccentricity is negative or greater than or equal to one (indicating that the orbit is not closed); otherwise true.
  - convertEccentricAnomalyToTrueAnomaly
```
public static double convertEccentricAnomalyToTrueAnomaly(double eccentricAnomaly,
                                                          double eccentricity)
```
    Converts the eccentric anomaly to the true anomaly.
    
    Parameters:
    
    eccentricAnomaly - The eccentric anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    Returns:
    
    The true anomaly.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is greater than or equal to one (indicating that the orbit is not closed), or if it is negative.
  - tryConvertTrueAnomalyToParabolicAnomaly
```
public static boolean tryConvertTrueAnomalyToParabolicAnomaly(double trueAnomaly,
                                                              double eccentricity,
                                                              @Nonnull
                                                              double[] parabolicAnomaly)
```
    Tries to convert the true anomaly to the parabolic anomaly.
    
    Parameters:
    
    trueAnomaly - The true anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    parabolicAnomaly - On input, an array with one element. On return, the array is populated with the parabolic anomaly.
    
    Returns:
    
    false if eccentricity is not equal to one (indicating that the orbit is not parabolic) or trueAnomaly is less than negative Math.PI or greater than Math.PI; otherwise true.
  - convertTrueAnomalyToParabolicAnomaly
```
public static double convertTrueAnomalyToParabolicAnomaly(double trueAnomaly,
                                                          double eccentricity)
```
    Converts the true anomaly to the parabolic anomaly.
    
    Parameters:
    
    trueAnomaly - The true anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    Returns:
    
    The parabolic anomaly.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is not equal to one (indicating that the orbit is not parabolic), or if it is negative, or trueAnomaly is less than negative Math.PI or greater than Math.PI.
  - tryConvertParabolicAnomalyToTrueAnomaly
```
public static boolean tryConvertParabolicAnomalyToTrueAnomaly(double parabolicAnomaly,
                                                              double eccentricity,
                                                              @Nonnull
                                                              double[] trueAnomaly)
```
    Tries to convert the parabolic anomaly to the true anomaly.
    
    Parameters:
    
    parabolicAnomaly - The parabolic anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    trueAnomaly - On input, an array with one element. On return, the array is populated with the true anomaly.
    
    Returns:
    
    false if eccentricity is not equal to one (indicating that the orbit is not parabolic).
  - convertParabolicAnomalyToTrueAnomaly
```
public static double convertParabolicAnomalyToTrueAnomaly(double parabolicAnomaly,
                                                          double eccentricity)
```
    Converts the parabolic anomaly to the true anomaly.
    
    Parameters:
    
    parabolicAnomaly - The parabolic anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    Returns:
    
    The true anomaly.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is not equal to one (indicating that the orbit is not parabolic), or if it is negative.
  - tryConvertTrueAnomalyToHyperbolicAnomaly
```
public static boolean tryConvertTrueAnomalyToHyperbolicAnomaly(double trueAnomaly,
                                                               double eccentricity,
                                                               @Nonnull
                                                               double[] hyperbolicAnomaly)
```
    Tries to convert the true anomaly to the hyperbolic anomaly.
    
    Parameters:
    
    trueAnomaly - The true anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    hyperbolicAnomaly - On input, an array with one element. On return, the array is populated with. the hyperbolic anomaly.
    
    Returns:
    
    false if eccentricity is less than or equal to one (indicating that the orbit is not hyperbolic) or trueAnomaly is outside the bounds of the asymptotes of the hyperbola; otherwise true.
  - convertTrueAnomalyToHyperbolicAnomaly
```
public static double convertTrueAnomalyToHyperbolicAnomaly(double trueAnomaly,
                                                           double eccentricity)
```
    Converts the true anomaly to the hyperbolic anomaly.
    
    Parameters:
    
    trueAnomaly - The true anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    Returns:
    
    The hyperbolic anomaly.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is less than or equal to one (indicating that the orbit is not hyperbolic), or if it is negative, or trueAnomaly is outside the bounds of the asymptotes of the hyperbola.
  - tryConvertHyperbolicAnomalyToTrueAnomaly
```
public static boolean tryConvertHyperbolicAnomalyToTrueAnomaly(double hyperbolicAnomaly,
                                                               double eccentricity,
                                                               @Nonnull
                                                               double[] trueAnomaly)
```
    Tries to convert the hyperbolic anomaly to the true anomaly.
    
    Parameters:
    
    hyperbolicAnomaly - The hyperbolic anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    trueAnomaly - On input, an array with one element. On return, the array is populated with the true anomaly.
    
    Returns:
    
    false if eccentricity is less than or equal to one (indicating that the orbit is not hyperbolic).
  - convertHyperbolicAnomalyToTrueAnomaly
```
public static double convertHyperbolicAnomalyToTrueAnomaly(double hyperbolicAnomaly,
                                                           double eccentricity)
```
    Converts the hyperbolic anomaly to the true anomaly.
    
    Parameters:
    
    hyperbolicAnomaly - The hyperbolic anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    Returns:
    
    The true anomaly.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is less than or equal to one (indicating that the orbit is not hyperbolic), or if it is negative.
  - tryConvertMeanAnomalyToEccentricAnomaly
```
public static boolean tryConvertMeanAnomalyToEccentricAnomaly(double meanAnomaly,
                                                              double eccentricity,
                                                              @Nonnull
                                                              double[] eccentricAnomaly)
```
    Tries to convert the mean anomaly to the eccentric anomaly.
    
    Parameters:
    
    meanAnomaly - The mean anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    eccentricAnomaly - On input, an array with one element. On return, the array is populated with the eccentric anomaly.
    
    Returns:
    
    false if eccentricity is negative or greater than or equal to one (indicating that the orbit is not closed) or if the iterative solution to Kepler's equation did not converge; otherwise true.
  - convertMeanAnomalyToEccentricAnomaly
```
public static double convertMeanAnomalyToEccentricAnomaly(double meanAnomaly,
                                                          double eccentricity)
```
    Converts the mean anomaly to the eccentric anomaly.
    
    Parameters:
    
    meanAnomaly - The true anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    Returns:
    
    The eccentric anomaly.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is greater than or equal to one (indicating that the orbit is not closed), or if it is negative.
    
    ArithmeticException - Thrown when the iterative solution to Kepler's equation did not converge.
  - tryConvertMeanAnomalyToParabolicAnomaly
```
public static boolean tryConvertMeanAnomalyToParabolicAnomaly(double meanAnomaly,
                                                              double eccentricity,
                                                              @Nonnull
                                                              double[] parabolicAnomaly)
```
    Tries to convert the mean anomaly to the parabolic anomaly.
    
    Parameters:
    
    meanAnomaly - The mean anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    parabolicAnomaly - On input, an array with one element. On return, the array is populated with the parabolic anomaly.
    
    Returns:
    
    false if eccentricity is not equal to one (indicating that the orbit is not parabolic); otherwise true.
  - convertMeanAnomalyToParabolicAnomaly
```
public static double convertMeanAnomalyToParabolicAnomaly(double meanAnomaly,
                                                          double eccentricity)
```
    Converts the mean anomaly to the parabolic anomaly.
    
    Parameters:
    
    meanAnomaly - The true anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    Returns:
    
    The parabolic anomaly.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is not equal to one (indicating that the orbit is not parabolic), or if it is negative.
  - tryConvertMeanAnomalyToHyperbolicAnomaly
```
public static boolean tryConvertMeanAnomalyToHyperbolicAnomaly(double meanAnomaly,
                                                               double eccentricity,
                                                               @Nonnull
                                                               double[] hyperbolicAnomaly)
```
    Tries to convert the mean anomaly to the hyperbolic anomaly.
    
    Parameters:
    
    meanAnomaly - The mean anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    hyperbolicAnomaly - On input, an array with one element. On return, the array is populated with the hyperbolic anomaly.
    
    Returns:
    
    false if eccentricity is less than or equal to one (indicating that the orbit is not hyperbolic), or if the iterative solution to Kepler's equation did not converge; otherwise true.
  - convertMeanAnomalyToHyperbolicAnomaly
```
public static double convertMeanAnomalyToHyperbolicAnomaly(double meanAnomaly,
                                                           double eccentricity)
```
    Tries to convert the mean anomaly to the hyperbolic anomaly.
    
    Parameters:
    
    meanAnomaly - The true anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    Returns:
    
    The hyperbolic anomaly.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is less than or equal to one (indicating that the orbit is not hyperbolic), or if it is negative.
    
    ArithmeticException - Thrown when the iterative solution to Kepler's equation did not converge.
  - tryConvertEccentricAnomalyToMeanAnomaly
```
public static boolean tryConvertEccentricAnomalyToMeanAnomaly(double eccentricAnomaly,
                                                              double eccentricity,
                                                              @Nonnull
                                                              double[] meanAnomaly)
```
    Tries to convert the eccentric anomaly to the mean anomaly.
    
    Parameters:
    
    eccentricAnomaly - The eccentric anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    meanAnomaly - On input, an array with one element. On return, the array is populated with the mean anomaly.
    
    Returns:
    
    false if eccentricity is negative or greater than or equal to one (indicating that the orbit is not closed); otherwise true.
  - convertEccentricAnomalyToMeanAnomaly
```
public static double convertEccentricAnomalyToMeanAnomaly(double eccentricAnomaly,
                                                          double eccentricity)
```
    Tries to convert the eccentric anomaly to the mean anomaly.
    
    Parameters:
    
    eccentricAnomaly - The eccentric anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    Returns:
    
    The mean anomaly.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is greater than or equal to one (indicating that the orbit is not closed), or if it is negative.
  - tryConvertParabolicAnomalyToMeanAnomaly
```
public static boolean tryConvertParabolicAnomalyToMeanAnomaly(double parabolicAnomaly,
                                                              double eccentricity,
                                                              @Nonnull
                                                              double[] meanAnomaly)
```
    Tries to convert the parabolic anomaly to the mean anomaly.
    
    Parameters:
    
    parabolicAnomaly - The parabolic anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    meanAnomaly - On input, an array with one element. On return, the array is populated with the mean anomaly.
    
    Returns:
    
    false if eccentricity is not equal to one (indicating that the orbit is not parabolic); otherwise true.
  - convertParabolicAnomalyToMeanAnomaly
```
public static double convertParabolicAnomalyToMeanAnomaly(double parabolicAnomaly,
                                                          double eccentricity)
```
    Converts the parabolic anomaly to the mean anomaly.
    
    Parameters:
    
    parabolicAnomaly - The parabolic anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    Returns:
    
    The mean anomaly.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is not equal to one (indicating that the orbit is not parabolic), or if it is negative.
  - tryConvertHyperbolicAnomalyToMeanAnomaly
```
public static boolean tryConvertHyperbolicAnomalyToMeanAnomaly(double hyperbolicAnomaly,
                                                               double eccentricity,
                                                               @Nonnull
                                                               double[] meanAnomaly)
```
    Tries to convert the hyperbolic anomaly to the mean anomaly.
    
    Parameters:
    
    hyperbolicAnomaly - The hyperbolic anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    meanAnomaly - On input, an array with one element. On return, the array is populated with the mean anomaly.
    
    Returns:
    
    false if eccentricity is less than or equal to one (indicating that the orbit is not hyperbolic); otherwise true.
  - convertHyperbolicAnomalyToMeanAnomaly
```
public static double convertHyperbolicAnomalyToMeanAnomaly(double hyperbolicAnomaly,
                                                           double eccentricity)
```
    Converts the hyperbolic anomaly to the mean anomaly.
    
    Parameters:
    
    hyperbolicAnomaly - The hyperbolic anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    Returns:
    
    The mean anomaly.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is less than or equal to one (indicating that the orbit is not hyperbolic), or if it is negative.
  - tryConvertTrueAnomalyToMeanAnomaly
```
public static boolean tryConvertTrueAnomalyToMeanAnomaly(double trueAnomaly,
                                                         double eccentricity,
                                                         @Nonnull
                                                         double[] meanAnomaly)
```
    Tries to convert the true anomaly to the mean anomaly.
    
    Parameters:
    
    trueAnomaly - The true anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    meanAnomaly - On input, an array with one element. On return, the array is populated with the mean anomaly.
    
    Returns:
    
    false if eccentricity is negative or if trueAnomaly is not within the valid range for the type of orbit; otherwise true.
  - convertTrueAnomalyToMeanAnomaly
```
public static double convertTrueAnomalyToMeanAnomaly(double trueAnomaly,
                                                     double eccentricity)
```
    Converts the true anomaly to the mean anomaly.
    
    Parameters:
    
    trueAnomaly - The true anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    Returns:
    
    The mean anomaly.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown if eccentricity is negative or if trueAnomaly is not within the valid range for the type of orbit.
  - tryConvertMeanAnomalyToTrueAnomaly
```
public static boolean tryConvertMeanAnomalyToTrueAnomaly(double meanAnomaly,
                                                         double eccentricity,
                                                         @Nonnull
                                                         double[] trueAnomaly)
```
    Tries to convert the mean anomaly to the true anomaly.
    
    Parameters:
    
    meanAnomaly - The mean anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    trueAnomaly - On input, an array with one element. On return, the array is populated with the true anomaly.
    
    Returns:
    
    false if eccentricity is negative or the iterative solution to Kepler's equation did not converge for elliptic or hyperbolic orbits; otherwise true.
  - convertMeanAnomalyToTrueAnomaly
```
public static double convertMeanAnomalyToTrueAnomaly(double meanAnomaly,
                                                     double eccentricity)
```
    Converts the mean anomaly to the true anomaly.
    
    Parameters:
    
    meanAnomaly - The true anomaly to convert (radians).
    
    eccentricity - The eccentricity of the orbit.
    
    Returns:
    
    The true anomaly.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is negative.
    
    ArithmeticException - Thrown when the iterative solution to Kepler's equation did not converge for elliptic or hyperbolic orbits.
  - tryConvertEccentricAnomalyToTimeFromPeriapsis
```
public static boolean tryConvertEccentricAnomalyToTimeFromPeriapsis(double eccentricAnomaly,
                                                                    double radiusOfPeriapsis,
                                                                    double eccentricity,
                                                                    double gravitationalParameter,
                                                                    @Nonnull
                                                                    double[] timeFromPeriapsis)
```
    Tries to convert the eccentric anomaly to the time of flight from the corresponding periapsis passage in seconds. The value returned is signed and monotonic even for periodic orbits.
    
    Parameters:
    
    eccentricAnomaly - The eccentric anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter of the central body being orbited.
    
    timeFromPeriapsis - On input, an array with one element. On return, the array is populated with the time since the last periapsis passage.
    
    Returns:
    
    false if eccentricity is negative or greater than or equal to one or radiusOfPeriapsis or gravitationalParameter is negative or zero; otherwise true.
  - convertEccentricAnomalyToTimeFromPeriapsis
```
public static double convertEccentricAnomalyToTimeFromPeriapsis(double eccentricAnomaly,
                                                                double radiusOfPeriapsis,
                                                                double eccentricity,
                                                                double gravitationalParameter)
```
    Converts the eccentric anomaly to the time of flight from the corresponding periapsis passage in seconds. The value returned is signed and monotonic even for periodic orbits.
    
    Parameters:
    
    eccentricAnomaly - The eccentric anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter of the central body being orbited.
    
    Returns:
    
    The time since the last periapsis passage.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is greater than or equal to one (indicating that the orbit is not closed), or if it is negative, or radiusOfPeriapsis or gravitationalParameter is negative or zero.
  - tryConvertParabolicAnomalyToTimeFromPeriapsis
```
public static boolean tryConvertParabolicAnomalyToTimeFromPeriapsis(double parabolicAnomaly,
                                                                    double radiusOfPeriapsis,
                                                                    double eccentricity,
                                                                    double gravitationalParameter,
                                                                    @Nonnull
                                                                    double[] timeFromPeriapsis)
```
    Tries to convert the parabolic anomaly to the time of flight from the corresponding periapsis passage in seconds. The value returned is signed and monotonic even for periodic orbits.
    
    Parameters:
    
    parabolicAnomaly - The parabolic anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter of the central body being orbited.
    
    timeFromPeriapsis - On input, an array with one element. On return, the array is populated with the time since the last periapsis passage.
    
    Returns:
    
    false if eccentricity is not equal to one (indicating that the orbit is not parabolic) or radiusOfPeriapsis or gravitationalParameter is negative or zero; otherwise true.
  - convertParabolicAnomalyToTimeFromPeriapsis
```
public static double convertParabolicAnomalyToTimeFromPeriapsis(double parabolicAnomaly,
                                                                double radiusOfPeriapsis,
                                                                double eccentricity,
                                                                double gravitationalParameter)
```
    Converts the parabolic anomaly to the time of flight from the corresponding periapsis passage in seconds. The value returned is signed and monotonic even for periodic orbits.
    
    Parameters:
    
    parabolicAnomaly - The parabolic anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter of the central body being orbited.
    
    Returns:
    
    The time since the last periapsis passage.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is not equal to one (indicating that the orbit is not parabolic), or if it is negative, or radiusOfPeriapsis or gravitationalParameter is negative or zero.
  - tryConvertHyperbolicAnomalyToTimeFromPeriapsis
```
public static boolean tryConvertHyperbolicAnomalyToTimeFromPeriapsis(double hyperbolicAnomaly,
                                                                     double radiusOfPeriapsis,
                                                                     double eccentricity,
                                                                     double gravitationalParameter,
                                                                     @Nonnull
                                                                     double[] timeFromPeriapsis)
```
    Tries to convert the hyperbolic anomaly to the time of flight from the corresponding periapsis passage in seconds. The value returned is signed and monotonic even for periodic orbits.
    
    Parameters:
    
    hyperbolicAnomaly - The hyperbolic anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter of the central body being orbited.
    
    timeFromPeriapsis - On input, an array with one element. On return, the array is populated with the time since the last periapsis passage.
    
    Returns:
    
    false if eccentricity is less than or equal to one (indicating that the orbit is not hyperbolic) or radiusOfPeriapsis or gravitationalParameter is negative or zero; otherwise true.
  - convertHyperbolicAnomalyToTimeFromPeriapsis
```
public static double convertHyperbolicAnomalyToTimeFromPeriapsis(double hyperbolicAnomaly,
                                                                 double radiusOfPeriapsis,
                                                                 double eccentricity,
                                                                 double gravitationalParameter)
```
    Converts the hyperbolic anomaly to the time of flight from the corresponding periapsis passage in seconds. The value returned is signed and monotonic even for periodic orbits.
    
    Parameters:
    
    hyperbolicAnomaly - The hyperbolic anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter of the central body being orbited.
    
    Returns:
    
    The time since the last periapsis passage.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is less than or equal to one (indicating that the orbit is not hyperbolic), or if it is negative, or radiusOfPeriapsis or gravitationalParameter is negative or zero.
  - tryConvertMeanAnomalyToTimeUntilNextPeriapsis
```
public static boolean tryConvertMeanAnomalyToTimeUntilNextPeriapsis(double meanAnomaly,
                                                                    double radiusOfPeriapsis,
                                                                    double eccentricity,
                                                                    double gravitationalParameter,
                                                                    @Nonnull
                                                                    double[] timeUntilNextPeriapsis)
```
    Tries to convert the mean anomaly to the time of flight until the next periapsis passage in seconds. The value returned is positive and, for closed orbits, periodic.
    
    Parameters:
    
    meanAnomaly - The mean anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter of the central body being orbited.
    
    timeUntilNextPeriapsis - On input, an array with one element. On return, the array is populated with the time until the next periapsis passage.
    
    Returns:
    
    false if eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero or if the orbit is open (parabolic or hyperbolic) and meanAnomaly is positive or zero; otherwise true.
  - convertMeanAnomalyToTimeUntilNextPeriapsis
```
public static double convertMeanAnomalyToTimeUntilNextPeriapsis(double meanAnomaly,
                                                                double radiusOfPeriapsis,
                                                                double eccentricity,
                                                                double gravitationalParameter)
```
    Converts the mean anomaly to the time of flight until the next periapsis passage in seconds. The value returned is positive and, for closed orbits, periodic.
    
    Parameters:
    
    meanAnomaly - The mean anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter of the central body being orbited.
    
    Returns:
    
    The time until the next periapsis passage.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero or if the orbit is open (parabolic or hyperbolic) and meanAnomaly is positive or zero.
  - tryConvertMeanAnomalyToTimeFromPeriapsis
```
public static boolean tryConvertMeanAnomalyToTimeFromPeriapsis(double meanAnomaly,
                                                               double radiusOfPeriapsis,
                                                               double eccentricity,
                                                               double gravitationalParameter,
                                                               @Nonnull
                                                               double[] timeFromPeriapsis)
```
    Tries to convert the mean anomaly to the time of flight from the corresponding periapsis passage in seconds. The value returned is signed and monotonic even for periodic orbits.
    
    Parameters:
    
    meanAnomaly - The mean anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter of the central body being orbited.
    
    timeFromPeriapsis - On input, an array with one element. On return, the array is populated with the time since the last periapsis passage.
    
    Returns:
    
    false if eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero; otherwise true.
  - convertMeanAnomalyToTimeFromPeriapsis
```
public static double convertMeanAnomalyToTimeFromPeriapsis(double meanAnomaly,
                                                           double radiusOfPeriapsis,
                                                           double eccentricity,
                                                           double gravitationalParameter)
```
    Converts the mean anomaly to the time of flight from the corresponding periapsis passage in seconds. The value returned is signed and monotonic even for periodic orbits.
    
    Parameters:
    
    meanAnomaly - The mean anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter of the central body being orbited.
    
    Returns:
    
    The time since the last periapsis passage.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero.
  - tryConvertMeanAnomalyToTimeSincePreviousPeriapsis
```
public static boolean tryConvertMeanAnomalyToTimeSincePreviousPeriapsis(double meanAnomaly,
                                                                        double radiusOfPeriapsis,
                                                                        double eccentricity,
                                                                        double gravitationalParameter,
                                                                        @Nonnull
                                                                        double[] timeSincePreviousPeriapsis)
```
    Tries to convert the mean anomaly to the time of flight since the previous periapsis passage in seconds. The value returned is positive and, for closed orbits, periodic.
    
    Parameters:
    
    meanAnomaly - The mean anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter of the central body being orbited.
    
    timeSincePreviousPeriapsis - On input, an array with one element. On return, the array is populated with the time since the previous periapsis passage.
    
    Returns:
    
    false if eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero or if the orbit is open (parabolic or hyperbolic) and meanAnomaly is negative or zero; otherwise true.
  - convertMeanAnomalyToTimeSincePreviousPeriapsis
```
public static double convertMeanAnomalyToTimeSincePreviousPeriapsis(double meanAnomaly,
                                                                    double radiusOfPeriapsis,
                                                                    double eccentricity,
                                                                    double gravitationalParameter)
```
    Converts the mean anomaly to the time of flight since the previous periapsis passage in seconds. The value returned is positive and, for closed orbits, periodic.
    
    Parameters:
    
    meanAnomaly - The mean anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter of the central body being orbited.
    
    Returns:
    
    The time since the previous periapsis passage.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero or if the orbit is open (parabolic or hyperbolic) and meanAnomaly is negative or zero.
  - tryConvertTrueAnomalyToTimeUntilNextPeriapsis
```
public static boolean tryConvertTrueAnomalyToTimeUntilNextPeriapsis(double trueAnomaly,
                                                                    double radiusOfPeriapsis,
                                                                    double eccentricity,
                                                                    double gravitationalParameter,
                                                                    @Nonnull
                                                                    double[] timeUntilNextPeriapsis)
```
    Tries to convert the true anomaly to the time of flight until the next periapsis passage in seconds. The value returned is positive and, for closed orbits, periodic.
    
    Parameters:
    
    trueAnomaly - The true anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter of the central body being orbited.
    
    timeUntilNextPeriapsis - On input, an array with one element. On return, the array is populated with the time until the next periapsis passage.
    
    Returns:
    
    false if eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero or if the orbit is open (parabolic or hyperbolic) and trueAnomaly is positive or zero or if trueAnomaly is not within the valid range for the type of orbit; otherwise true.
  - convertTrueAnomalyToTimeUntilNextPeriapsis
```
public static double convertTrueAnomalyToTimeUntilNextPeriapsis(double trueAnomaly,
                                                                double radiusOfPeriapsis,
                                                                double eccentricity,
                                                                double gravitationalParameter)
```
    Converts the true anomaly to the time of flight until the next periapsis passage in seconds. The value returned is positive and, for closed orbits, periodic.
    
    Parameters:
    
    trueAnomaly - The true anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter of the central body being orbited.
    
    Returns:
    
    The time until the next periapsis passage.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero or if the orbit is open (parabolic or hyperbolic) and trueAnomaly is positive or zero or if trueAnomaly is not within the valid range for the type of orbit; otherwise true.
  - tryConvertTrueAnomalyToTimeFromPeriapsis
```
public static boolean tryConvertTrueAnomalyToTimeFromPeriapsis(double trueAnomaly,
                                                               double radiusOfPeriapsis,
                                                               double eccentricity,
                                                               double gravitationalParameter,
                                                               @Nonnull
                                                               double[] timeFromPeriapsis)
```
    True to convert the true anomaly to the time of flight from the corresponding periapsis passage in seconds. The value returned is signed and monotonic even for periodic orbits.
    
    Parameters:
    
    trueAnomaly - The true anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter of the central body being orbited.
    
    timeFromPeriapsis - On input, an array with one element. On return, the array is populated with the time since the last periapsis passage.
    
    Returns:
    
    false if eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero or if trueAnomaly is not within the valid range for the type of orbit; otherwise true.
  - convertTrueAnomalyToTimeFromPeriapsis
```
public static double convertTrueAnomalyToTimeFromPeriapsis(double trueAnomaly,
                                                           double radiusOfPeriapsis,
                                                           double eccentricity,
                                                           double gravitationalParameter)
```
    Converts the true anomaly to the time of flight from the corresponding periapsis passage in seconds. The value returned is signed and monotonic even for periodic orbits.
    
    Parameters:
    
    trueAnomaly - The true anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter of the central body being orbited.
    
    Returns:
    
    The time since the last periapsis passage.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero or if trueAnomaly is not within the valid range for the type of orbit; otherwise true.
  - tryConvertTrueAnomalyToTimeSincePreviousPeriapsis
```
public static boolean tryConvertTrueAnomalyToTimeSincePreviousPeriapsis(double trueAnomaly,
                                                                        double radiusOfPeriapsis,
                                                                        double eccentricity,
                                                                        double gravitationalParameter,
                                                                        @Nonnull
                                                                        double[] timeSincePreviousPeriapsis)
```
    Tries to convert the true anomaly to the time of flight since the previous periapsis passage in seconds. The value returned is positive and, for closed orbits, periodic.
    
    Parameters:
    
    trueAnomaly - The true anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter of the central body being orbited.
    
    timeSincePreviousPeriapsis - On input, an array with one element. On return, the array is populated with the time since the previous periapsis passage.
    
    Returns:
    
    false if eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero or if the orbit is open (parabolic or hyperbolic) and trueAnomaly is negative or zero or if trueAnomaly is not within the valid range for the type of orbit; otherwise true.
  - convertTrueAnomalyToTimeSincePreviousPeriapsis
```
public static double convertTrueAnomalyToTimeSincePreviousPeriapsis(double trueAnomaly,
                                                                    double radiusOfPeriapsis,
                                                                    double eccentricity,
                                                                    double gravitationalParameter)
```
    Converts the true anomaly to the time of flight since the previous periapsis passage in seconds. The value returned is positive and, for closed orbits, periodic.
    
    Parameters:
    
    trueAnomaly - The true anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis.
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter of the central body being orbited.
    
    Returns:
    
    The time since the previous periapsis passage.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero or if the orbit is open (parabolic or hyperbolic) and trueAnomaly is negative or zero or if trueAnomaly is not within the valid range for the type of orbit; otherwise true.
  - tryConvertTimeFromPeriapsisToMeanAnomaly
```
public static boolean tryConvertTimeFromPeriapsisToMeanAnomaly(double timeFromPeriapsis,
                                                               double radiusOfPeriapsis,
                                                               double eccentricity,
                                                               double gravitationalParameter,
                                                               @Nonnull
                                                               double[] meanAnomaly)
```
    Tries to convert the time from periapsis passage to mean anomaly. The value returned is signed and monotonic even for periodic orbits.
    
    Parameters:
    
    timeFromPeriapsis - The time from periapsis passage (time).
    
    radiusOfPeriapsis - The radius of periapsis (distance).
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter (distance cubed per time squared).
    
    meanAnomaly - On input, an array with one element. On return, the array is populated with the mean anomaly (radians).
    
    Returns:
    
    false if eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero; otherwise true.
  - convertTimeFromPeriapsisToMeanAnomaly
```
public static double convertTimeFromPeriapsisToMeanAnomaly(double timeFromPeriapsis,
                                                           double radiusOfPeriapsis,
                                                           double eccentricity,
                                                           double gravitationalParameter)
```
    Converts the time from periapsis passage to mean anomaly. The value returned is signed and monotonic even for periodic orbits.
    
    Parameters:
    
    timeFromPeriapsis - The time from periapsis passage (time).
    
    radiusOfPeriapsis - The radius of periapsis (distance).
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter (distance cubed per time squared).
    
    Returns:
    
    The mean anomaly (radians).
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero; otherwise true.
  - tryConvertTimeFromPeriapsisToTrueAnomaly
```
public static boolean tryConvertTimeFromPeriapsisToTrueAnomaly(double timeFromPeriapsis,
                                                               double radiusOfPeriapsis,
                                                               double eccentricity,
                                                               double gravitationalParameter,
                                                               @Nonnull
                                                               double[] trueAnomaly)
```
    Tries to convert the time from periapsis passage to true anomaly. The value returned is signed and monotonic even for periodic orbits.
    
    Parameters:
    
    timeFromPeriapsis - The time from periapsis passage (time).
    
    radiusOfPeriapsis - The radius of periapsis (distance).
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter (distance cubed per time squared).
    
    trueAnomaly - On input, an array with one element. On return, the array is populated with the true anomaly.
    
    Returns:
    
    false if eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero or the iterative solution to Kepler's equation did not converge for elliptic or hyperbolic orbits; otherwise true.
  - convertTimeFromPeriapsisToTrueAnomaly
```
public static double convertTimeFromPeriapsisToTrueAnomaly(double timeFromPeriapsis,
                                                           double radiusOfPeriapsis,
                                                           double eccentricity,
                                                           double gravitationalParameter)
```
    Converts the time from periapsis passage to true anomaly. The value returned is signed and monotonic even for periodic orbits.
    
    Parameters:
    
    timeFromPeriapsis - The time from periapsis passage (time).
    
    radiusOfPeriapsis - The radius of periapsis (distance).
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter (distance cubed per time squared).
    
    Returns:
    
    The true anomaly.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero.
    
    ArithmeticException - Thrown when the iterative solution to Kepler's equation did not converge for elliptic or hyperbolic orbits.
  - tryConvertTimeFromPeriapsisToEccentricAnomaly
```
public static boolean tryConvertTimeFromPeriapsisToEccentricAnomaly(double timeFromPeriapsis,
                                                                    double radiusOfPeriapsis,
                                                                    double eccentricity,
                                                                    double gravitationalParameter,
                                                                    @Nonnull
                                                                    double[] eccentricAnomaly)
```
    Tries to convert the time from periapsis passage to eccentric anomaly. The value returned is signed and monotonic even for periodic orbits.
    
    Parameters:
    
    timeFromPeriapsis - The time from periapsis passage (time).
    
    radiusOfPeriapsis - The radius of periapsis (distance).
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter (distance cubed per time squared).
    
    eccentricAnomaly - On input, an array with one element. On return, the array is populated with the eccentric anomaly.
    
    Returns:
    
    false if eccentricity is negative or greater than or equal to one (indicating that the orbit is not closed) or radiusOfPeriapsis or gravitationalParameter is negative or zero or the iterative solution to Kepler's equation did not converge; otherwise true.
  - convertTimeFromPeriapsisToEccentricAnomaly
```
public static double convertTimeFromPeriapsisToEccentricAnomaly(double timeFromPeriapsis,
                                                                double radiusOfPeriapsis,
                                                                double eccentricity,
                                                                double gravitationalParameter)
```
    Converts the time from periapsis passage to eccentric anomaly. The value returned is signed and monotonic even for periodic orbits.
    
    Parameters:
    
    timeFromPeriapsis - The time from periapsis passage (time).
    
    radiusOfPeriapsis - The radius of periapsis (distance).
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter (distance cubed per time squared).
    
    Returns:
    
    The eccentric anomaly.
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is greater than or equal to one (indicating that the orbit is not closed), or if it is negative, or radiusOfPeriapsis or gravitationalParameter is negative or zero.
    
    ArithmeticException - Thrown when the iterative solution to Kepler's equation did not converge for elliptic or hyperbolic orbits.
  - tryConvertTimeFromPeriapsisToParabolicAnomaly
```
public static boolean tryConvertTimeFromPeriapsisToParabolicAnomaly(double timeFromPeriapsis,
                                                                    double radiusOfPeriapsis,
                                                                    double eccentricity,
                                                                    double gravitationalParameter,
                                                                    @Nonnull
                                                                    double[] parabolicAnomaly)
```
    Tries to convert the time from periapsis passage to parabolic anomaly. The value returned is signed and monotonic.
    
    Parameters:
    
    timeFromPeriapsis - The time from periapsis passage (time).
    
    radiusOfPeriapsis - The radius of periapsis (distance).
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter (distance cubed per time squared).
    
    parabolicAnomaly - On input, an array with one element. On return, the array is populated with the parabolic anomaly (radians).
    
    Returns:
    
    false if eccentricity is not equal to one (indicating that the orbit is not parabolic) or radiusOfPeriapsis or gravitationalParameter is negative or zero; otherwise true.
  - convertTimeFromPeriapsisToParabolicAnomaly
```
public static double convertTimeFromPeriapsisToParabolicAnomaly(double timeFromPeriapsis,
                                                                double radiusOfPeriapsis,
                                                                double eccentricity,
                                                                double gravitationalParameter)
```
    Converts the time from periapsis passage to parabolic anomaly. The value returned is signed and monotonic.
    
    Parameters:
    
    timeFromPeriapsis - The time from periapsis passage (time).
    
    radiusOfPeriapsis - The radius of periapsis (distance).
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter (distance cubed per time squared).
    
    Returns:
    
    The parabolic anomaly (radians).
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is not equal to one (indicating that the orbit is not parabolic), or if it is negative, or radiusOfPeriapsis or gravitationalParameter is negative or zero.
  - tryConvertTimeFromPeriapsisToHyperbolicAnomaly
```
public static boolean tryConvertTimeFromPeriapsisToHyperbolicAnomaly(double timeFromPeriapsis,
                                                                     double radiusOfPeriapsis,
                                                                     double eccentricity,
                                                                     double gravitationalParameter,
                                                                     @Nonnull
                                                                     double[] hyperbolicAnomaly)
```
    Tries to convert the time from periapsis passage to hyperbolic anomaly. The value returned is signed and monotonic.
    
    Parameters:
    
    timeFromPeriapsis - The time from periapsis passage (time).
    
    radiusOfPeriapsis - The radius of periapsis (distance).
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter (distance cubed per time squared).
    
    hyperbolicAnomaly - On input, an array with one element. On return, the array is populated with the hyperbolic anomaly (radians).
    
    Returns:
    
    false if eccentricity is less than or equal to one (indicating that the orbit is not hyperbolic) or radiusOfPeriapsis or gravitationalParameter is negative or zero; otherwise true.
  - convertTimeFromPeriapsisToHyperbolicAnomaly
```
public static double convertTimeFromPeriapsisToHyperbolicAnomaly(double timeFromPeriapsis,
                                                                 double radiusOfPeriapsis,
                                                                 double eccentricity,
                                                                 double gravitationalParameter)
```
    Converts the time from periapsis passage to hyperbolic anomaly. The value returned is signed and monotonic.
    
    Parameters:
    
    timeFromPeriapsis - The time from periapsis passage (time).
    
    radiusOfPeriapsis - The radius of periapsis (distance).
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter (distance cubed per time squared).
    
    Returns:
    
    The hyperbolic anomaly (radians).
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is less than or equal to one (indicating that the orbit is not hyperbolic), or if it is negative, or radiusOfPeriapsis or gravitationalParameter is negative or zero.
    
    ArithmeticException - Thrown when the iterative solution to Kepler's equation did not converge.
  - tryComputeTimeOfFlight
```
public static boolean tryComputeTimeOfFlight(double initialTrueAnomaly,
                                             double finalTrueAnomaly,
                                             double radiusOfPeriapsis,
                                             double eccentricity,
                                             double gravitationalParameter,
                                             @Nonnull
                                             double[] timeOfFlight)
```
    Tries to calculate the time of flight between two true anomalies.
    The sign of the true anomaly indicates whether the position in orbit was measured before or after crossing periapsis.
    
    Parameters:
    
    initialTrueAnomaly - The initial true anomaly (radians).
    
    finalTrueAnomaly - The final true anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis (distance).
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter (distance cubed per time squared).
    
    timeOfFlight - On input, an array with one element. On return, the array is populated with the time of flight (time).
    
    Returns:
    
    true if the time of flight could be calculated with the given elements; otherwise false.
  - computeTimeOfFlight
```
public static double computeTimeOfFlight(double initialTrueAnomaly,
                                         double finalTrueAnomaly,
                                         double radiusOfPeriapsis,
                                         double eccentricity,
                                         double gravitationalParameter)
```
    Calculates the time of flight between two true anomalies.
    The sign of the true anomaly indicates whether the position in orbit was measured before or after crossing periapsis.
    
    Parameters:
    
    initialTrueAnomaly - The initial true anomaly (radians).
    
    finalTrueAnomaly - The final true anomaly (radians).
    
    radiusOfPeriapsis - The radius of periapsis (distance).
    
    eccentricity - The eccentricity of the orbit.
    
    gravitationalParameter - The gravitational parameter (distance cubed per time squared).
    
    Returns:
    
    The time of flight (time).
    
    Throws:
    
    ArgumentOutOfRangeException - Thrown when eccentricity is negative or radiusOfPeriapsis or gravitationalParameter is negative or zero or if initialTrueAnomaly or initialTrueAnomaly are not within the valid range for the type of orbit; otherwise true.

Class OrbitalElements

Method Summary

Methods inherited from class java.lang.Object

Method Detail

perifocalToCartesianMatrix

tryComputeEccentricity

computeEccentricity

tryComputeSemilatusRectum

computeSemilatusRectum

tryComputeSemimajorAxis

computeSemimajorAxis

tryComputeRadiusOfPeriapsis

computeRadiusOfPeriapsis

tryComputeRadiusOfApoapsis

computeRadiusOfApoapsis

tryComputePeriod

computePeriod

tryComputeMeanMotion

computeMeanMotion

tryConvertTrueAnomalyToEccentricAnomaly

convertTrueAnomalyToEccentricAnomaly

tryConvertEccentricAnomalyToTrueAnomaly

convertEccentricAnomalyToTrueAnomaly

tryConvertTrueAnomalyToParabolicAnomaly

convertTrueAnomalyToParabolicAnomaly

tryConvertParabolicAnomalyToTrueAnomaly

convertParabolicAnomalyToTrueAnomaly

tryConvertTrueAnomalyToHyperbolicAnomaly

convertTrueAnomalyToHyperbolicAnomaly

tryConvertHyperbolicAnomalyToTrueAnomaly

convertHyperbolicAnomalyToTrueAnomaly

tryConvertMeanAnomalyToEccentricAnomaly

convertMeanAnomalyToEccentricAnomaly

tryConvertMeanAnomalyToParabolicAnomaly

convertMeanAnomalyToParabolicAnomaly

tryConvertMeanAnomalyToHyperbolicAnomaly

convertMeanAnomalyToHyperbolicAnomaly

tryConvertEccentricAnomalyToMeanAnomaly

convertEccentricAnomalyToMeanAnomaly

tryConvertParabolicAnomalyToMeanAnomaly

convertParabolicAnomalyToMeanAnomaly

tryConvertHyperbolicAnomalyToMeanAnomaly

convertHyperbolicAnomalyToMeanAnomaly

tryConvertTrueAnomalyToMeanAnomaly

convertTrueAnomalyToMeanAnomaly

tryConvertMeanAnomalyToTrueAnomaly

convertMeanAnomalyToTrueAnomaly

tryConvertEccentricAnomalyToTimeFromPeriapsis

convertEccentricAnomalyToTimeFromPeriapsis

tryConvertParabolicAnomalyToTimeFromPeriapsis

convertParabolicAnomalyToTimeFromPeriapsis

tryConvertHyperbolicAnomalyToTimeFromPeriapsis

convertHyperbolicAnomalyToTimeFromPeriapsis

tryConvertMeanAnomalyToTimeUntilNextPeriapsis

convertMeanAnomalyToTimeUntilNextPeriapsis

tryConvertMeanAnomalyToTimeFromPeriapsis

convertMeanAnomalyToTimeFromPeriapsis

tryConvertMeanAnomalyToTimeSincePreviousPeriapsis

convertMeanAnomalyToTimeSincePreviousPeriapsis

tryConvertTrueAnomalyToTimeUntilNextPeriapsis

convertTrueAnomalyToTimeUntilNextPeriapsis

tryConvertTrueAnomalyToTimeFromPeriapsis

convertTrueAnomalyToTimeFromPeriapsis

tryConvertTrueAnomalyToTimeSincePreviousPeriapsis

convertTrueAnomalyToTimeSincePreviousPeriapsis

tryConvertTimeFromPeriapsisToMeanAnomaly

convertTimeFromPeriapsisToMeanAnomaly

tryConvertTimeFromPeriapsisToTrueAnomaly

convertTimeFromPeriapsisToTrueAnomaly

tryConvertTimeFromPeriapsisToEccentricAnomaly

convertTimeFromPeriapsisToEccentricAnomaly

tryConvertTimeFromPeriapsisToParabolicAnomaly

convertTimeFromPeriapsisToParabolicAnomaly

tryConvertTimeFromPeriapsisToHyperbolicAnomaly

convertTimeFromPeriapsisToHyperbolicAnomaly

tryComputeTimeOfFlight

computeTimeOfFlight