Here are some Kotlin examples and Java examples to get you started.
Feel free to start a new discussion topic if you need some help in your astronomy-related project, either with this code or astronomy computation concepts in general.
To include Astronomy Engine in your project, add this in your root build.gradle.kts at the end of repositories section:
allprojects {
repositories {
...
maven("https://jitpack.io")
}
}Now add the dependency:
dependencies {
implementation("io.github.cosinekitty:astronomy:2.1.19")
}For other build tools support have a look at this.
The following orientation systems are supported. Astronomy Engine can convert a vector from any of these orientations to any of the others. It also allows converting from a vector to spherical (angular) coordinates and back, within a given orientation. Note the 3-letter codes for each of the orientation systems; these are used in function and type names.
- EQJ = J2000 Mean Equator: Uses the Earth's mean equator (corrected for precession but ignoring nutation) on January 1, 2000, at noon UTC. This moment in time is called J2000.
- EQD = True Equator of Date: Uses the Earth's equator on a given date and time, adjusted for precession and nutation.
- ECL = J2000 Mean Ecliptic: Uses the plane of the Earth's orbit around the Sun at J2000. The x-axis is referenced against the J2000 mean equinox.
- ECT = True Ecliptic of Date: Uses the true (corrected for precession and nutation) orbital plane of the Earth on the given date. The x-axis is referenced against the true equinox for that date.
- HOR = Horizontal: Uses the viewpoint of an observer at a specific location on the Earth at a given date and time.
- GAL = Galactic: Based on the IAU 1958 definition of galactic coordinates.
Astronomy Engine provides a GravitySimulator class that allows you to model the trajectories of one or more small bodies like asteroids, comets, or coasting spacecraft. If you know an initial position vector and velocity vector for a small body, the gravity simulator can incrementally simulate the pull of gravity on it from the Sun and planets, to calculate its movement through the Solar System.
| Name | Summary |
|---|---|
| Aberration enum Aberration : Enum<Aberration> Aberration calculation options. |
|
| ApsisInfo class ApsisInfo(time: Time, kind: ApsisKind, distanceAu: Double) An apsis event: pericenter (closest approach) or apocenter (farthest distance). |
|
| ApsisKind enum ApsisKind : Enum<ApsisKind> The type of apsis: pericenter (closest approach) or apocenter (farthest distance). |
|
| AtmosphereInfo class AtmosphereInfo(pressure: Double, temperature: Double, density: Double) Information about idealized atmospheric variables at a given elevation. |
|
| AxisInfo class AxisInfo(ra: Double, dec: Double, spin: Double, north: Vector) Information about a body's rotation axis at a given time. |
|
| Body enum Body : Enum<Body> The enumeration of celestial bodies supported by Astronomy Engine. |
|
| ConstellationInfo class ConstellationInfo(symbol: String, name: String, ra1875: Double, dec1875: Double) Reports the constellation that a given celestial point lies within. |
|
| DateTime class DateTime(year: Int, month: Int, day: Int, hour: Int, minute: Int, second: Double) A universal time resolved into UTC calendar date and time fields. |
|
| Direction enum Direction : Enum<Direction> Selects whether to search for a rising event or a setting event for a celestial body. |
|
| EarthNotAllowedException class EarthNotAllowedException : Exception The Earth is not allowed as the body parameter. |
|
| EclipseEvent class EclipseEvent(time: Time, altitude: Double) Holds a time and the observed altitude of the Sun at that time. |
|
| EclipseKind enum EclipseKind : Enum<EclipseKind> The different kinds of lunar/solar eclipses. |
|
| Ecliptic data class Ecliptic(vec: Vector, elat: Double, elon: Double) Ecliptic angular and Cartesian coordinates. |
|
| ElongationInfo class ElongationInfo(time: Time, visibility: Visibility, elongation: Double, eclipticSeparation: Double) Contains information about the visibility of a celestial body at a given date and time. |
|
| EquatorEpoch enum EquatorEpoch : Enum<EquatorEpoch> Selects the date for which the Earth's equator is to be used for representing equatorial coordinates. |
|
| Equatorial class Equatorial(ra: Double, dec: Double, dist: Double, vec: Vector) Equatorial angular and cartesian coordinates. |
|
| GlobalSolarEclipseInfo class GlobalSolarEclipseInfo(kind: EclipseKind, obscuration: Double, peak: Time, distance: Double, latitude: Double, longitude: Double) Reports the time and geographic location of the peak of a solar eclipse. |
|
| GravitySimulator class GravitySimulator A simulation of zero or more small bodies moving through the Solar System. |
|
| HourAngleInfo class HourAngleInfo(time: Time, hor: Topocentric) Information about a celestial body crossing a specific hour angle. |
|
| IlluminationInfo class IlluminationInfo(time: Time, mag: Double, phaseAngle: Double, phaseFraction: Double, helioDist: Double, ringTilt: Double) Information about the brightness and illuminated shape of a celestial body. |
|
| InternalError class InternalError(message: String) : Exception An unexpected internal error occurred in Astronomy Engine |
|
| InvalidBodyException class InvalidBodyException(body: Body) : Exception An invalid body was specified for the given function. |
|
| JupiterMoonsInfo class JupiterMoonsInfo(io: StateVector, europa: StateVector, ganymede: StateVector, callisto: StateVector) Holds the positions and velocities of Jupiter's major 4 moons. |
|
| LibrationInfo data class LibrationInfo(elat: Double, elon: Double, mlat: Double, mlon: Double, distanceKm: Double, diamDeg: Double) Lunar libration angles, returned by libration. |
|
| LocalSolarEclipseInfo class LocalSolarEclipseInfo(kind: EclipseKind, obscuration: Double, partialBegin: EclipseEvent, totalBegin: EclipseEvent?, peak: EclipseEvent, totalEnd: EclipseEvent?, partialEnd: EclipseEvent) Information about a solar eclipse as seen by an observer at a given time and geographic location. |
|
| LunarEclipseInfo class LunarEclipseInfo(kind: EclipseKind, obscuration: Double, peak: Time, sdPenum: Double, sdPartial: Double, sdTotal: Double) Information about a lunar eclipse. |
|
| MoonQuarterInfo class MoonQuarterInfo(quarter: Int, time: Time) A lunar quarter event (new moon, first quarter, full moon, or third quarter) along with its date and time. |
|
| NodeEventInfo class NodeEventInfo(time: Time, kind: NodeEventKind) Information about an ascending or descending node of a body. |
|
| NodeEventKind enum NodeEventKind : Enum<NodeEventKind> Indicates whether a crossing through the ecliptic plane is ascending or descending. |
|
| Observer data class Observer(latitude: Double, longitude: Double, height: Double) The location of an observer on (or near) the surface of the Earth. |
|
| PositionFunction fun interface PositionFunction A function for which to solve a light-travel time problem. |
|
| Refraction enum Refraction : Enum<Refraction> Selects whether to correct for atmospheric refraction, and if so, how. |
|
| RotationMatrix class RotationMatrix(rot: Array<DoubleArray>) A rotation matrix that can be used to transform one coordinate system to another. |
|
| SearchContext fun interface SearchContext Represents a function whose ascending root is to be found. |
|
| SeasonsInfo class SeasonsInfo(marchEquinox: Time, juneSolstice: Time, septemberEquinox: Time, decemberSolstice: Time) The dates and times of changes of season for a given calendar year. |
|
| Spherical data class Spherical(lat: Double, lon: Double, dist: Double) Spherical coordinates: latitude, longitude, distance. |
|
| StateVector data class StateVector(x: Double, y: Double, z: Double, vx: Double, vy: Double, vz: Double, t: Time) Represents a combined position vector and velocity vector at a given moment in time. |
|
| Time class Time : Comparable<Time> A date and time used for astronomical calculations. |
|
| Topocentric data class Topocentric(azimuth: Double, altitude: Double, ra: Double, dec: Double) Coordinates of a celestial body as seen by a topocentric observer. |
|
| TransitInfo class TransitInfo(start: Time, peak: Time, finish: Time, separation: Double) Information about a transit of Mercury or Venus, as seen from the Earth. |
|
| Vector data class Vector(x: Double, y: Double, z: Double, t: Time) A 3D Cartesian vector whose components are expressed in Astronomical Units (AU). |
|
| Visibility enum Visibility : Enum<Visibility> Indicates whether a body (especially Mercury or Venus) is best seen in the morning or evening. |
| Name | Summary |
|---|---|
| angleFromSun fun angleFromSun(body: Body, time: Time): Double Returns the angle between the given body and the Sun, as seen from the Earth. |
|
| atmosphere fun atmosphere(elevationMeters: Double): AtmosphereInfo Calculates U.S. Standard Atmosphere (1976) variables as a function of elevation. |
|
| backdatePosition fun backdatePosition(time: Time, observerBody: Body, targetBody: Body, aberration: Aberration): Vector Solve for light travel time correction of apparent position. |
|
| baryState fun baryState(body: Body, time: Time): StateVector Calculates barycentric position and velocity vectors for the given body. |
|
| constellation fun constellation(ra: Double, dec: Double): ConstellationInfo Determines the constellation that contains the given point in the sky. |
|
| correctLightTravel fun correctLightTravel(func: PositionFunction, time: Time): Vector Solve for light travel time of a vector function. |
|
| defineStar fun defineStar(body: Body, ra: Double, dec: Double, distanceLightYears: Double) Assign equatorial coordinates to a user-defined star. |
|
| degreesToRadians fun Double.degreesToRadians(): Double Convert an angle expressed in degrees to an angle expressed in radians. |
|
| eclipticGeoMoon fun eclipticGeoMoon(time: Time): Spherical Calculates spherical ecliptic geocentric position of the Moon. |
|
| eclipticLongitude fun eclipticLongitude(body: Body, time: Time): Double Calculates heliocentric ecliptic longitude of a body. |
|
| elongation fun elongation(body: Body, time: Time): ElongationInfo Determines visibility of a celestial body relative to the Sun, as seen from the Earth. |
|
| equator fun equator(body: Body, time: Time, observer: Observer, equdate: EquatorEpoch, aberration: Aberration): Equatorial Calculates equatorial coordinates of a celestial body as seen by an observer on the Earth's surface. |
|
| equatorialToEcliptic fun equatorialToEcliptic(eqj: Vector): Ecliptic Converts a J2000 mean equator (EQJ) vector to a true ecliptic of date (ETC) vector and angles. |
|
| geoEmbState fun geoEmbState(time: Time): StateVector Calculates the geocentric position and velocity of the Earth/Moon barycenter. |
|
| geoMoon fun geoMoon(time: Time): Vector Calculates equatorial geocentric position of the Moon at a given time. |
|
| geoMoonState fun geoMoonState(time: Time): StateVector Calculates equatorial geocentric position and velocity of the Moon at a given time. |
|
| geoVector fun geoVector(body: Body, time: Time, aberration: Aberration): Vector Calculates geocentric Cartesian coordinates of a body in the J2000 equatorial system. |
|
| globalSolarEclipsesAfter fun globalSolarEclipsesAfter(startTime: Time): Sequence<GlobalSolarEclipseInfo> Enumerates a series of consecutive global solar eclipses that occur after a given time. |
|
| helioDistance fun helioDistance(body: Body, time: Time): Double Calculates the distance between a body and the Sun at a given time. |
|
| helioState fun helioState(body: Body, time: Time): StateVector Calculates heliocentric position and velocity vectors for the given body. |
|
| helioVector fun helioVector(body: Body, time: Time): Vector Calculates heliocentric Cartesian coordinates of a body in the J2000 equatorial system. |
|
| horizon fun horizon(time: Time, observer: Observer, ra: Double, dec: Double, refraction: Refraction): Topocentric Calculates the apparent location of a body relative to the local horizon of an observer on the Earth. |
|
| hourAngle fun hourAngle(body: Body, time: Time, observer: Observer): Double Finds the hour angle of a body for a given observer and time. |
|
| illumination fun illumination(body: Body, time: Time): IlluminationInfo Finds visual magnitude, phase angle, and other illumination information about a celestial body. |
|
| inverseRefractionAngle fun inverseRefractionAngle(refraction: Refraction, bentAltitude: Double): Double Calculates the inverse of an atmospheric refraction angle. |
|
| jupiterMoons fun jupiterMoons(time: Time): JupiterMoonsInfo Calculates jovicentric positions and velocities of Jupiter's largest 4 moons. |
|
| lagrangePoint fun lagrangePoint(point: Int, time: Time, majorBody: Body, minorBody: Body): StateVector Calculates one of the 5 Lagrange points for a pair of co-orbiting bodies. |
|
| lagrangePointFast fun lagrangePointFast(point: Int, majorState: StateVector, majorMass: Double, minorState: StateVector, minorMass: Double): StateVector Calculates one of the 5 Lagrange points from body masses and state vectors. |
|
| libration fun libration(time: Time): LibrationInfo Calculates the Moon's libration angles at a given moment in time. |
|
| localSolarEclipsesAfter fun localSolarEclipsesAfter(startTime: Time, observer: Observer): Sequence<LocalSolarEclipseInfo> Enumerates a series of consecutive local solar eclipses that occur after a given time. |
|
| lunarApsidesAfter fun lunarApsidesAfter(startTime: Time): Sequence<ApsisInfo> Enumerates a series of consecutive lunar apsides that occur after a given time. |
|
| lunarEclipsesAfter fun lunarEclipsesAfter(startTime: Time): Sequence<LunarEclipseInfo> Enumerates a series of consecutive lunar eclipses that occur after a given time. |
|
| massProduct fun massProduct(body: Body): Double Returns the product of mass and universal gravitational constant of a Solar System body. |
|
| moonNodesAfter fun moonNodesAfter(startTime: Time): Sequence<NodeEventInfo> Enumerates a series of consecutive ascending/descending nodes of the Moon. |
|
| moonPhase fun moonPhase(time: Time): Double Returns the Moon's phase as an angle from 0 to 360 degrees. |
|
| moonQuartersAfter fun moonQuartersAfter(startTime: Time): Sequence<MoonQuarterInfo> Enumerates a series of consecutive moon quarter phase events. |
|
| nextGlobalSolarEclipse fun nextGlobalSolarEclipse(prevEclipseTime: Time): GlobalSolarEclipseInfo Searches for the next global solar eclipse in a series. |
|
| nextLocalSolarEclipse fun nextLocalSolarEclipse(prevEclipseTime: Time, observer: Observer): LocalSolarEclipseInfo Searches for the next local solar eclipse in a series. |
|
| nextLunarApsis fun nextLunarApsis(apsis: ApsisInfo): ApsisInfo Finds the next lunar perigee or apogee event in a series. |
|
| nextLunarEclipse fun nextLunarEclipse(prevEclipseTime: Time): LunarEclipseInfo Searches for the next lunar eclipse in a series. |
|
| nextMoonNode fun nextMoonNode(prevNode: NodeEventInfo): NodeEventInfo Searches for the next time when the Moon's center crosses through the ecliptic plane. |
|
| nextMoonQuarter fun nextMoonQuarter(mq: MoonQuarterInfo): MoonQuarterInfo Continues searching for lunar quarters from a previous search. |
|
| nextPlanetApsis fun nextPlanetApsis(body: Body, apsis: ApsisInfo): ApsisInfo Finds the next planetary perihelion or aphelion event in a series. |
|
| nextTransit fun nextTransit(body: Body, prevTransitTime: Time): TransitInfo Searches for another transit of Mercury or Venus. |
|
| observerGravity fun observerGravity(latitude: Double, height: Double): Double Calculates the gravitational acceleration experienced by an observer on the Earth. |
|
| pairLongitude fun pairLongitude(body1: Body, body2: Body, time: Time): Double Returns one body's ecliptic longitude with respect to another, as seen from the Earth. |
|
| planetApsidesAfter fun planetApsidesAfter(body: Body, startTime: Time): Sequence<ApsisInfo> Enumerates a series of consecutive planetary perihelia/aphelia events. |
|
| planetOrbitalPeriod fun planetOrbitalPeriod(body: Body): Double Returns the average number of days it takes for a planet to orbit the Sun. |
|
| radiansToDegrees fun Double.radiansToDegrees(): Double Convert an angle expressed in radians to an angle expressed in degrees. |
|
| refractionAngle fun refractionAngle(refraction: Refraction, altitude: Double): Double Calculates the amount of "lift" to an altitude angle caused by atmospheric refraction. |
|
| rotationAxis fun rotationAxis(body: Body, time: Time): AxisInfo Calculates information about a body's rotation axis at a given time. |
|
| rotationEclEqd fun rotationEclEqd(time: Time): RotationMatrix Calculates a rotation matrix from J2000 mean ecliptic (ECL) to equatorial of-date (EQD). |
|
| rotationEclEqj fun rotationEclEqj(): RotationMatrix Calculates a rotation matrix from J2000 mean ecliptic (ECL) to J2000 mean equator (EQJ). |
|
| rotationEclHor fun rotationEclHor(time: Time, observer: Observer): RotationMatrix Calculates a rotation matrix from J2000 mean ecliptic (ECL) to horizontal (HOR). |
|
| rotationEctEqd fun rotationEctEqd(time: Time): RotationMatrix Calculates a rotation matrix from true ecliptic of date (ECT) to equator of date (EQD). |
|
| rotationEctEqj fun rotationEctEqj(time: Time): RotationMatrix Calculates a rotation matrix from true ecliptic of date (ECT) to J2000 mean equator (EQJ). |
|
| rotationEqdEcl fun rotationEqdEcl(time: Time): RotationMatrix Calculates a rotation matrix from equatorial of-date (EQD) to J2000 mean ecliptic (ECL). |
|
| rotationEqdEct fun rotationEqdEct(time: Time): RotationMatrix Calculates a rotation matrix from equator of date (EQD) to true ecliptic of date (ECT). |
|
| rotationEqdEqj fun rotationEqdEqj(time: Time): RotationMatrix Calculates a rotation matrix from equatorial of-date (EQD) to J2000 mean equator (EQJ). |
|
| rotationEqdHor fun rotationEqdHor(time: Time, observer: Observer): RotationMatrix Calculates a rotation matrix from equatorial of-date (EQD) to horizontal (HOR). |
|
| rotationEqjEcl fun rotationEqjEcl(): RotationMatrix Calculates a rotation matrix from J2000 mean equator (EQJ) to J2000 mean ecliptic (ECL). |
|
| rotationEqjEct fun rotationEqjEct(time: Time): RotationMatrix Calculates a rotation matrix from J2000 mean equator (EQJ) to true ecliptic of date (ECT). |
|
| rotationEqjEqd fun rotationEqjEqd(time: Time): RotationMatrix Calculates a rotation matrix from J2000 mean equator (EQJ) to equatorial of-date (EQD). |
|
| rotationEqjGal fun rotationEqjGal(): RotationMatrix Calculates a rotation matrix from galactic (GAL) to J2000 mean equator (EQJ). |
|
| rotationEqjHor fun rotationEqjHor(time: Time, observer: Observer): RotationMatrix Calculates a rotation matrix from J2000 mean equator (EQJ) to horizontal (HOR). |
|
| rotationGalEqj fun rotationGalEqj(): RotationMatrix Calculates a rotation matrix from galactic (GAL) to J2000 mean equator (EQJ). |
|
| rotationHorEcl fun rotationHorEcl(time: Time, observer: Observer): RotationMatrix Calculates a rotation matrix from horizontal (HOR) to J2000 mean ecliptic (ECL). |
|
| rotationHorEqd fun rotationHorEqd(time: Time, observer: Observer): RotationMatrix Calculates a rotation matrix from horizontal (HOR) to equatorial of-date (EQD). |
|
| rotationHorEqj fun rotationHorEqj(time: Time, observer: Observer): RotationMatrix Calculates a rotation matrix from horizontal (HOR) to J2000 equatorial (EQJ). This is one of the family of functions that returns a rotation matrix for converting from one orientation to another. Source: HOR = horizontal system (x=North, y=West, z=Zenith). Target: EQJ = equatorial system, using equator at the J2000 epoch. |
|
| search fun search(time1: Time, time2: Time, toleranceSeconds: Double, func: SearchContext): Time? Searches for a time at which a function's value increases through zero. |
|
| searchAltitude fun searchAltitude(body: Body, observer: Observer, direction: Direction, startTime: Time, limitDays: Double, altitude: Double): Time? Finds the next time the center of a body reaches a given altitude. |
|
| searchGlobalSolarEclipse fun searchGlobalSolarEclipse(startTime: Time): GlobalSolarEclipseInfo Searches for a solar eclipse visible anywhere on the Earth's surface. |
|
| searchHourAngle fun searchHourAngle(body: Body, observer: Observer, hourAngle: Double, startTime: Time, direction: Int = +1): HourAngleInfo Searches for the time when the center of a body reaches a specified hour angle as seen by an observer on the Earth. |
|
| searchLocalSolarEclipse fun searchLocalSolarEclipse(startTime: Time, observer: Observer): LocalSolarEclipseInfo Searches for a solar eclipse visible at a specific location on the Earth's surface. |
|
| searchLunarApsis fun searchLunarApsis(startTime: Time): ApsisInfo Finds the date and time of the Moon's perigee or apogee. |
|
| searchLunarEclipse fun searchLunarEclipse(startTime: Time): LunarEclipseInfo Searches for a lunar eclipse. |
|
| searchMaxElongation fun searchMaxElongation(body: Body, startTime: Time): ElongationInfo Finds a date and time when Mercury or Venus reaches its maximum angle from the Sun as seen from the Earth. |
|
| searchMoonNode fun searchMoonNode(startTime: Time): NodeEventInfo Searches for a time when the Moon's center crosses through the ecliptic plane. |
|
| searchMoonPhase fun searchMoonPhase(targetLon: Double, startTime: Time, limitDays: Double): Time? Searches for the time that the Moon reaches a specified phase. |
|
| searchMoonQuarter fun searchMoonQuarter(startTime: Time): MoonQuarterInfo Finds the first lunar quarter after the specified date and time. A lunar quarter is one of the following four lunar phase events: new moon, first quarter, full moon, third quarter. This function finds the lunar quarter that happens soonest after the specified date and time. |
|
| searchPeakMagnitude fun searchPeakMagnitude(body: Body, startTime: Time): IlluminationInfo Searches for the date and time Venus will next appear brightest as seen from the Earth. |
|
| searchPlanetApsis fun searchPlanetApsis(body: Body, startTime: Time): ApsisInfo Finds the first aphelion or perihelion for a planet after a given time. |
|
| searchRelativeLongitude fun searchRelativeLongitude(body: Body, targetRelativeLongitude: Double, startTime: Time): Time Searches for the time when the Earth and another planet are separated by a specified angle in ecliptic longitude, as seen from the Sun. |
|
| searchRiseSet @JvmOverloads fun searchRiseSet(body: Body, observer: Observer, direction: Direction, startTime: Time, limitDays: Double, metersAboveGround: Double = 0.0): Time? Searches for the next time a celestial body rises or sets as seen by an observer on the Earth. |
|
| searchSunLongitude fun searchSunLongitude(targetLon: Double, startTime: Time, limitDays: Double): Time? Searches for the time when the Sun reaches an apparent ecliptic longitude as seen from the Earth. |
|
| searchTransit fun searchTransit(body: Body, startTime: Time): TransitInfo Searches for the first transit of Mercury or Venus after a given date. |
|
| seasons fun seasons(year: Int): SeasonsInfo Finds both equinoxes and both solstices for a given calendar year. |
|
| siderealTime fun siderealTime(time: Time): Double Calculates Greenwich Apparent Sidereal Time (GAST). |
|
| sunPosition fun sunPosition(time: Time): Ecliptic Calculates geocentric ecliptic coordinates for the Sun. |
|
| times operator fun Double.times(vec: Vector): Vector Multiply a scalar by a vector, yielding another vector. |
|
| transitsAfter fun transitsAfter(body: Body, startTime: Time): Sequence<TransitInfo> Enumerates a series of consecutive transits of Mercury or Venus. |
| Name | Summary |
|---|---|
| AU_PER_LY const val AU_PER_LY: Double = 63241.07708807546 The number of astronomical units per light-year. |
|
| C_AUDAY const val C_AUDAY: Double = 173.1446326846693 The speed of light in AU/day. |
|
| CALLISTO_RADIUS_KM const val CALLISTO_RADIUS_KM: Double = 2410.3 The mean radius of Jupiter's moon Callisto, expressed in kilometers. |
|
| DEG2RAD const val DEG2RAD: Double = 0.017453292519943295 The factor to convert degrees to radians = pi/180. |
|
| EUROPA_RADIUS_KM const val EUROPA_RADIUS_KM: Double = 1560.8 The mean radius of Jupiter's moon Europa, expressed in kilometers. |
|
| GANYMEDE_RADIUS_KM const val GANYMEDE_RADIUS_KM: Double = 2631.2 The mean radius of Jupiter's moon Ganymede, expressed in kilometers. |
|
| HOUR2RAD const val HOUR2RAD: Double = 0.26179938779914946 The factor to convert sidereal hours to radians = pi/12. |
|
| IO_RADIUS_KM const val IO_RADIUS_KM: Double = 1821.6 The mean radius of Jupiter's moon Io, expressed in kilometers. |
|
| JUPITER_EQUATORIAL_RADIUS_KM const val JUPITER_EQUATORIAL_RADIUS_KM: Double = 71492.0 The equatorial radius of Jupiter, expressed in kilometers. |
|
| JUPITER_MEAN_RADIUS_KM const val JUPITER_MEAN_RADIUS_KM: Double = 69911.0 The volumetric mean radius of Jupiter, expressed in kilometers. |
|
| JUPITER_POLAR_RADIUS_KM const val JUPITER_POLAR_RADIUS_KM: Double = 66854.0 The polar radius of Jupiter, expressed in kilometers. |
|
| KM_PER_AU const val KM_PER_AU: Double = 1.4959787069098932E8 The number of kilometers in one astronomical unit (AU). |
|
| MILLISECONDS_PER_DAY const val MILLISECONDS_PER_DAY: Double The number of milliseconds in a day. |
|
| MINUTES_PER_DAY const val MINUTES_PER_DAY: Double The number of minutes in a day. |
|
| RAD2DEG const val RAD2DEG: Double = 57.29577951308232 The factor to convert radians to degrees = 180/pi. |
|
| RAD2HOUR const val RAD2HOUR: Double = 3.819718634205488 The factor to convert radians to sidereal hours = 12/pi. |
|
| SECONDS_PER_DAY const val SECONDS_PER_DAY: Double The number of seconds in a day. |