public static void CalcMoonTimes(GPLocationProvider e, GPGregorianTime vc, out GPGregorianTime rise, out GPGregorianTime set)
{
double UT;
rise = null;
set = null;
// inicializacia prvej hodnoty ELEVATION
vc.setDayHours(0.0);
vc.normalizeValues();
UT = vc.getJulianGreenwichTime();
GPJulianTime start = new GPJulianTime();
GPJulianTime time;
start.setLocalJulianDay(vc.getJulianGreenwichTime());
TRiseSet rs;
set = null;
rise = null;
time = GPAstroEngine.GetNextMoonEvent(start, e, out rs);
while (time.getLocalJulianDay() < UT + 1)
{
GPGregorianTime gt = new GPGregorianTime(e, time);
if (rs == TRiseSet.RISE && rise == null)
{
rise = gt;
}
else if (rs == TRiseSet.SET && set == null)
{
set = gt;
}
time = GPAstroEngine.GetNextMoonEvent(time, e, out rs);
}
}
public static void FormatAppDayText(GPAppDayResults app, StringBuilder strResult)
{
GPAstroData d = app.details;
string str;
GPGregorianTime vc = app.evente;
StringBuilder strText = strResult;
int max = 0;
foreach (GPStringPair rec in app.output)
{
if (!rec.Header)
{
max = Math.Max(max, rec.Name.Length);
}
}
max++;
foreach (GPStringPair rec in app.output)
{
if (rec.Header)
{
AddTextLine(strText, rec.Name);
AddTextLine(strText, string.Empty.PadLeft(rec.Name.Length, '-'));
}
else
{
str = string.Format("{0} : {1}", rec.Name.PadLeft(max), rec.Value);
AddTextLine(strText, str);
}
}
}
public GPGregorianTime TimeByAddingHours(double dHours)
{
GPGregorianTime vc = new GPGregorianTime(this);
vc.addDayHours(dHours / 24.0);
return(vc);
}
/*********************************************************************/
/* */
/* finds next time when starts next yoga */
/* */
/* timezone is not changed */
/* */
/* return value: index of yoga 0..26 */
/* or -1 if failed */
/*********************************************************************/
public static int GetNextStart(GPGregorianTime startDate, out GPGregorianTime nextDate)
{
double phi = 40 / 3.0;
double l1, l2, sunl;
double jday = startDate.getJulianGreenwichTime();
double xj;
double ayanamsa = GPAyanamsa.GetAyanamsa(jday);
GPMoon moon = new GPMoon();
GPGregorianTime d = new GPGregorianTime(startDate);
GPGregorianTime xd = new GPGregorianTime(startDate.getLocationProvider());
double scan_step = 0.5;
int prev_tit = 0;
int new_tit = -1;
moon.MoonCalc(jday);
sunl = GPSun.GetSunLongitude(jday);
l1 = GPMath.putIn360(moon.longitude_deg + sunl - 2 * ayanamsa);
prev_tit = Convert.ToInt32(Math.Floor(l1 * 3 / 40.0));
int counter = 0;
while (counter < 20)
{
xj = jday;
xd.Copy(d);
jday += scan_step;
d.setDayHours(d.getDayHours() + scan_step);
if (d.getDayHours() > 1.0)
{
d.setDayHours(d.getDayHours() - 1.0);
d.NextDay();
}
moon.MoonCalc(jday);
//SunPosition(d, ed, sun, d.shour - 0.5 + d.tzone/24.0);
//l2 = put_in_360(moon.longitude_deg - sun.longitude_deg - 180.0);
sunl = GPSun.GetSunLongitude(jday);
l2 = GPMath.putIn360(moon.longitude_deg + sunl - 2 * ayanamsa);
//Debugger.Log(0, "", "Current position: " + l2/12.0 + " date: " + jday + "\n");
new_tit = Convert.ToInt32(Math.Floor(l2 / phi));
if (prev_tit != new_tit)
{
jday = xj;
d.Copy(xd);
scan_step *= 0.5;
counter++;
continue;
}
else
{
l1 = l2;
}
}
nextDate = d;
// nextDate.shour += startDate.tzone / 24.0;
// nextDate.NormalizeValues();
return(new_tit);
}
public static int FormatEventsXML(GPCoreEventResults inEvents, StringBuilder strXml)
{
int i;
strXml.AppendFormat("<xml>\r\n<program version=\"{0}\">\r\n<location longitude=\"{1}\" latitude=\"{2}\" timezone=\"{3}\"/>\n"
, GPFileHelper.FileVersion, inEvents.m_location.getLocation(0).GetLongitudeEastPositive(),
inEvents.m_location.getLocation(0).GetLatitudeNorthPositive()
, inEvents.m_location.getLocation(0).getTimeZoneName());
GPGregorianTime prevd = new GPGregorianTime(inEvents.m_location);
prevd.setDate(1800, 1, 1);
for (i = 0; i < inEvents.getCount(); i++)
{
GPCoreEvent dnr = inEvents.get(i);
if (inEvents.b_sorted)
{
if (prevd.getDay() != dnr.Time.getDay() || prevd.getMonth() != dnr.Time.getMonth() || prevd.getYear() != dnr.Time.getYear())
{
strXml.AppendFormat("\t<day date=\"{0}\" />\n", dnr.Time);
}
prevd = dnr.Time;
}
strXml.AppendFormat("\t<event type=\"{0}\" time=\"{1}\" />\n", dnr.getEventTitle(), dnr.Time.getLongTimeString());
}
strXml.Append("</xml>\n");
return(1);
}
public void calculateCoordinatesMethodC(GPGregorianTime vct, double DayHours)
{
double DG = GPMath.pi / 180;
double RAD = 180 / GPMath.pi;
// mean ecliptic longitude of the sun
double mel = SunGetMeanLong(vct.getYear(), vct.getMonth(), vct.getDay()) + (360 / 365.25) * DayHours / 360.0;
// ecliptic longitude of perigee
double elp = SunGetPerigee(vct.getYear(), vct.getMonth(), vct.getDay());
// mean anomaly of the sun
double M = mel - elp;
// equation of center
double C = 1.9148 * GPMath.sinDeg(M)
+ 0.02 * GPMath.sinDeg(2 * M)
+ 0.0003 * GPMath.sinDeg(3 * M);
// ecliptic longitude of the sun
double els = 0;
eclipticalLongitude = els = mel + C;
// declination of the sun
declination = GPMath.arcsinDeg(0.397948 * GPMath.sinDeg(eclipticalLongitude));
// right ascension of the sun
rightAscession = els - RAD * Math.Atan2(Math.Sin(2 * els * DG), 23.2377 + Math.Cos(2 * DG * els));
// equation of time
equationOfTime = rightAscession - mel;
//equationOfTime = GPAstroEngine.getEquationOfTime(julianDay, right_asc_deg);
//Debugger.Log(0,"", String.Format("{1}: EoTdiff = {0}\n", vct.getShortDateString(), equationOfTime - (right_asc_deg - mel)));
}
private void calculateRiseSetMethodA(GPGregorianTime vct, GPLocationProvider ed, double DayHours, GPSun sun, double DG, double RAD)
{
double time = vct.getJulianLocalNoon() - 0.5 + DayHours / 360 - vct.getTimeZoneOffsetHours() / 24.0;
double dLatitude = ed.getLocation(time).GetLatitudeNorthPositive();
double dLongitude = ed.getLocation(time).GetLongitudeEastPositive();
//Debugger.Log(0,"",String.Format("{0} {1} {2}\n", vct.getLongDateString(), dLatitude, dLongitude));
// definition of event
// eventdef = 0.0;
// civil twilight eventdef = 0.10453;
// nautical twilight eventdef = 0.20791;
// astronomical twilight eventdef = 0.30902;
// center of the sun on the horizont eventdef = 0.01454;
double eventdef = 0.01454;
double x = GPMath.tanDeg(dLatitude) * GPMath.tanDeg(sun.declination) + eventdef / (GPMath.cosDeg(dLatitude) * GPMath.cosDeg(sun.declination));
if (x < -1.0 || x > 1.0)
{
// initial values for the case
// that no rise no set for that day
sun.sunrise_deg = -360;
sun.noon_deg = -360;
sun.sunset_deg = -360;
return;
}
double hourAngle = GPMath.arcsinDeg(x);
// time of sunrise
sun.sunrise_deg = 90.0 - dLongitude - hourAngle + equationOfTime;
// time of noon
sun.noon_deg = 180.0 - dLongitude + equationOfTime;
// time of sunset
sun.sunset_deg = 270.0 - dLongitude + hourAngle + equationOfTime;
}
public static void FormatAppDayRtf(GPAppDayResults app, StringBuilder strResult)
{
//MOONDATA moon;
//SUNDATA sun;
GPAstroData d = app.details;
string str;
GPGregorianTime vc = app.evente;
StringBuilder strText = strResult;
strText.Remove(0, strText.Length);
AppendRtfHeader(strText);
foreach (GPStringPair rec in app.output)
{
if (rec.Header)
{
strText.AppendFormat("\\par\\pard{{\\f2\\fs{0} {1}}", g_HeaderSize, rec.Name);
strText.AppendFormat("\\par\\pard\\f2\\fs{0}\r\n", g_TextSize);
}
else
{
str = string.Format("\\tab {0} : {{\\b {1}}", rec.Name, rec.Value);
AddTextLineRtf(strText, str);
}
}
strText.Append("}");
}
// return values
// 0 - DST is off, yesterday was off
// 1 - DST is on, yesterday was off
// 2 - DST is on, yesterday was on
// 3 - DST is off, yesterday was on
public int GetDaylightChangeType(GPGregorianTime vc2)
{
long uToday = vc2.getTimestamp();
long uYesterday = uToday - 86400;
Transition tzToday = FindActiveTransition(uToday);
Transition tzYesterday = FindActiveTransition(uYesterday);
bool t1 = tzToday != null ? tzToday.Dst : false;
bool t2 = tzYesterday != null ? tzYesterday.Dst : false;
if (t1)
{
if (t2)
{
return(2);
}
else
{
return(1);
}
}
else if (t2)
{
return(3);
}
else
{
return(0);
}
}
/// <summary>
/// this will move date to the nearest conjunction
/// whether it is in future or in the past
/// </summary>
/// <returns></returns>
protected GPGregorianTime movePosition()
{
double position = 0;
double diff;
double seconds = 0.5 / 86400.0;
double prevSeconds = -1;
for (int i = 0; i < 10; i++)
{
position = calculatePosition() / 360;
if (Math.Abs(pJulianDate - prevSeconds) < seconds)
{
break;
}
prevSeconds = pJulianDate;
diff = position * 30;
pJulianDate -= diff;
pStartDate.addDayHours(diff);
}
GPGregorianTime nt = new GPGregorianTime(pStartDate.getLocation());
nt.setJulianGreenwichTime(new GPJulianTime(GPAstroEngine.ConvertDynamicToUniversal(pJulianDate), 0.0));
return(nt);
}
/// <summary>
/// Recalculation of sunrise time for given travelling
/// </summary>
/// <param name="sun"></param>
/// <param name="locChange"></param>
private static void recalculateSunriseTravel(GPSun sun, GPLocationChange locChange)
{
GPSun newSun = new GPSun();
double drStep = 0.5;
double dr = 0.0;
int steps = 0;
while (steps < 25)
{
GPLocation lp = locChange.getTravellingLocation(dr);
double jd = locChange.julianStart + (locChange.julianEnd - locChange.julianStart) * dr;
GPGregorianTime gt = new GPGregorianTime(lp);
gt.setJulianGreenwichTime(jd);
GPLocationProvider lpr = new GPLocationProvider(lp);
newSun.calculateRise(sun.rise, lpr);
newSun.updateSunriseTimes(sun.rise, lpr);
if (gt.getJulianGreenwichTime() > newSun.rise.getJulianGreenwichTime())
{
drStep = drStep / 2;
dr -= drStep;
}
else
{
dr += drStep;
}
steps++;
}
sun.rise = newSun.rise;
sun.sunrise_deg = newSun.sunrise_deg;
sun.eclipticalLongitude = newSun.eclipticalLongitude;
}
public int GetArg_Date(string str, out GPGregorianTime vc)
{
vc = new GPGregorianTime(GPLocation.getEmptyLocation());
string[] parts = str.Replace('/', '-').Split('-');
if (parts.Length < 3)
{
return(1);
}
int day, month, year;
int.TryParse(parts[0], out day);
if (day == 0)
{
day = 1;
}
int.TryParse(parts[1], out month);
if (month == 0)
{
month = 1;
}
int.TryParse(parts[2], out year);
vc.setDate(year, month, day);
return(0);
}
/// <summary>
/// get date text for today screen
/// </summary>
/// <param name="vc"></param>
public static string getDateText(GPGregorianTime vc)
{
string str = string.Empty;
getShared().TodayDate = new GPGregorianTime(vc);
getShared().TodayDate.Today();
int input = Convert.ToInt32(vc.getJulianLocalNoon());
int today = Convert.ToInt32(getShared().TodayDate.getJulianLocalNoon());
if ((vc.getDay() > 0) && (vc.getDay() < 32) && (vc.getMonth() > 0) && (vc.getMonth() < 13) && (vc.getYear() >= 1500) && (vc.getYear() < 4000))
{
if (input - today == 0)
{
str = string.Format("{0} ({1}) - {2}", vc.ToString(), GPStrings.getString(43), GPStrings.getString(vc.getDayOfWeek()));
}
else if (input - today == 1)
{
str = string.Format("{0} ({1}) - {2}", vc.ToString(), GPStrings.getString(854), GPStrings.getString(vc.getDayOfWeek()));
}
else if (input - today == -1)
{
str = string.Format("{0} ({1}) - {2}", vc.ToString(), GPStrings.getString(853), GPStrings.getString(vc.getDayOfWeek()));
}
else
{
str = string.Format("{0} - {1}", vc.ToString(), GPStrings.getString(vc.getDayOfWeek()));
}
}
return(str);
}
public GPGregorianTime getSunriseTime()
{
GPGregorianTime vc = new GPGregorianTime(this.date);
vc.setDayHours(astrodata.sun.getSunriseDayHours());
return(vc);
}
public static void Report(GPLocationProvider loc, string prefix)
{
GPGregorianTime start = new GPGregorianTime(loc);
GPGregorianTime end = new GPGregorianTime(loc);
start.setDate(2010, 1, 1);
end.setDate(2015, 1, 1);
GPCalendarResults calendar = new GPCalendarResults();
calendar.CalculateCalendar(start, Convert.ToInt32(end.getJulianLocalNoon() - start.getJulianLocalNoon()));
GPCoreEventResults coreEvents = new GPCoreEventResults();
coreEvents.Sort(false);
coreEvents.CalculateEvents(loc, start, end);
string path = "d:\\gcal\\reports\\";
if (Directory.Exists(path))
{
File.WriteAllText(Path.Combine(path, prefix + "-cal-" + loc.getCity() + ".txt"),
FormaterInternal.getInternalDalendarData(calendar));
File.WriteAllText(Path.Combine(path, prefix + "-eve-" + loc.getCity() + ".txt"),
FormaterInternal.getInternalEventsText(coreEvents));
}
}
/// <summary>
/// Returns first day of gaurabda vaisnava calendar for given year
/// </summary>
/// <param name="loc"></param>
/// <param name="year"></param>
/// <returns></returns>
public static DateTime GetFirstDayOfYear(GPLocationProvider loc, int year)
{
GPGregorianTime vcStart = GPGaurabdaYear.getFirstDayOfYear(loc, year);
DateTime dt = new DateTime(vcStart.getYear(), vcStart.getMonth(), vcStart.getDay());
return(dt);
}
/*********************************************************************/
/* */
/* finds previous time when starts next yoga */
/* */
/* timezone is not changed */
/* */
/* return value: index of yoga 0..26 */
/* or -1 if failed */
/*********************************************************************/
public static int GetPrevStart(GPGregorianTime startDate, out GPGregorianTime nextDate)
{
double phi = 12.0;
double l1, l2, sunl;
double jday = startDate.getJulianGreenwichTime();
double xj;
double ayanamsa = GPAyanamsa.GetAyanamsa(jday);
GPMoon moon = new GPMoon();
GPGregorianTime d = new GPGregorianTime(startDate);
GPGregorianTime xd = new GPGregorianTime(startDate.getLocationProvider());
double scan_step = 0.5;
int prev_tit = 0;
int new_tit = -1;
moon.MoonCalc(jday);
sunl = GPSun.GetSunLongitude(jday);
l1 = GPMath.putIn360(moon.longitude_deg + sunl - 2 * ayanamsa);
prev_tit = Convert.ToInt32(Math.Floor(l1 / phi));
int counter = 0;
while (counter < 20)
{
xj = jday;
xd.Copy(d);
jday -= scan_step;
d.setDayHours(d.getDayHours() - scan_step);
if (d.getDayHours() < 0.0)
{
d.setDayHours(d.getDayHours() + 1.0);
d.PreviousDay();
}
moon.MoonCalc(jday);
sunl = GPSun.GetSunLongitude(jday);
l2 = GPMath.putIn360(moon.longitude_deg + sunl - 2 * ayanamsa);
new_tit = Convert.ToInt32(Math.Floor(l2 / phi));
if (prev_tit != new_tit)
{
jday = xj;
d.Copy(xd);
scan_step *= 0.5;
counter++;
continue;
}
else
{
l1 = l2;
}
}
nextDate = d;
// nextDate.shour += startDate.tzone / 24.0;
// nextDate.NormalizeValues();
return(new_tit);
}
public void Copy(GPGregorianTime vc)
{
p_year = vc.getYear();
p_month = vc.getMonth();
p_day = vc.getDay();
setDayHours(vc.getDayHours());
setLocationProvider(vc.getLocationProvider());
recalculateJulianGreenwichTime();
}
public void calculateRise(GPGregorianTime vct, GPLocationProvider ed)
{
//Debugger.Log(0,"", "stepA: ");
calculateRiseSet(vct, ed, 0);
//Debugger.Log(0, "", "stepB: ");
calculateRiseSet(vct, ed, sunrise_deg - 180);
//Debugger.Log(0, "", "stepC: ");
calculateRiseSet(vct, ed, sunrise_deg - 180);
}
public int GetArg_Time(string str, out GPGregorianTime vc)
{
vc = new GPGregorianTime(GPLocation.getEmptyLocation());
double l = 0.0;
double coma = 10.0;
bool after_coma = false;
bool is_deg = false;
string s = str;
foreach (char ch in str)
{
switch (ch)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if (after_coma)
{
if (is_deg)
{
l += (ch - '0') * 5.0 / (coma * 3.0);
}
else
{
l += (ch - '0') / coma;
}
coma *= 10.0;
}
else
{
l = l * 10.0 + (ch - '0');
}
break;
case ':':
after_coma = true;
is_deg = true;
break;
default:
return(SetArgLastError(14));
}
}
vc.setDayHours(l / 24.0);
return(0);
}
public GPGregorianTime movePosition(int dir)
{
double unitLength = getUnitAverageLength();
int unitCount = getUnitCount();
double lowerLimit = 0.5;
double upperLimit = unitCount - 0.5;
double position = 0;
bool over = false;
bool under = false;
double nextTithi = getCurrentPosition() + dir;
double diff;
double seconds = 0.5 / 86400.0;
double prevSeconds = -1;
if (dir > 0)
{
over = (nextTithi > upperLimit);
under = (currentPosition < lowerLimit);
}
else
{
over = (currentPosition > upperLimit);
under = (nextTithi < lowerLimit);
}
for (int i = 0; i < 10; i++)
{
position = calculatePosition();
//seconds = Convert.ToInt32((pJulianDate - Math.Floor(pJulianDate)) * 86400);
if (Math.Abs(pJulianDate - prevSeconds) < seconds)
{
break;
}
if (over && position < lowerLimit)
{
position += unitCount;
}
else if (under && position > upperLimit)
{
position -= unitCount;
}
prevSeconds = pJulianDate;
diff = (nextTithi - position) * unitLength;
pJulianDate += diff;
pStartDate.addDayHours(diff);
}
currentPosition = Convert.ToInt32(nextTithi) % unitCount;
GPGregorianTime nt = new GPGregorianTime(pStartDate.getLocation());
nt.setJulianGreenwichTime(new GPJulianTime(GPAstroEngine.ConvertDynamicToUniversal(pJulianDate), 0.0));
return(nt);
}
public static int getGaurabdaYear(GPGregorianTime vc, GPLocationProvider earth)
{
GPAstroData day = new GPAstroData();
int n;
day.calculateDayData(vc, earth);
day.determineMasa(vc, out n);
return(n);
}
public double BiasHoursForDate(GPGregorianTime vc)
{
Transition trans = FindActiveTransition(vc.getTimestamp());
if (trans != null)
{
return(Convert.ToDouble(trans.OffsetInSeconds - OffsetSeconds) / 3600.0);
}
return(0.0);
}
//===========================================================================
//
//===========================================================================
public static void VCTIMEtoVATIME(GPGregorianTime vc, out GPVedicTime va, GPLocationProvider earth)
{
GPAstroData day = new GPAstroData();
va = new GPVedicTime();
day.calculateDayData(vc, earth);
va.masa = day.determineMasa(vc, out va.gyear);
va.tithi = day.nTithi;
}
/*********************************************************************/
/* */
/* finds previous time when starts next naksatra */
/* */
/* timezone is not changed */
/* */
/* return value: index of naksatra 0..26 */
/* or -1 if failed */
/*********************************************************************/
public static int GetPrevNaksatra(GPGregorianTime startDate, out GPGregorianTime nextDate)
{
double phi = 40.0 / 3.0;
double l1, l2;
double jday = startDate.getJulianGreenwichTime();
GPMoon moon = new GPMoon();
GPGregorianTime d = new GPGregorianTime(startDate);
double ayanamsa = GPAyanamsa.GetAyanamsa(jday);
double scan_step = 0.5;
int prev_naks = 0;
int new_naks = -1;
double xj;
GPGregorianTime xd = new GPGregorianTime(startDate.getLocationProvider());
moon.MoonCalc(jday);
l1 = GPMath.putIn360(moon.longitude_deg - ayanamsa);
prev_naks = Convert.ToInt32(Math.Floor(l1 / phi));
int counter = 0;
while (counter < 20)
{
xj = jday;
xd.Copy(d);
jday -= scan_step;
d.setDayHours(d.getDayHours() - scan_step);
if (d.getDayHours() < 0.0)
{
d.setDayHours(d.getDayHours() + 1.0);
d.PreviousDay();
}
moon.MoonCalc(jday);
l2 = GPMath.putIn360(moon.longitude_deg - ayanamsa);
new_naks = Convert.ToInt32(Math.Floor(l2 / phi));
if (prev_naks != new_naks)
{
jday = xj;
d.Copy(xd);
scan_step *= 0.5;
counter++;
continue;
}
else
{
l1 = l2;
}
}
nextDate = d;
return(new_naks);
}
public bool GetNaksatraTimeRange(GPLocation earth, out GPGregorianTime from, out GPGregorianTime to)
{
GPGregorianTime start = new GPGregorianTime(date);
start.setDayHours(astrodata.sun.getSunriseDayHours());
GPNaksatra.GetNextNaksatra(start, out to);
GPNaksatra.GetPrevNaksatra(start, out from);
return(true);
}
private bool AddEvent(GPGregorianTime inTime, int inType, string inData)
{
GPCoreEvent eve = new GPCoreEvent();
eve.Time = inTime;
eve.strData = inData;
eve.nType = inType;
p_events.Add(eve);
return(true);
}
// return values
// 0 - DST is off, yesterday was off
// 1 - DST is on, yesterday was off
// 2 - DST is on, yesterday was on
// 3 - DST is off, yesterday was on
public int GetDaylightChangeType(GPGregorianTime vcDay)
{
GPGregorianTime vcPrevDay = new GPGregorianTime(vcDay);
vcPrevDay.PreviousDay();
bool t1 = DaylightSavingInEFfect(vcDay);
bool t2 = DaylightSavingInEFfect(vcPrevDay);
return(t1 ? (t2 ? 2 : 1) : (t2 ? 3 : 0));
}
/*********************************************************************/
/* */
/* Calculation of tithi, paksa, naksatra, yoga for given */
/* Gregorian date */
/* */
/* */
/*********************************************************************/
public int calculateDayData(GPGregorianTime aDate, GPLocationProvider earth)
{
double d;
GPAstroData day = this;
GPGregorianTime date = new GPGregorianTime(aDate);
// SUNDATA sun;
// sun position on sunrise on that day
sun.SunCalc(date, earth);
date.setDayHours(sun.getSunriseDayHours());
// date.shour is [0..1] time of sunrise in local timezone time
jdate = date.getJulianGreenwichTime();
// moon position at sunrise on that day
day.moon.MoonCalc(jdate);
// correct_parallax(day.moon, jdate, earth.latitude_deg, earth.longitude_deg);
day.msDistance = GPMath.putIn360(day.moon.longitude_deg - day.sun.eclipticalLongitude - 180.0);
day.msAyanamsa = GPAyanamsa.GetAyanamsa(jdate);
// tithi
d = day.msDistance / 12.0;
day.nTithi = Convert.ToInt32(Math.Floor(d));
day.nTithiElapse = GPMath.frac(d) * 100.0;
day.nPaksa = (day.nTithi >= 15) ? 1 : 0;
// naksatra
d = GPMath.putIn360(day.moon.longitude_deg - day.msAyanamsa);
d = (d * 3.0) / 40.0;
day.nNaksatra = Convert.ToInt32(Math.Floor(d) + 0.1);
day.nNaksatraElapse = GPMath.frac(d) * 100.0;
// yoga
d = GPMath.putIn360(day.moon.longitude_deg + day.sun.eclipticalLongitude - 2 * day.msAyanamsa);
d = (d * 3.0) / 40.0;
day.nYoga = Convert.ToInt32(Math.Floor(d));
day.nYogaElapse = GPMath.frac(d) * 100.0;
// masa
day.nMasa = -1;
// rasi
day.nSunRasi = GPEngine.GetRasi(day.sun.eclipticalLongitude, day.msAyanamsa);
day.nMoonRasi = GPEngine.GetRasi(day.moon.longitude_deg, day.msAyanamsa);
setDate(date);
return(1);
}
public static int calculateNaksatraAtMidnight(GPGregorianTime date, GPLocationProvider earth)
{
double d;
double jdate;
GPMoon moon = new GPMoon();
GPSun sun = new GPSun();
jdate = date.getJulianGreenwichNoon() + 0.5;
moon.MoonCalc(jdate);
d = GPMath.putIn360(moon.longitude_deg - GPAyanamsa.GetAyanamsa(jdate));
return(Convert.ToInt32(Math.Floor((d * 3.0) / 40.0)));
}
