CalendarAstronomer is a class that can perform the calculations to
* determine the positions of the sun and moon, the time of sunrise and
* sunset, and other astronomy-related data. The calculations it performs
* are in some cases quite complicated, and this utility class saves you
* the trouble of worrying about them.
*
* The measurement of time is a very important part of astronomy. Because
* astronomical bodies are constantly in motion, observations are only valid
* at a given moment in time. Accordingly, each CalendarAstronomer
* object has a time property that determines the date
* and time for which its calculations are performed. You can set and
* retrieve this property with {@link #setDate setDate}, {@link #getDate getDate}
* and related methods.
*
* Almost all of the calculations performed by this class, or by any * astronomer, are approximations to various degrees of accuracy. The * calculations in this class are mostly modelled after those described * in the book * * Practical Astronomy With Your Calculator, by Peter J. * Duffett-Smith, Cambridge University Press, 1990. This is an excellent * book, and if you want a greater understanding of how these calculations * are performed it a very good, readable starting point. *
* WARNING: This class is very early in its development, and
* it is highly likely that its API will change to some degree in the future.
* At the moment, it basically does just enough to support {@link android.icu.util.IslamicCalendar}
* and {@link android.icu.util.ChineseCalendar}.
*
* @author Laura Werner
* @author Alan Liu
* @hide Only a subset of ICU is exposed in Android
* @hide draft / provisional / internal are hidden on Android
*/
public class CalendarAstronomer {
//-------------------------------------------------------------------------
// Astronomical constants
//-------------------------------------------------------------------------
/**
* The number of standard hours in one sidereal day.
* Approximately 24.93.
* @hide draft / provisional / internal are hidden on Android
*/
public static final double SIDEREAL_DAY = 23.93446960027;
/**
* The number of sidereal hours in one mean solar day.
* Approximately 24.07.
* @hide draft / provisional / internal are hidden on Android
*/
public static final double SOLAR_DAY = 24.065709816;
/**
* The average number of solar days from one new moon to the next. This is the time
* it takes for the moon to return the same ecliptic longitude as the sun.
* It is longer than the sidereal month because the sun's longitude increases
* during the year due to the revolution of the earth around the sun.
* Approximately 29.53.
*
* @see #SIDEREAL_MONTH
* @hide draft / provisional / internal are hidden on Android
*/
public static final double SYNODIC_MONTH = 29.530588853;
/**
* The average number of days it takes
* for the moon to return to the same ecliptic longitude relative to the
* stellar background. This is referred to as the sidereal month.
* It is shorter than the synodic month due to
* the revolution of the earth around the sun.
* Approximately 27.32.
*
* @see #SYNODIC_MONTH
* @hide draft / provisional / internal are hidden on Android
*/
public static final double SIDEREAL_MONTH = 27.32166;
/**
* The average number number of days between successive vernal equinoxes.
* Due to the precession of the earth's
* axis, this is not precisely the same as the sidereal year.
* Approximately 365.24
*
* @see #SIDEREAL_YEAR
* @hide draft / provisional / internal are hidden on Android
*/
public static final double TROPICAL_YEAR = 365.242191;
/**
* The average number of days it takes
* for the sun to return to the same position against the fixed stellar
* background. This is the duration of one orbit of the earth about the sun
* as it would appear to an outside observer.
* Due to the precession of the earth's
* axis, this is not precisely the same as the tropical year.
* Approximately 365.25.
*
* @see #TROPICAL_YEAR
* @hide draft / provisional / internal are hidden on Android
*/
public static final double SIDEREAL_YEAR = 365.25636;
//-------------------------------------------------------------------------
// Time-related constants
//-------------------------------------------------------------------------
/**
* The number of milliseconds in one second.
* @hide draft / provisional / internal are hidden on Android
*/
public static final int SECOND_MS = 1000;
/**
* The number of milliseconds in one minute.
* @hide draft / provisional / internal are hidden on Android
*/
public static final int MINUTE_MS = 60*SECOND_MS;
/**
* The number of milliseconds in one hour.
* @hide draft / provisional / internal are hidden on Android
*/
public static final int HOUR_MS = 60*MINUTE_MS;
/**
* The number of milliseconds in one day.
* @hide draft / provisional / internal are hidden on Android
*/
public static final long DAY_MS = 24*HOUR_MS;
/**
* The start of the julian day numbering scheme used by astronomers, which
* is 1/1/4713 BC (Julian), 12:00 GMT. This is given as the number of milliseconds
* since 1/1/1970 AD (Gregorian), a negative number.
* Note that julian day numbers and
* the Julian calendar are not the same thing. Also note that
* julian days start at noon, not midnight.
* @hide draft / provisional / internal are hidden on Android
*/
public static final long JULIAN_EPOCH_MS = -210866760000000L;
// static {
// Calendar cal = new GregorianCalendar(TimeZone.getTimeZone("GMT"));
// cal.clear();
// cal.set(cal.ERA, 0);
// cal.set(cal.YEAR, 4713);
// cal.set(cal.MONTH, cal.JANUARY);
// cal.set(cal.DATE, 1);
// cal.set(cal.HOUR_OF_DAY, 12);
// System.out.println("1.5 Jan 4713 BC = " + cal.getTime().getTime());
// cal.clear();
// cal.set(cal.YEAR, 2000);
// cal.set(cal.MONTH, cal.JANUARY);
// cal.set(cal.DATE, 1);
// cal.add(cal.DATE, -1);
// System.out.println("0.0 Jan 2000 = " + cal.getTime().getTime());
// }
/**
* Milliseconds value for 0.0 January 2000 AD.
*/
static final long EPOCH_2000_MS = 946598400000L;
//-------------------------------------------------------------------------
// Assorted private data used for conversions
//-------------------------------------------------------------------------
// My own copies of these so compilers are more likely to optimize them away
static private final double PI = 3.14159265358979323846;
static private final double PI2 = PI * 2.0;
static private final double RAD_HOUR = 12 / PI; // radians -> hours
static private final double DEG_RAD = PI / 180; // degrees -> radians
static private final double RAD_DEG = 180 / PI; // radians -> degrees
//-------------------------------------------------------------------------
// Constructors
//-------------------------------------------------------------------------
/**
* Construct a new CalendarAstronomer object that is initialized to
* the current date and time.
* @hide draft / provisional / internal are hidden on Android
*/
public CalendarAstronomer() {
this(System.currentTimeMillis());
}
/**
* Construct a new CalendarAstronomer object that is initialized to
* the specified time. The time is expressed as a number of milliseconds since
* January 1, 1970 AD (Gregorian).
*
* @see java.util.Date#getTime()
* @hide draft / provisional / internal are hidden on Android
*/
public CalendarAstronomer(long aTime) {
time = aTime;
}
//-------------------------------------------------------------------------
// Time and date getters and setters
//-------------------------------------------------------------------------
/**
* Set the current date and time of this CalendarAstronomer object. All
* astronomical calculations are performed based on this time setting.
*
* @param aTime the date and time, expressed as the number of milliseconds since
* 1/1/1970 0:00 GMT (Gregorian).
*
* @see #setDate
* @see #getTime
* @hide draft / provisional / internal are hidden on Android
*/
public void setTime(long aTime) {
time = aTime;
clearCache();
}
/**
* Set the current date and time of this CalendarAstronomer object. All
* astronomical calculations are performed based on this time setting.
*
* @param jdn the desired time, expressed as a "julian day number",
* which is the number of elapsed days since
* 1/1/4713 BC (Julian), 12:00 GMT. Note that julian day
* numbers start at noon. To get the jdn for
* the corresponding midnight, subtract 0.5.
*
* @see #getJulianDay
* @see #JULIAN_EPOCH_MS
* @hide draft / provisional / internal are hidden on Android
*/
public void setJulianDay(double jdn) {
time = (long)(jdn * DAY_MS) + JULIAN_EPOCH_MS;
clearCache();
julianDay = jdn;
}
/**
* Get the current time of this CalendarAstronomer object,
* represented as the number of milliseconds since
* 1/1/1970 AD 0:00 GMT (Gregorian).
*
* @see #setTime
* @see #getDate
* @hide draft / provisional / internal are hidden on Android
*/
public long getTime() {
return time;
}
/**
* Get the current time of this CalendarAstronomer object,
* represented as a Date object.
*
* @see #setDate
* @see #getTime
* @hide draft / provisional / internal are hidden on Android
*/
public Date getDate() {
return new Date(time);
}
/**
* Get the current time of this CalendarAstronomer object,
* expressed as a "julian day number", which is the number of elapsed
* days since 1/1/4713 BC (Julian), 12:00 GMT.
*
* @see #setJulianDay
* @see #JULIAN_EPOCH_MS
* @hide draft / provisional / internal are hidden on Android
*/
public double getJulianDay() {
if (julianDay == INVALID) {
julianDay = (double)(time - JULIAN_EPOCH_MS) / (double)DAY_MS;
}
return julianDay;
}
//-------------------------------------------------------------------------
// Coordinate transformations, all based on the current time of this object
//-------------------------------------------------------------------------
/**
* Convert from ecliptic to equatorial coordinates.
*
* @param eclipLong The ecliptic longitude
* @param eclipLat The ecliptic latitude
*
* @return The corresponding point in equatorial coordinates.
* @hide draft / provisional / internal are hidden on Android
*/
public final Equatorial eclipticToEquatorial(double eclipLong, double eclipLat)
{
// See page 42 of "Practical Astronomy with your Calculator",
// by Peter Duffet-Smith, for details on the algorithm.
double obliq = eclipticObliquity();
double sinE = Math.sin(obliq);
double cosE = Math.cos(obliq);
double sinL = Math.sin(eclipLong);
double cosL = Math.cos(eclipLong);
double sinB = Math.sin(eclipLat);
double cosB = Math.cos(eclipLat);
double tanB = Math.tan(eclipLat);
return new Equatorial(Math.atan2(sinL*cosE - tanB*sinE, cosL),
Math.asin(sinB*cosE + cosB*sinE*sinL) );
}
//-------------------------------------------------------------------------
// The Sun
//-------------------------------------------------------------------------
//
// Parameters of the Sun's orbit as of the epoch Jan 0.0 1990
// Angles are in radians (after multiplying by PI/180)
//
static final double JD_EPOCH = 2447891.5; // Julian day of epoch
static final double SUN_ETA_G = 279.403303 * PI/180; // Ecliptic longitude at epoch
static final double SUN_OMEGA_G = 282.768422 * PI/180; // Ecliptic longitude of perigee
static final double SUN_E = 0.016713; // Eccentricity of orbit
//double sunR0 = 1.495585e8; // Semi-major axis in KM
//double sunTheta0 = 0.533128 * PI/180; // Angular diameter at R0
// The following three methods, which compute the sun parameters
// given above for an arbitrary epoch (whatever time the object is
// set to), make only a small difference as compared to using the
// above constants. E.g., Sunset times might differ by ~12
// seconds. Furthermore, the eta-g computation is befuddled by
// Duffet-Smith's incorrect coefficients (p.86). I've corrected
// the first-order coefficient but the others may be off too - no
// way of knowing without consulting another source.
// /**
// * Return the sun's ecliptic longitude at perigee for the current time.
// * See Duffett-Smith, p. 86.
// * @return radians
// */
// private double getSunOmegaG() {
// double T = getJulianCentury();
// return (281.2208444 + (1.719175 + 0.000452778*T)*T) * DEG_RAD;
// }
// /**
// * Return the sun's ecliptic longitude for the current time.
// * See Duffett-Smith, p. 86.
// * @return radians
// */
// private double getSunEtaG() {
// double T = getJulianCentury();
// //return (279.6966778 + (36000.76892 + 0.0003025*T)*T) * DEG_RAD;
// //
// // The above line is from Duffett-Smith, and yields manifestly wrong
// // results. The below constant is derived empirically to match the
// // constant he gives for the 1990 EPOCH.
// //
// return (279.6966778 + (-0.3262541582718024 + 0.0003025*T)*T) * DEG_RAD;
// }
// /**
// * Return the sun's eccentricity of orbit for the current time.
// * See Duffett-Smith, p. 86.
// * @return double
// */
// private double getSunE() {
// double T = getJulianCentury();
// return 0.01675104 - (0.0000418 + 0.000000126*T)*T;
// }
/**
* The longitude of the sun at the time specified by this object.
* The longitude is measured in radians along the ecliptic
* from the "first point of Aries," the point at which the ecliptic
* crosses the earth's equatorial plane at the vernal equinox.
*
* Currently, this method uses an approximation of the two-body Kepler's * equation for the earth and the sun. It does not take into account the * perturbations caused by the other planets, the moon, etc. * @hide draft / provisional / internal are hidden on Android */ public double getSunLongitude() { // See page 86 of "Practical Astronomy with your Calculator", // by Peter Duffet-Smith, for details on the algorithm. if (sunLongitude == INVALID) { double[] result = getSunLongitude(getJulianDay()); sunLongitude = result[0]; meanAnomalySun = result[1]; } return sunLongitude; } /** * TODO Make this public when the entire class is package-private. */ /*public*/ double[] getSunLongitude(double julian) { // See page 86 of "Practical Astronomy with your Calculator", // by Peter Duffet-Smith, for details on the algorithm. double day = julian - JD_EPOCH; // Days since epoch // Find the angular distance the sun in a fictitious // circular orbit has travelled since the epoch. double epochAngle = norm2PI(PI2/TROPICAL_YEAR*day); // The epoch wasn't at the sun's perigee; find the angular distance // since perigee, which is called the "mean anomaly" double meanAnomaly = norm2PI(epochAngle + SUN_ETA_G - SUN_OMEGA_G); // Now find the "true anomaly", e.g. the real solar longitude // by solving Kepler's equation for an elliptical orbit // NOTE: The 3rd ed. of the book lists omega_g and eta_g in different // equations; omega_g is to be correct. return new double[] { norm2PI(trueAnomaly(meanAnomaly, SUN_E) + SUN_OMEGA_G), meanAnomaly }; } private static class SolarLongitude { double value; SolarLongitude(double val) { value = val; } } /** * Constant representing the winter solstice. * For use with {@link #getSunTime(SolarLongitude, boolean) getSunTime}. * Note: In this case, "winter" refers to the northern hemisphere's seasons. * @hide draft / provisional / internal are hidden on Android */ public static final SolarLongitude WINTER_SOLSTICE = new SolarLongitude((PI*3)/2); /** * Find the next time at which the sun's ecliptic longitude will have * the desired value. * @hide draft / provisional / internal are hidden on Android */ public long getSunTime(double desired, boolean next) { return timeOfAngle( new AngleFunc() { @Override public double eval() { return getSunLongitude(); } }, desired, TROPICAL_YEAR, MINUTE_MS, next); } /** * Find the next time at which the sun's ecliptic longitude will have * the desired value. * @hide draft / provisional / internal are hidden on Android */ public long getSunTime(SolarLongitude desired, boolean next) { return getSunTime(desired.value, next); } //------------------------------------------------------------------------- // The Moon //------------------------------------------------------------------------- static final double moonL0 = 318.351648 * PI/180; // Mean long. at epoch static final double moonP0 = 36.340410 * PI/180; // Mean long. of perigee static final double moonN0 = 318.510107 * PI/180; // Mean long. of node static final double moonI = 5.145366 * PI/180; // Inclination of orbit static final double moonE = 0.054900; // Eccentricity of orbit // These aren't used right now static final double moonA = 3.84401e5; // semi-major axis (km) static final double moonT0 = 0.5181 * PI/180; // Angular size at distance A static final double moonPi = 0.9507 * PI/180; // Parallax at distance A /** * The position of the moon at the time set on this * object, in equatorial coordinates. * @hide draft / provisional / internal are hidden on Android */ public Equatorial getMoonPosition() { // // See page 142 of "Practical Astronomy with your Calculator", // by Peter Duffet-Smith, for details on the algorithm. // if (moonPosition == null) { // Calculate the solar longitude. Has the side effect of // filling in "meanAnomalySun" as well. double sunLong = getSunLongitude(); // // Find the # of days since the epoch of our orbital parameters. // TODO: Convert the time of day portion into ephemeris time // double day = getJulianDay() - JD_EPOCH; // Days since epoch // Calculate the mean longitude and anomaly of the moon, based on // a circular orbit. Similar to the corresponding solar calculation. double meanLongitude = norm2PI(13.1763966*PI/180*day + moonL0); double meanAnomalyMoon = norm2PI(meanLongitude - 0.1114041*PI/180 * day - moonP0); // // Calculate the following corrections: // Evection: the sun's gravity affects the moon's eccentricity // Annual Eqn: variation in the effect due to earth-sun distance // A3: correction factor (for ???) // double evection = 1.2739*PI/180 * Math.sin(2 * (meanLongitude - sunLong) - meanAnomalyMoon); double annual = 0.1858*PI/180 * Math.sin(meanAnomalySun); double a3 = 0.3700*PI/180 * Math.sin(meanAnomalySun); meanAnomalyMoon += evection - annual - a3; // // More correction factors: // center equation of the center correction // a4 yet another error correction (???) // // TODO: Skip the equation of the center correction and solve Kepler's eqn? // double center = 6.2886*PI/180 * Math.sin(meanAnomalyMoon); double a4 = 0.2140*PI/180 * Math.sin(2 * meanAnomalyMoon); // Now find the moon's corrected longitude double moonLongitude = meanLongitude + evection + center - annual + a4; // // And finally, find the variation, caused by the fact that the sun's // gravitational pull on the moon varies depending on which side of // the earth the moon is on // double variation = 0.6583*PI/180 * Math.sin(2*(moonLongitude - sunLong)); moonLongitude += variation; // // What we've calculated so far is the moon's longitude in the plane // of its own orbit. Now map to the ecliptic to get the latitude // and longitude. First we need to find the longitude of the ascending // node, the position on the ecliptic where it is crossed by the moon's // orbit as it crosses from the southern to the northern hemisphere. // double nodeLongitude = norm2PI(moonN0 - 0.0529539*PI/180 * day); nodeLongitude -= 0.16*PI/180 * Math.sin(meanAnomalySun); double y = Math.sin(moonLongitude - nodeLongitude); double x = Math.cos(moonLongitude - nodeLongitude); moonEclipLong = Math.atan2(y*Math.cos(moonI), x) + nodeLongitude; double moonEclipLat = Math.asin(y * Math.sin(moonI)); moonPosition = eclipticToEquatorial(moonEclipLong, moonEclipLat); } return moonPosition; } /** * The "age" of the moon at the time specified in this object. * This is really the angle between the * current ecliptic longitudes of the sun and the moon, * measured in radians. * * @see #getMoonPhase * @hide draft / provisional / internal are hidden on Android */ public double getMoonAge() { // See page 147 of "Practical Astronomy with your Calculator", // by Peter Duffet-Smith, for details on the algorithm. // // Force the moon's position to be calculated. We're going to use // some the intermediate results cached during that calculation. // getMoonPosition(); return norm2PI(moonEclipLong - sunLongitude); } private static class MoonAge { double value; MoonAge(double val) { value = val; } } /** * Constant representing a new moon. * For use with {@link #getMoonTime(MoonAge, boolean) getMoonTime} * @hide draft / provisional / internal are hidden on Android */ public static final MoonAge NEW_MOON = new MoonAge(0); /** * Find the next or previous time at which the Moon's ecliptic * longitude will have the desired value. *
* @param desired The desired longitude. * @param next true if the next occurrance of the phase * is desired, false for the previous occurrance. * @hide draft / provisional / internal are hidden on Android */ public long getMoonTime(double desired, boolean next) { return timeOfAngle( new AngleFunc() { @Override public double eval() { return getMoonAge(); } }, desired, SYNODIC_MONTH, MINUTE_MS, next); } /** * Find the next or previous time at which the moon will be in the * desired phase. *
* @param desired The desired phase of the moon. * @param next true if the next occurrance of the phase * is desired, false for the previous occurrance. * @hide draft / provisional / internal are hidden on Android */ public long getMoonTime(MoonAge desired, boolean next) { return getMoonTime(desired.value, next); } //------------------------------------------------------------------------- // Interpolation methods for finding the time at which a given event occurs //------------------------------------------------------------------------- private interface AngleFunc { public double eval(); } private long timeOfAngle(AngleFunc func, double desired, double periodDays, long epsilon, boolean next) { // Find the value of the function at the current time double lastAngle = func.eval(); // Find out how far we are from the desired angle double deltaAngle = norm2PI(desired - lastAngle) ; // Using the average period, estimate the next (or previous) time at // which the desired angle occurs. double deltaT = (deltaAngle + (next ? 0 : -PI2)) * (periodDays*DAY_MS) / PI2; double lastDeltaT = deltaT; // Liu long startTime = time; // Liu setTime(time + (long)deltaT); // Now iterate until we get the error below epsilon. Throughout // this loop we use normPI to get values in the range -Pi to Pi, // since we're using them as correction factors rather than absolute angles. do { // Evaluate the function at the time we've estimated double angle = func.eval(); // Find the # of milliseconds per radian at this point on the curve double factor = Math.abs(deltaT / normPI(angle-lastAngle)); // Correct the time estimate based on how far off the angle is deltaT = normPI(desired - angle) * factor; // HACK: // // If abs(deltaT) begins to diverge we need to quit this loop. // This only appears to happen when attempting to locate, for // example, a new moon on the day of the new moon. E.g.: // // This result is correct: // newMoon(7508(Mon Jul 23 00:00:00 CST 1990,false))= // Sun Jul 22 10:57:41 CST 1990 // // But attempting to make the same call a day earlier causes deltaT // to diverge: // CalendarAstronomer.timeOfAngle() diverging: 1.348508727575625E9 -> // 1.3649828540224032E9 // newMoon(7507(Sun Jul 22 00:00:00 CST 1990,false))= // Sun Jul 08 13:56:15 CST 1990 // // As a temporary solution, we catch this specific condition and // adjust our start time by one eighth period days (either forward // or backward) and try again. // Liu 11/9/00 if (Math.abs(deltaT) > Math.abs(lastDeltaT)) { long delta = (long) (periodDays * DAY_MS / 8); setTime(startTime + (next ? delta : -delta)); return timeOfAngle(func, desired, periodDays, epsilon, next); } lastDeltaT = deltaT; lastAngle = angle; setTime(time + (long)deltaT); } while (Math.abs(deltaT) > epsilon); return time; } //------------------------------------------------------------------------- // Other utility methods //------------------------------------------------------------------------- /*** * Given 'value', add or subtract 'range' until 0 <= 'value' < range. * The modulus operator. */ private static final double normalize(double value, double range) { return value - range * Math.floor(value / range); } /** * Normalize an angle so that it's in the range 0 - 2pi. * For positive angles this is just (angle % 2pi), but the Java * mod operator doesn't work that way for negative numbers.... */ private static final double norm2PI(double angle) { return normalize(angle, PI2); } /** * Normalize an angle into the range -PI - PI */ private static final double normPI(double angle) { return normalize(angle + PI, PI2) - PI; } /** * Find the "true anomaly" (longitude) of an object from * its mean anomaly and the eccentricity of its orbit. This uses * an iterative solution to Kepler's equation. * * @param meanAnomaly The object's longitude calculated as if it were in * a regular, circular orbit, measured in radians * from the point of perigee. * * @param eccentricity The eccentricity of the orbit * * @return The true anomaly (longitude) measured in radians */ private double trueAnomaly(double meanAnomaly, double eccentricity) { // First, solve Kepler's equation iteratively // Duffett-Smith, p.90 double delta; double E = meanAnomaly; do { delta = E - eccentricity * Math.sin(E) - meanAnomaly; E = E - delta / (1 - eccentricity * Math.cos(E)); } while (Math.abs(delta) > 1e-5); // epsilon = 1e-5 rad return 2.0 * Math.atan( Math.tan(E/2) * Math.sqrt( (1+eccentricity) /(1-eccentricity) ) ); } /** * Return the obliquity of the ecliptic (the angle between the ecliptic * and the earth's equator) at the current time. This varies due to * the precession of the earth's axis. * * @return the obliquity of the ecliptic relative to the equator, * measured in radians. */ private double eclipticObliquity() { final double epoch = 2451545.0; // 2000 AD, January 1.5 double T = (getJulianDay() - epoch) / 36525; double eclipObliquity = 23.439292 - 46.815/3600 * T - 0.0006/3600 * T*T + 0.00181/3600 * T*T*T; return eclipObliquity * DEG_RAD; } //------------------------------------------------------------------------- // Private data //------------------------------------------------------------------------- /** * Current time in milliseconds since 1/1/1970 AD * @see java.util.Date#getTime */ private long time; // // The following fields are used to cache calculated results for improved // performance. These values all depend on the current time setting // of this object, so the clearCache method is provided. // static final private double INVALID = Double.MIN_VALUE; private transient double julianDay = INVALID; private transient double sunLongitude = INVALID; private transient double meanAnomalySun = INVALID; private transient double moonEclipLong = INVALID; private transient Equatorial moonPosition = null; private void clearCache() { julianDay = INVALID; sunLongitude = INVALID; meanAnomalySun = INVALID; moonEclipLong = INVALID; moonPosition = null; } /** * Represents the position of an object in the sky relative to the ecliptic, * the plane of the earth's orbit around the Sun. * This is a spherical coordinate system in which the latitude * specifies the position north or south of the plane of the ecliptic. * The longitude specifies the position along the ecliptic plane * relative to the "First Point of Aries", which is the Sun's position in the sky * at the Vernal Equinox. *
* Note that Ecliptic objects are immutable and cannot be modified * once they are constructed. This allows them to be passed and returned by * value without worrying about whether other code will modify them. * * @see CalendarAstronomer.Equatorial * @hide Only a subset of ICU is exposed in Android * @hide draft / provisional / internal are hidden on Android */ public static final class Ecliptic { /** * Constructs an Ecliptic coordinate object. *
* @param lat The ecliptic latitude, measured in radians. * @param lon The ecliptic longitude, measured in radians. * @hide draft / provisional / internal are hidden on Android */ public Ecliptic(double lat, double lon) { latitude = lat; longitude = lon; } /** * Return a string representation of this object * @hide draft / provisional / internal are hidden on Android */ @Override public String toString() { return Double.toString(longitude*RAD_DEG) + "," + (latitude*RAD_DEG); } /** * The ecliptic latitude, in radians. This specifies an object's * position north or south of the plane of the ecliptic, * with positive angles representing north. * @hide draft / provisional / internal are hidden on Android */ public final double latitude; /** * The ecliptic longitude, in radians. * This specifies an object's position along the ecliptic plane * relative to the "First Point of Aries", which is the Sun's position * in the sky at the Vernal Equinox, * with positive angles representing east. *
* A bit of trivia: the first point of Aries is currently in the * constellation Pisces, due to the precession of the earth's axis. * @hide draft / provisional / internal are hidden on Android */ public final double longitude; } /** * Represents the position of an * object in the sky relative to the plane of the earth's equator. * The Right Ascension specifies the position east or west * along the equator, relative to the sun's position at the vernal * equinox. The Declination is the position north or south * of the equatorial plane. *
* Note that Equatorial objects are immutable and cannot be modified * once they are constructed. This allows them to be passed and returned by * value without worrying about whether other code will modify them. * * @see CalendarAstronomer.Ecliptic * @hide Only a subset of ICU is exposed in Android * @hide draft / provisional / internal are hidden on Android */ public static final class Equatorial { /** * Constructs an Equatorial coordinate object. *
* @param asc The right ascension, measured in radians. * @param dec The declination, measured in radians. * @hide draft / provisional / internal are hidden on Android */ public Equatorial(double asc, double dec) { ascension = asc; declination = dec; } /** * Return a string representation of this object, with the * angles measured in degrees. * @hide draft / provisional / internal are hidden on Android */ @Override public String toString() { return Double.toString(ascension*RAD_DEG) + "," + (declination*RAD_DEG); } /** * Return a string representation of this object with the right ascension * measured in hours, minutes, and seconds. * @hide draft / provisional / internal are hidden on Android */ public String toHmsString() { return radToHms(ascension) + "," + radToDms(declination); } /** * The right ascension, in radians. * This is the position east or west along the equator * relative to the sun's position at the vernal equinox, * with positive angles representing East. * @hide draft / provisional / internal are hidden on Android */ public final double ascension; /** * The declination, in radians. * This is the position north or south of the equatorial plane, * with positive angles representing north. * @hide draft / provisional / internal are hidden on Android */ public final double declination; } static private String radToHms(double angle) { int hrs = (int) (angle*RAD_HOUR); int min = (int)((angle*RAD_HOUR - hrs) * 60); int sec = (int)((angle*RAD_HOUR - hrs - min/60.0) * 3600); return Integer.toString(hrs) + "h" + min + "m" + sec + "s"; } static private String radToDms(double angle) { int deg = (int) (angle*RAD_DEG); int min = (int)((angle*RAD_DEG - deg) * 60); int sec = (int)((angle*RAD_DEG - deg - min/60.0) * 3600); return Integer.toString(deg) + "\u00b0" + min + "'" + sec + "\""; } }