def toordinal(self):
"""Return the ordinal date of this Hindu lunar date."""
approx = OldHindu.EPOCH + (self.SIDEREAL_YEAR *
(self.year + self.LUNAR_ERA +
((self.month - 1) / 12)))
s = int(
math.floor(approx -
((1 / 360) * self.SIDEREAL_YEAR *
((self.hindu_solar_longitude(approx) -
((self.month - 1) * 30) + 180) % 360) - 180)))
k = self.lunar_day_from_moment(s + Clock.days_from_hours(6))
if (3 < k < 27):
temp = k
else:
mid = self.lunar_fromordinal(s - 15)
if ((mid.month != self.month)
or (mid.leap_month and not self.leap_month)):
temp = ((k + 15) % 30) - 15
else:
temp = ((k - 15) % 30) + 15
est = s + self.day - temp
tau = est - (
(self.lunar_day_from_moment(est + Clock.days_from_hours(6)) -
self.day + 15) % 30) + 15
date = next_int(
tau - 1, lambda d: self.lunar_day_from_moment(self.sunrise(d)) in
[self.day, amod(self.day + 1, 30)])
return date + 1 if self.leap_day else date
def toordinal(self):
"""Return the ordinal date corresponding to Hindu lunar date, l_date."""
approx = (OldHindu.EPOCH + self.MEAN_SIDEREAL_YEAR *
(self.year + self.LUNAR_ERA + ((self.month - 1) / 12)))
s = int(
math.floor(approx - 1 / 360 * self.MEAN_SIDEREAL_YEAR *
(((sidereal_solar_longitude(approx) -
(self.month - 1) * 30 + 180) % 360) - 180)))
k = self.day_from_moment(s + Clock.days_from_hours(6))
if (3 < k < 27):
temp = k
else:
mid = self.fromordinal(s - 15)
if ((mid.month != self.month)
or (mid.leap_month and not self.leap_month)):
temp = ((k + 15) % 30) - 15
else:
temp = ((k - 15) % 30) + 15
est = s + self.day - temp
tau = est - ((self.day_from_moment(est + Clock.days_from_hours(6)) -
self.day + 15) % 30) + 15
date = next_int(
tau - 1, lambda d: (self.day_from_moment(self.alt_sunrise(d)) in
[self.day, amod(self.day + 1, 30)]))
return (date + 1) if self.leap_day else date
def approx_moment_of_depression(self, tee, alpha, early):
"""Return the moment in local time near tee when depression angle
of sun is alpha (negative if above horizon) at location;
early is true when MORNING event is sought and false for EVENING.
Raise VlueError if depression angle is not reached."""
ttry = self.sine_offset(tee, alpha)
date = Clock.ordinal_from_moment(tee)
if alpha >= 0:
if early:
alt = date
else:
alt = date + 1
else:
alt = date + Clock.days_from_hours(12)
if abs(ttry) > 1:
value = self.sine_offset(alt, alpha)
else:
value = ttry
if abs(value) <= 1:
temp = -1 if early else 1
temp *= mod(Clock.days_from_hours(12) + arcsin_degrees(value) / 360, 1) - Clock.days_from_hours(6)
temp += date + Clock.days_from_hours(12)
return self.local_from_apparent(temp)
else:
raise ValueError("Depression angle not reached")
def location(cls, tee):
"""Return location of Beijing; time zone varies with time, tee."""
year = GregorianDate.to_year(int(math.floor(tee)))
if (year < 1929):
return Location(angle(39, 55, 0), angle(116, 25, 0), 43.5,
Clock.days_from_hours(1397 / 180))
else:
return Location(angle(39, 55, 0), angle(116, 25, 0), 43.5,
Clock.days_from_hours(8))
def testUniversalFromDynamical(self):
date = GregorianDate(1977, MonthOfYear.FEBRUARY, 18)
time = Clock(3, 37, 40).to_time()
td = date.toordinal() + time
utc = universal_from_dynamical(td)
clk = Clock.from_moment(utc)
self.assertEqual(clk.hour, 3)
self.assertEqual(clk.minute, 36)
self.assertEqual(int(round(clk.second)), 52)
def japanese_location(tee):
"""Return the location for Japanese calendar; varies with moment, tee."""
year = GregorianDate.to_year(int(math.floor(tee)))
if (year < 1888):
# Tokyo (139 deg 46 min east) local time
loc = Location(mpf(35.7), angle(139, 46, 0), 24,
Clock.days_from_hours(9 + 143 / 450))
else:
# Longitude 135 time zone
loc = Location(35, 135, 0, Clock.days_from_hours(9))
return loc
def equation_of_time(tee):
"""Return the equation of time (as fraction of day) for moment, tee.
Adapted from "Astronomical Algorithms" by Jean Meeus,
Willmann_Bell, Inc., 1991."""
c = julian_centuries(tee)
lamb = poly(c, [mpf(280.46645), mpf(36000.76983), mpf(0.0003032)])
anomaly = poly(
c,
[mpf(357.52910),
mpf(35999.05030),
mpf(-0.0001559),
mpf(-0.00000048)])
eccentricity = poly(
c, [mpf(0.016708617),
mpf(-0.000042037),
mpf(-0.0000001236)])
varepsilon = obliquity(tee)
y = pow(tan_degrees(varepsilon / 2), 2)
equation = (
(1 / 2 / pi) *
(y * sin_degrees(2 * lamb) + -2 * eccentricity * sin_degrees(anomaly) +
(4 * eccentricity * y * sin_degrees(anomaly) * cos_degrees(2 * lamb))
+ -0.5 * y * y * sin_degrees(4 * lamb) +
-1.25 * eccentricity * eccentricity * sin_degrees(2 * anomaly)))
return signum(equation) * min(abs(equation), Clock.days_from_hours(
mpf(12)))
class BahaiDate(object):
EPOCH = GregorianDate(1844, MonthOfYear.MARCH, 21).toordinal()
HAIFA = Location(mpf(32.82), 35, 0, Clock.days_from_hours(2))
AYYAM_I_HA = 0
def __init__(self, major, cycle, year, month, day):
self.major = major
self.cycle = cycle
self.year = year
self.month = month
self.day = day
def to_tuple(self):
return (self.major, self.cycle, self.year, self.month, self.day)
def toordinal(self):
raise NotImplementedError()
@classmethod
def fromordinal(cls, ordinal):
raise NotImplementedError()
@classmethod
def new_year(cls, gregorian_year):
"""Return ordinal date of Bahai New Year in Gregorian year, 'gregorian_year'."""
return GregorianDate(gregorian_year, MonthOfYear.MARCH, 21).toordinal()
@classmethod
def sunset_in_haifa(cls, ordinal):
"""Return universal time of sunset of evening
before ordinal date in Haifa."""
return cls.HAIFA.universal_from_standard(cls.HAIFA.sunset(ordinal))
def __eq__(self, other):
return isinstance(other, BahaiDate) and all(
map(lambda (x, y): x == y, zip(self.to_tuple(), other.to_tuple())))
def __ne__(self, other):
return not self.__eq__(other)
def __lt__(self, other):
return isinstance(other, BahaiDate) and reduce_cond(
lambda _, (x, y): x < y, lambda r, (x, y): not r and x == y,
zip(self.to_tuple(), other.to_tuple()), False)
def __le__(self, other):
return isinstance(other, BahaiDate) and reduce_cond(
lambda _, (x, y): x <= y, lambda r, (x, y): not r and x == y,
zip(self.to_tuple(), other.to_tuple()), False)
def __gt__(self, other):
return isinstance(other, BahaiDate) and reduce_cond(
lambda _, (x, y): x > y, lambda r, (x, y): not r and x == y,
zip(self.to_tuple(), other.to_tuple()), False)
def __ge__(self, other):
return isinstance(other, BahaiDate) and reduce_cond(
lambda _, (x, y): x >= y, lambda r, (x, y): not r and x == y,
zip(self.to_tuple(), other.to_tuple()), False)
class ObservationalIslamicDate(IslamicDate):
# (Cairo, Egypt).
LOCATION = Location(mpf(30.1), mpf(31.3), 200, Clock.days_from_hours(2))
def __init__(self, year, month, day):
IslamicDate.__init__(self, year, month, day)
def toordinal(self):
"""Return ordinal date equivalent to Observational Islamic date, i_date."""
midmonth = self.EPOCH + int(
math.floor((((self.year - 1) * 12) + self.month - 0.5) *
MEAN_SYNODIC_MONTH))
return (self.LOCATION.phasis_on_or_before(midmonth) + self.day - 1)
@classmethod
def fromordinal(cls, ordinal):
"""Return Observational Islamic date (year month day)
corresponding to ordinal date, 'ordinal'."""
crescent = cls.LOCATION.phasis_on_or_before(ordinal)
elapsed_months = int(round(
(crescent - cls.EPOCH) / MEAN_SYNODIC_MONTH))
year = int(math.floor(elapsed_months / 12)) + 1
month = (elapsed_months % 12) + 1
day = (ordinal - crescent) + 1
return ObservationalIslamicDate(year, month, day)
def molad(cls, month, year):
"""Return moment of mean conjunction of month in Hebrew year."""
y = year + 1 if month < HebrewMonth.TISHRI else year
months_elapsed = month - HebrewMonth.TISHRI + int(
math.floor((235 * y - 234) / 19))
return cls.EPOCH - Fraction(876, 25920) + months_elapsed * (
29 + Clock.days_from_hours(12) + Fraction(793, 25920))
def fromordinal(cls, ordinal):
"""Return Old Hindu solar date equivalent to ordinal date ordinal."""
sun = cls.hindu_day_count(ordinal) + Clock.days_from_hours(6)
year = int(math.floor(sun / cls.ARYA_SOLAR_YEAR))
month = (int(math.floor(sun / cls.ARYA_SOLAR_MONTH)) % 12) + 1
day = int(math.floor(sun % cls.ARYA_SOLAR_MONTH)) + 1
return OldHinduSolarDate(year, month, day)
def sunset(cls, date):
"""Return sunset at HINDU_LOCATION on date, date."""
return (date + Clock.days_from_hours(18) +
((cls.UJJAIN.longitude - cls.LOCATION.longitude) / 360) -
cls.equation_of_time(date) +
(((1577917828 / 1582237828) / 360) *
(-cls.ascensional_difference(date, cls.LOCATION) +
(3 / 4 * cls.solar_sidereal_difference(date)))))
def sunrise(cls, date):
"""Return the sunrise at hindu_location on date, date."""
return (date + Clock.days_from_hours(6) +
((cls.UJJAIN.longitude - cls.LOCATION.longitude) / 360) -
cls.equation_of_time(date) +
((1577917828 / 1582237828 / 360) *
(cls.ascensional_difference(date, cls.LOCATION) +
(1 / 4 * cls.solar_sidereal_difference(date)))))
def testDynamicalFromUniversal(self):
date = GregorianDate(1977, MonthOfYear.FEBRUARY, 18)
time = Clock(3, 36, 52).to_time()
utc = date.toordinal() + time
td = dynamical_from_universal(utc)
clk = Clock.from_moment(td)
self.assertEqual(clk.hour, 3)
self.assertEqual(clk.minute, 37)
self.assertEqual(int(round(clk.second)), 40)
date = GregorianDate(333, MonthOfYear.FEBRUARY, 6)
time = Clock(6, 0, 0).to_time()
utc = date.toordinal() + time
td = dynamical_from_universal(utc)
clk = Clock.from_moment(td)
self.assertEqual(clk.hour, 7)
self.assertEqual(clk.minute, 57)
self.assertAlmostEqual(clk.second, 54.66054, 4)
def vietnamese_location(tee):
"""Return the location for Vietnamese calendar is Hanoi;
varies with moment, tee. Time zone has changed over the years."""
if (tee < GregorianDate.new_year(1968)):
z = 8
else:
z = 7
return Location(angle(21, 2, 0), angle(105, 51, 0), 12,
Clock.days_from_hours(z))
def moment_of_depression(self, approx, alpha, early):
"""Return the moment in local time near approx when depression
angle of sun is alpha (negative if above horizon) at location;
early is true when MORNING event is sought, and false for EVENING."""
tee = self.approx_moment_of_depression(approx, alpha, early)
if abs(approx - tee) < Clock.days_from_seconds(30):
return tee
else:
return self.moment_of_depression(tee, alpha, early)
def sundial_time(cls, tee):
"""Return Hindu local time of temporal moment, tee."""
date = Clock.ordinal_from_moment(tee)
time = tee % 1
q = int(math.floor(4 * time))
if q == 0:
a = cls.sunset(date - 1)
b = cls.sunrise(date)
t = Clock.days_from_hours(-6)
elif q == 3:
a = cls.sunset(date)
b = cls.sunrise(date + 1)
t = Clock.days_from_hours(18)
else:
a = cls.sunrise(date)
b = cls.sunset(date)
t = Clock.days_from_hours(6)
return a + (2 * (b - a) * (time - t))
def fromordinal(cls, ordinal):
"""Return Old Hindu lunar date equivalent to ordinal date 'ordinal'."""
sun = cls.hindu_day_count(ordinal) + Clock.days_from_hours(6)
new_moon = sun - (sun % cls.ARYA_LUNAR_MONTH)
leap = cls.ARYA_SOLAR_MONTH - cls.ARYA_LUNAR_MONTH >= new_moon % cls.ARYA_SOLAR_MONTH and new_moon % cls.ARYA_SOLAR_MONTH > 0
month = 1 + int(math.ceil(new_moon / cls.ARYA_SOLAR_MONTH) % 12)
day = (int(math.floor(sun / cls.ARYA_LUNAR_DAY)) % 30) + 1
year = int(
math.ceil(
(new_moon + cls.ARYA_SOLAR_MONTH) / cls.ARYA_SOLAR_YEAR)) - 1
return OldHinduLunarDate(year, month, leap, day)
def moonrise(self, date):
"""Return the standard time of moonrise on fixed, date,
and location, location."""
t = self.universal_from_standard(date)
waning = (lunar_phase(t) > 180)
alt = self.observed_lunar_altitude(t)
offset = alt / 360
if waning and (offset > 0):
approx = t + 1 - offset
elif waning:
approx = t - offset
else:
approx = t + (1 / 2) + offset
rise = binary_search(approx - Clock.days_from_hours(3),
approx + Clock.days_from_hours(3),
lambda u, l: ((u - l) < Clock.days_from_hours(1/60)),
lambda x: self.observed_lunar_altitude(x) > 0)
if rise < (t + 1):
return self.standard_from_universal(rise)
raise ValueError()
def hindu_tithi_occur(l_month, tithi, tee, l_year):
"""Return the ordinal date of occurrence of Hindu lunar tithi prior
to sundial time, tee, in Hindu lunar month, l_month, and
year, l_year."""
approx = hindu_date_occur(l_month, int(math.floor(tithi)), l_year)
lunar = HinduLunarDate.day_at_or_after(tithi, approx - 2)
ttry = Clock.ordinal_from_moment(lunar)
tee_h = HinduLunarDate.UJJAIN.standard_from_sundial(ttry + tee)
if lunar <= tee_h or HinduLunarDate.lunar_phase(
HinduLunarDate.UJJAIN.standard_from_sundial(ttry + 1 +
tee)) > 12 * tithi:
return ttry
else:
return ttry + 1
def ephemeris_correction(tee):
"""Return Dynamical Time minus Universal Time (in days) for
moment, tee. Adapted from "Astronomical Algorithms"
by Jean Meeus, Willmann_Bell, Inc., 1991."""
year = GregorianDate.to_year(int(math.floor(tee)))
c = GregorianDate.date_difference(
GregorianDate(1900, MonthOfYear.JANUARY, 1),
GregorianDate(year, MonthOfYear.JULY, 1)) / mpf(36525)
if 1988 <= year <= 2019:
return 1 / 86400 * (year - 1933)
elif 1900 <= year <= 1987:
return poly(c, [
mpf(-0.00002),
mpf(0.000297),
mpf(0.025184),
mpf(-0.181133),
mpf(0.553040),
mpf(-0.861938),
mpf(0.677066),
mpf(-0.212591)
])
elif 1800 <= year <= 1899:
return poly(c, [
mpf(-0.000009),
mpf(0.003844),
mpf(0.083563),
mpf(0.865736),
mpf(4.867575),
mpf(15.845535),
mpf(31.332267),
mpf(38.291999),
mpf(28.316289),
mpf(11.636204),
mpf(2.043794)
])
elif 1700 <= year <= 1799:
return 1 / 86400 * poly(
year - 1700,
[8.118780842, -0.005092142, 0.003336121, -0.0000266484])
elif 1620 <= year <= 1699:
return 1 / 86400 * poly(
year - 1600,
[mpf(196.58333), mpf(-4.0675),
mpf(0.0219167)])
else:
x = Clock.days_from_hours(mpf(12)) + GregorianDate.date_difference(
GregorianDate(1810, MonthOfYear.JANUARY, 1),
GregorianDate(year, MonthOfYear.JANUARY, 1))
return 1 / 86400 * (((x * x) / mpf(41048480)) - 15)
def korean_location(tee):
"""Return the location for Korean calendar; varies with moment, tee."""
# Seoul city hall at a varying time zone.
if (tee < GregorianDate(1908, MonthOfYear.APRIL, 1).toordinal()):
#local mean time for longitude 126 deg 58 min
z = 3809 / 450
elif (tee < GregorianDate(1912, MonthOfYear.JANUARY, 1).toordinal()):
z = 8.5
elif (tee < GregorianDate(1954, MonthOfYear.MARCH, 21).toordinal()):
z = 9
elif (tee < GregorianDate(1961, MonthOfYear.AUGUST, 10).toordinal()):
z = 8.5
else:
z = 9
return Location(angle(37, 34, 0), angle(126, 58, 0), 0,
Clock.days_from_hours(z))
def standard_from_sundial(self, tee):
"""Return standard time of temporal moment, tee, at location, location."""
date = Clock.ordinal_from_moment(tee)
hour = 24 * mod(tee, 1)
if 6 <= hour <= 18:
h = self.daytime_temporal_hour(date)
elif (hour < 6):
h = self.nighttime_temporal_hour(date - 1)
else:
h = self.nighttime_temporal_hour(date)
# return
if 6 <= hour <= 18:
return self.sunrise(date) + ((hour - 6) * h)
elif hour < 6:
return self.sunset(date - 1) + ((hour + 6) * h)
else:
return self.sunset(date) + ((hour - 18) * h)
def toordinal(self):
"""Return ordinal date corresponding to Old Hindu lunar date l_date."""
mina = ((12 * self.year) - 1) * self.ARYA_SOLAR_MONTH
lunar_new_year = self.ARYA_LUNAR_MONTH * (
int(math.floor(mina / self.ARYA_LUNAR_MONTH)) + 1)
if not self.leap and int(
math.ceil((lunar_new_year - mina) /
(self.ARYA_SOLAR_MONTH -
self.ARYA_LUNAR_MONTH))) <= self.month:
temp = self.month
else:
temp = self.month - 1
temp = self.EPOCH + lunar_new_year + (self.ARYA_LUNAR_MONTH * temp) + (
(self.day - 1) * self.ARYA_LUNAR_DAY) + Clock.days_from_hours(-6)
return int(math.ceil(temp))
class HinduDate(object):
SIDEREAL_YEAR = 365 + 279457 / 1080000
ANOMALISTIC_YEAR = 1577917828000 / (4320000000 - 387)
CREATION = OldHindu.EPOCH - 1955880000 * SIDEREAL_YEAR
UJJAIN = Location(angle(23, 9, 0), angle(75, 46, 6), 0,
Clock.days_from_hours(5 + 461 / 9000))
LOCATION = UJJAIN
def __init__(self, year, month, leap_month, day, leap_day):
self.year = year
self.month = month
self.leap_month = leap_month
self.day = day
self.leap_day = leap_day
def to_tuple(self):
return (self.year, self.month, self.leap_month, self.day,
self.leap_day)
def __eq__(self, other):
return isinstance(other, HinduDate) and all(
map(lambda (x, y): x == y, zip(self.to_tuple(), other.to_tuple())))
def __ne__(self, other):
return not self.__eq__(other)
def __lt__(self, other):
return isinstance(other, HinduDate) and reduce_cond(
lambda _, (x, y): x < y, lambda r, (x, y): not r and x == y,
zip(self.to_tuple(), other.to_tuple()), False)
def __le__(self, other):
return isinstance(other, HinduDate) and reduce_cond(
lambda _, (x, y): x <= y, lambda r, (x, y): not r and x == y,
zip(self.to_tuple(), other.to_tuple()), False)
def __gt__(self, other):
return isinstance(other, HinduDate) and reduce_cond(
lambda _, (x, y): x > y, lambda r, (x, y): not r and x == y,
zip(self.to_tuple(), other.to_tuple()), False)
def __ge__(self, other):
return isinstance(other, HinduDate) and reduce_cond(
lambda _, (x, y): x >= y, lambda r, (x, y): not r and x == y,
zip(self.to_tuple(), other.to_tuple()), False)
@classmethod
def sine_table(cls, entry):
"""Return the value for entry in the Hindu sine table.
Entry, entry, is an angle given as a multiplier of 225'."""
exact = 3438 * sin_degrees(entry * angle(0, 225, 0))
error = 0.215 * signum(exact) * signum(abs(exact) - 1716)
return int(round(exact + error)) / 3438
@classmethod
def sine(cls, theta):
"""Return the linear interpolation for angle, theta, in Hindu table."""
entry = theta / angle(0, 225, 0)
fraction = entry % 1
return ((fraction * cls.sine_table(int(math.ceil(entry)))) +
((1 - fraction) * cls.sine_table(int(math.floor(entry)))))
@classmethod
def arcsin(cls, amp):
"""Return the inverse of Hindu sine function of amp."""
if (amp < 0):
return -cls.arcsin(-amp)
else:
pos = next_int(0, lambda k: amp <= cls.sine_table(k))
below = cls.sine_table(pos - 1)
return (angle(0, 225, 0) * (pos - 1 +
((amp - below) /
(cls.sine_table(pos) - below))))
@classmethod
def mean_position(cls, tee, period):
"""Return the position in degrees at moment, tee, in uniform circular
orbit of period days."""
return 360 * (((tee - cls.CREATION) / period) % 1)
@classmethod
def true_position(cls, tee, period, size, anomalistic, change):
"""Return the longitudinal position at moment, tee.
period is the period of mean motion in days.
size is ratio of radii of epicycle and deferent.
anomalistic is the period of retrograde revolution about epicycle.
change is maximum decrease in epicycle size."""
lam = cls.mean_position(tee, period)
offset = cls.sine(cls.mean_position(tee, anomalistic))
contraction = abs(offset) * change * size
equation = cls.arcsin(offset * (size - contraction))
return (lam - equation) % 360
@classmethod
def solar_longitude(cls, tee):
"""Return the solar longitude at moment, tee."""
return cls.true_position(tee, cls.SIDEREAL_YEAR, 14 / 360,
cls.ANOMALISTIC_YEAR, 1 / 42)
@classmethod
def zodiac(cls, tee):
"""Return the zodiacal sign of the sun, as integer in range 1..12,
at moment tee."""
return int(math.floor(float(cls.solar_longitude(tee)), 30)) + 1
@classmethod
def equation_of_time(cls, date):
"""Return the time from true to mean midnight of date, date."""
offset = cls.sine(cls.mean_position(date, cls.ANOMALISTIC_YEAR))
equation_sun = (offset * angle(57, 18, 0) * (14 / 360 -
(abs(offset) / 1080)))
return ((cls.daily_motion(date) / 360) * (equation_sun / 360) *
cls.SIDEREAL_YEAR)
@classmethod
def ascensional_difference(cls, date, location):
"""Return the difference between right and oblique ascension
of sun on date, date, at loacel, location."""
sin_delta = (1397 / 3438) * cls.sine(cls.tropical_longitude(date))
phi = location.latitude
diurnal_radius = cls.sine(90 + cls.arcsin(sin_delta))
tan_phi = cls.sine(phi) / cls.sine(90 + phi)
earth_sine = sin_delta * tan_phi
return cls.arcsin(-earth_sine / diurnal_radius)
@classmethod
def daily_motion(cls, date):
"""Return the sidereal daily motion of sun on date, date."""
mean_motion = 360 / cls.SIDEREAL_YEAR
anomaly = cls.mean_position(date, cls.ANOMALISTIC_YEAR)
epicycle = 14 / 360 - abs(cls.sine(anomaly)) / 1080
entry = int(math.floor(float(anomaly), angle(0, 225, 0)))
sine_table_step = cls.sine_table(entry + 1) - cls.sine_table(entry)
factor = -3438 / 225 * sine_table_step * epicycle
return mean_motion * (factor + 1)
@classmethod
def solar_sidereal_difference(cls, date):
"""Return the difference between solar and sidereal day on date, date."""
return cls.daily_motion(date) * cls.rising_sign(date)
@classmethod
def sunrise(cls, date):
"""Return the sunrise at hindu_location on date, date."""
return (date + Clock.days_from_hours(6) +
((cls.UJJAIN.longitude - cls.LOCATION.longitude) / 360) -
cls.equation_of_time(date) +
((1577917828 / 1582237828 / 360) *
(cls.ascensional_difference(date, cls.LOCATION) +
(1 / 4 * cls.solar_sidereal_difference(date)))))
@classmethod
def sunset(cls, date):
"""Return sunset at HINDU_LOCATION on date, date."""
return (date + Clock.days_from_hours(18) +
((cls.UJJAIN.longitude - cls.LOCATION.longitude) / 360) -
cls.equation_of_time(date) +
(((1577917828 / 1582237828) / 360) *
(-cls.ascensional_difference(date, cls.LOCATION) +
(3 / 4 * cls.solar_sidereal_difference(date)))))
@classmethod
def alt_sunrise(cls, date):
"""Return the astronomical sunrise at Hindu location on date, date,
per Lahiri, rounded to nearest minute, as a rational number."""
rise = cls.UJJAIN.dawn(date, angle(0, 47, 0))
return 1 / 24 * 1 / 60 * int(round(rise * 24 * 60))
def midday(self, date):
"""Return standard time on fixed date, date, of midday
at location, location."""
return self.standard_from_local(self.local_from_apparent(date + Clock.days_from_hours(mpf(12))))
def toordinal(self):
"""Return ordinal date corresponding to Old Hindu solar date s_date."""
return int(
math.ceil(self.EPOCH + self.year * self.ARYA_SOLAR_YEAR +
(self.month - 1) * self.ARYA_SOLAR_MONTH + self.day +
Clock.days_from_hours(-30)))
def shiva(gregorian_year):
"""Return the list of ordinal date(s) of Night of Shiva in Gregorian year, 'gregorian_year'."""
return hindu_lunar_event(11, 29, Clock.days_from_hours(24), gregorian_year)
def rama(gregorian_year):
"""Return the list of ordinal date(s) of Rama's Birthday in Gregorian
year, 'gregorian_year'."""
return hindu_lunar_event(1, 9, Clock.days_from_hours(12), gregorian_year)
def dusk(self, date, alpha):
"""Return standard time in evening on fixed date 'date' at
location 'location' when depression angle of sun is alpha."""
result = self.moment_of_depression(date + Clock.days_from_hours(18), alpha, self.EVENING)
return self.standard_from_local(result)
