//astronomy/io.github.cosinekitty.astronomy
| 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. |