public static int WriteXML_Naksatra(StringBuilder doc, GPLocationProvider loc, GPGregorianTime vc, int nDaysCount)
{
doc.Append("<xml>\n");
doc.Append("\t<request name=\"Naksatra\" version=\"" + GPFileHelper.FileVersion + "\">\n");
doc.Append("\t\t<arg name=\"longitude\" val=\"" + loc.GetLongitudeEastPositive() + "\" />\n");
doc.Append("\t\t<arg name=\"latitude\" val=\"" + loc.GetLatitudeNorthPositive() + "\" />\n");
doc.Append("\t\t<arg name=\"timezone\" val=\"" + loc.getTimeZone().OffsetSeconds / 60 + "\" />\n");
doc.Append("\t\t<arg name=\"startdate\" val=\"" + vc + "\" />\n");
doc.Append("\t\t<arg name=\"daycount\" val=\"" + nDaysCount + "\" />\n");
doc.Append("\t</request>\n");
doc.Append("\t<result name=\"Naksatra\">\n");
GPGregorianTime d = new GPGregorianTime(vc);
GPGregorianTime dn = new GPGregorianTime(loc);
GPSun sun = new GPSun();
int nak;
for (int i = 0; i < 30; i++)
{
nak = GPNaksatra.GetNextNaksatra(d, out dn);
d.Copy(dn);
doc.Append("\t\t<day date=\"" + d + "\">\n");
//str = string.Format("{}.{}.{}", d.day, d.month, d.year);
//n = m_list.InsertItem(50, GPNaksatra.GetName(nak));
//m_list.SetItemText(n, 1, str);
doc.Append("\t\t\t<naksatra id=\"" + nak + "\" name=\"" + GPNaksatra.getName(nak) + "\"\n");
//dt.SetDegTime(d.getDayHours() * 360);
//time_print(str, dt);
doc.Append("\t\t\t\tstarttime=\"" + d.getShortTimeString() + "\" />\n");
//m_list.SetItemText(n, 2, str);
// sunrise time get
sun.SunCalc(d, loc);
//time_print(str, sun.rise);
//m_list.SetItemText(n, 3, str);
doc.Append("\t\t\t<sunrise time=\"" + sun.rise + "\" />\n");
doc.Append("\t\t</day>\n");
// increment for non-duplication of naksatra
d.Copy(dn);
d.setDayHours(d.getDayHours() + 1.0 / 8.0);
}
doc.Append("\t</result>\n");
doc.Append("</xml>\n");
return(1);
}
/*********************************************************************/
/* */
/* 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);
}
/*********************************************************************/
/* */
/* 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);
}
/*********************************************************************/
/* */
/* 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 static int GetNextRasi(GPGregorianTime startDate, out GPGregorianTime nextDate)
{
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 = GPEngine.GetRasi(moon.longitude_deg, ayanamsa);
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);
//l2 = GPMath.putIn360(moon.longitude_deg - ayanamsa);
new_naks = GPEngine.GetRasi(moon.longitude_deg, ayanamsa);
if (prev_naks != new_naks)
{
jday = xj;
d.Copy(xd);
scan_step *= 0.5;
counter++;
continue;
}
}
nextDate = d;
return(new_naks);
}
/*********************************************************************/
/* Finds next time when rasi is changed */
/* */
/* startDate - starting date and time, timezone member must be valid */
/* zodiac [out] - found zodiac sign into which is changed */
/* */
/*********************************************************************/
public static GPGregorianTime GetNextSankranti(GPGregorianTime startDate, out int zodiac)
{
GPGregorianTime d;
double step = 1.0;
int count = 0;
double ld, prev;
int prev_rasi, new_rasi;
GPGregorianTime prevday = new GPGregorianTime(startDate.getLocation());
zodiac = 0;
d = new GPGregorianTime(startDate);
double jdate = d.getJulianGreenwichTime();
prev = GPMath.putIn360(GPSun.GetSunLongitude(jdate) - GPAyanamsa.GetAyanamsa(jdate));
prev_rasi = Convert.ToInt32(Math.Floor(prev / 30.0));
while (count < 20)
{
prevday.Copy(d);
d.setDayHours(d.getDayHours() + step);
if (d.getDayHours() > 1.0)
{
d.setDayHours(d.getDayHours() - 1.0);
d.NextDay();
}
jdate = d.getJulianGreenwichTime();
ld = GPMath.putIn360(GPSun.GetSunLongitude(jdate) - GPAyanamsa.GetAyanamsa(jdate));
new_rasi = Convert.ToInt32(Math.Floor(ld / 30.0));
if (prev_rasi != new_rasi)
{
zodiac = new_rasi;
//v uplynulom dni je sankranti
step *= 0.5;
d.Copy(prevday);
count++;
continue;
}
}
return(d);
}
public static GPGregorianTime CalcTithiEndEx(GPGregorianTime vcStart, int GYear, int nMasa, int nPaksa, int nTithi, GPLocationProvider earth, out GPGregorianTime endTithi)
{
int i, gy, nType;
GPGregorianTime d = new GPGregorianTime(earth);
GPGregorianTime dtemp = new GPGregorianTime(earth);
GPAstroData day = new GPAstroData();
int tithi;
int counter;
GPGregorianTime start = new GPGregorianTime(earth), end = new GPGregorianTime(earth);
// SUNDATA sun;
// MOONDATA moon;
double sunrise;
start.setDayHours(-1.0);
end.setDayHours(-1.0);
start.Clear();
end.Clear();
/* d = GetFirstDayOfYear(earth, nGYear + 1486);
* d.shour = 0.5;
* d.TimeZone = earth.tzone;
*/
d.Copy(vcStart);
i = 0;
do
{
d.AddDays(13);
day.calculateDayData(d, earth);
day.nMasa = day.determineMasa(d, out gy);
day.nGaurabdaYear = gy;
i++;
}while (((day.nPaksa != nPaksa) || (day.nMasa != nMasa)) && (i <= 30));
if (i >= 30)
{
d.Clear();
endTithi = d;
return(d);
}
// we found masa and paksa
// now we have to find tithi
tithi = nTithi + nPaksa * 15;
if (day.nTithi == tithi)
{
// loc1
// find tithi juncts in this day and according to that times,
// look in previous or next day for end and start of this tithi
nType = 1;
}
else
{
if (day.nTithi < tithi)
{
// do increment of date until nTithi == tithi
// but if nTithi > tithi
// then do decrement of date
counter = 0;
while (counter < 30)
{
d.NextDay();
day.calculateDayData(d, earth);
if (day.nTithi == tithi)
{
goto cont_2;
}
if ((day.nTithi < tithi) && (day.nPaksa != nPaksa))
{
d.PreviousDay();
goto cont_2;
}
if (day.nTithi > tithi)
{
d.PreviousDay();
goto cont_2;
}
counter++;
}
// somewhere is error
d.Clear();
nType = 0;
}
else
{
// do decrement of date until nTithi <= tithi
counter = 0;
while (counter < 30)
{
d.PreviousDay();
day.calculateDayData(d, earth);
if (day.nTithi == tithi)
{
goto cont_2;
}
if ((day.nTithi > tithi) && (day.nPaksa != nPaksa))
{
goto cont_2;
}
if (day.nTithi < tithi)
{
goto cont_2;
}
counter++;
}
// somewhere is error
d.Clear();
nType = 0;
}
cont_2:
if (day.nTithi == tithi)
{
// do the same as in loc1
nType = 1;
}
else
{
// nTithi != tithi and nTithi < tithi
// but on next day is nTithi > tithi
// that means we will find start and the end of tithi
// in this very day or on next day before sunrise
nType = 2;
}
}
// now we know the type of day-accurancy
// nType = 0 means, that we dont found a day
// nType = 1 means, we find day, when tithi was present at sunrise
// nType = 2 means, we found day, when tithi started after sunrise
// but ended before next sunrise
//
sunrise = day.sun.getSunriseDayHours() / 360 + day.sun.rise.getLocation().getTimeZoneOffsetHours() / 24;
if (nType == 1)
{
GPGregorianTime d1, d2;
d.setDayHours(sunrise);
GetPrevTithiStart(d, out d1);
//d = d1;
//d.shour += 0.02;
GetNextTithiStart(d, out d2);
endTithi = d2;
return(d1);
}
else if (nType == 2)
{
GPGregorianTime d1, d2;
d.setDayHours(sunrise);
GetNextTithiStart(d, out d1);
d.Copy(d1);
d.addDayHours(0.1);
GetNextTithiStart(d, out d2);
endTithi = d2;
return(d1);
}
// if nType == 0, then this algoritmus has some failure
if (nType == 0)
{
d.Clear();
d.setDayHours(0.0);
endTithi = d;
}
else
{
d.Copy(start);
endTithi = end;
}
return(d);
}
public int CalcMasaList(GPLocationProvider loc, int nYear, int nCount)
{
GPMasaListResults mlist = this;
GPAstroData day = new GPAstroData();
GPGregorianTime d = new GPGregorianTime(loc);
GPGregorianTime de = new GPGregorianTime(loc);
GPGregorianTime t = new GPGregorianTime(loc);
vc_end = new GPGregorianTime(loc);
vc_start = new GPGregorianTime(loc);
int lm = -1;
mlist.n_startYear = nYear;
mlist.n_countYears = nCount;
d.Copy(GPGaurabdaYear.getFirstDayOfYear(loc, nYear));
de.Copy(GPGaurabdaYear.getFirstDayOfYear(loc, nYear + nCount));
mlist.vc_start.Copy(d);
mlist.vc_end.Copy(de);
mlist.m_location = loc;
alloc(nCount);
int i = 0;
int prev_paksa = -1;
int current = 0;
while (d.IsBeforeThis(de))
{
day.calculateDayData(d, loc);
if (prev_paksa != day.nPaksa)
{
day.nMasa = day.determineMasa(d, out day.nGaurabdaYear);
if (lm != day.nMasa)
{
if (lm >= 0)
{
t.Copy(d);
t.PreviousDay();
mlist.arr[current].vc_end.Copy(t);
current++;
}
lm = day.nMasa;
mlist.arr[current].masa = day.nMasa;
mlist.arr[current].year = day.nGaurabdaYear;
mlist.arr[current].vc_start.Copy(d);
}
}
prev_paksa = day.nPaksa;
d.NextDay();
i++;
}
t.Copy(d);
mlist.arr[current].vc_end.Copy(t);
current++;
mlist.n_countMasa = current;
return(1);
}
public void CalculateEvents(GPLocationProvider loc, GPGregorianTime vcStart, GPGregorianTime vcEnd)
{
GPCoreEventResults inEvents = this;
GPLocationProvider earth = loc;
GPGregorianTime vc = new GPGregorianTime(loc);
GPSun sun = new GPSun();
//int ndst = 0;
int nData;
inEvents.clear();
inEvents.m_location = loc;
inEvents.m_vcStart = vcStart;
inEvents.m_vcEnd = vcEnd;
GPGregorianTime vcAdd = new GPGregorianTime(loc);
GPGregorianTime vcTemp = null;
GPGregorianTime vcNext = new GPGregorianTime(loc);
vc.Copy(vcStart);
if (GPDisplays.CoreEvents.Sunrise())
{
vcAdd.Copy(vc);
while (vcAdd.IsBeforeThis(vcEnd))
{
sun.SunCalc(vcAdd, earth);
vcTemp = new GPGregorianTime(sun.arunodaya);
inEvents.AddEvent(vcTemp, GPConstants.CCTYPE_S_ARUN, 0);
//GPJulianTime tr, tt, ts;
//GPAstroEngine.CalculateTimeSun(vcTemp, vcTemp.getLocation(), out tr, out tt, out ts);
vcTemp = new GPGregorianTime(sun.rise);
//vcTemp = new GPGregorianTime(vcTemp.getLocation(), tr);
inEvents.AddEvent(vcTemp, GPConstants.CCTYPE_S_RISE, 0);
vcTemp = new GPGregorianTime(sun.noon);
//vcTemp = new GPGregorianTime(vcTemp.getLocation(), tt);
inEvents.AddEvent(vcTemp, GPConstants.CCTYPE_S_NOON, 0);
vcTemp = new GPGregorianTime(sun.set);
//vcTemp = new GPGregorianTime(vcTemp.getLocation(), ts);
inEvents.AddEvent(vcTemp, GPConstants.CCTYPE_S_SET, 0);
vcAdd.NextDay();
}
}
if (GPDisplays.CoreEvents.Tithi())
{
GPTithi te = new GPTithi();
te.setStartDate(vc);
vcAdd = te.getNext();
while (vcAdd.IsBeforeThis(vcEnd))
{
nData = te.getCurrentPosition();
//ndst = loc.getTimeZone().GetDaylightChangeType(vcNext);
inEvents.AddEvent(vcAdd, GPConstants.CCTYPE_TITHI, nData);
vcAdd = te.getNext();
}
}
if (GPDisplays.CoreEvents.Naksatra())
{
GPNaksatra te = new GPNaksatra();
te.setStartDate(vc);
vcAdd = te.getNext();
while (vcAdd.IsBeforeThis(vcEnd))
{
nData = te.getCurrentNaksatra();
//ndst = loc.getTimeZone().GetDaylightChangeType(vcNext);
inEvents.AddEvent(vcAdd, GPConstants.CCTYPE_NAKS, nData);
vcAdd = te.getNext();
}
}
if (GPDisplays.CoreEvents.Sankranti())
{
GPSankranti te = new GPSankranti();
te.setStartDate(vc);
vcAdd = te.getNext();
while (vcAdd.IsBeforeThis(vcEnd))
{
nData = te.getCurrentPosition();
//ndst = loc.getTimeZone().GetDaylightChangeType(vcNext);
inEvents.AddEvent(vcAdd, GPConstants.CCTYPE_SANK, nData);
vcAdd = te.getNext();
}
}
if (GPDisplays.CoreEvents.Conjunction())
{
double[] times = null;
GPConjunction te = new GPConjunction();
te.setStartDate(vc);
vcAdd = te.getNext();
while (vcAdd.IsBeforeThis(vcEnd))
{
nData = te.getCurrentPosition();
//ndst = loc.getTimeZone().GetDaylightChangeType(vcNext);
inEvents.AddEvent(vcAdd, GPConstants.CCTYPE_CONJ, nData);
if (GPDisplays.CoreEvents.SunEclipse())
{
GPAstroEngine.CalculateTimesSunEclipse(vcAdd.getJulianGreenwichTime(), vcAdd.getLocation(), out times);
if (times != null && times[2] > 0)
{
for (int i = 0; i < 5; i++)
{
if (times[i] > 0)
{
GPGregorianTime gt = new GPGregorianTime(vcAdd.getLocation());
gt.setJulianGreenwichTime(new GPJulianTime(times[i], 0.0));
inEvents.AddEvent(gt, GPConstants.SUNECLIPSE_CONSTS[i], 0);
}
}
}
}
vcAdd = te.getNext();
}
}
// moon eclipses
if (GPDisplays.CoreEvents.MoonEclipse())
{
double[] times = null;
GPConjunction te = new GPConjunction();
te.setOpositeConjunction(true);
te.setStartDate(vc);
vcAdd = te.getNext();
while (vcAdd.IsBeforeThis(vcEnd))
{
GPAstroEngine.CalculateTimesMoonEclipse(vcAdd.getJulianGreenwichTime(), vcAdd.getLocation(), out times);
if (times != null && times[4] > 0)
{
for (int i = 0; i < 9; i++)
{
if (times[i] > 0 && GPConstants.MOONECLIPSE_CONSTS[i] > 0)
{
GPGregorianTime gt = new GPGregorianTime(vcAdd.getLocation());
gt.setJulianGreenwichTime(new GPJulianTime(times[i], 0.0));
inEvents.AddEvent(gt, GPConstants.MOONECLIPSE_CONSTS[i], 0);
}
}
}
vcAdd = te.getNext();
}
}
// rise and set of the moon
if (GPDisplays.CoreEvents.Moonrise())
{
GPJulianTime julian = vc.getJulian();
GPJulianTime julianEnd = vcEnd.getJulian();
GPJulianTime nextJulian;
TRiseSet kind;
while (julian.getGreenwichJulianDay() < julianEnd.getGreenwichJulianDay())
{
nextJulian = GPAstroEngine.GetNextMoonEvent(julian, vc.getLocationProvider(), out kind);
if (kind == TRiseSet.RISE)
{
inEvents.AddEvent(new GPGregorianTime(loc, nextJulian), GPConstants.CoreEventMoonRise, 0);
}
else if (kind == TRiseSet.SET)
{
inEvents.AddEvent(new GPGregorianTime(loc, nextJulian), GPConstants.CoreEventMoonSet, 0);
}
julian.setGreenwichJulianDay(nextJulian.getGreenwichJulianDay() + 10.0 / 1440.0);
}
}
// travellings
{
GPJulianTime julian = vc.getJulian();
GPJulianTime julianEnd = vcEnd.getJulian();
double start, end;
start = julian.getGreenwichJulianDay();
end = julianEnd.getGreenwichJulianDay();
for (int i = 0; i < loc.getChangeCount(); i++)
{
GPLocationChange chn = loc.getChangeAtIndex(i);
if ((chn.julianStart >= start && chn.julianStart <= end) ||
(chn.julianStart >= start && chn.julianEnd <= end))
{
GPGregorianTime startTime = new GPGregorianTime(chn.LocationA);
startTime.setJulianGreenwichTime(new GPJulianTime(chn.julianStart, 0));
GPGregorianTime endTime = new GPGregorianTime(chn.LocationB);
endTime.setJulianGreenwichTime(new GPJulianTime(chn.julianEnd, 0));
inEvents.AddEvent(startTime, GPConstants.CCTYPE_TRAVELLING_START, 0);
inEvents.AddEvent(endTime, GPConstants.CCTYPE_TRAVELLING_END, 0);
}
}
}
// eventual sorting
inEvents.Sort(GPDisplays.CoreEvents.Sort());
}
public static int WriteXML_GaurabdaNextTithi(StringBuilder doc, GPLocationProvider loc, GPGregorianTime vcStart, GPVedicTime vaStart)
{
int gmasa, gpaksa, gtithi;
gmasa = vaStart.masa;
gpaksa = vaStart.tithi / 15;
gtithi = vaStart.tithi % 15;
doc.Append("<xml>\n");
doc.Append("\t<request name=\"Tithi\" version=\"" + GPFileHelper.FileVersion + "\">\n");
doc.Append("\t\t<arg name=\"longitude\" val=\"" + loc.GetLongitudeEastPositive() + "\" />\n");
doc.Append("\t\t<arg name=\"latitude\" val=\"" + loc.GetLatitudeNorthPositive() + "\" />\n");
doc.Append("\t\t<arg name=\"timezone\" val=\"" + loc.getTimeZone().OffsetSeconds / 60 + "\" />\n");
doc.Append("\t\t<arg name=\"start date\" val=\"" + vcStart + "\" />\n");
doc.Append("\t\t<arg name=\"masa\" val=\"" + gmasa + "\" />\n");
doc.Append("\t\t<arg name=\"paksa\" val=\"" + gpaksa + "\" />\n");
doc.Append("\t\t<arg name=\"tithi\" val=\"" + gtithi + "\" />\n");
doc.Append("\t</request>\n");
doc.Append("\t<result name=\"Tithi\">\n");
GPGregorianTime vcs = new GPGregorianTime(loc);
GPGregorianTime vce = new GPGregorianTime(loc);
GPGregorianTime today = new GPGregorianTime(loc);
GPSun sun = new GPSun();
int A;
double sunrise;
GPAstroData day = new GPAstroData();
int oTithi, oPaksa, oMasa, oYear;
today.Copy(vcStart);
today.PreviousDay();
vcStart.SubDays(15);
for (A = 0; A <= 3; A++)
{
vcs = GPTithi.CalcTithiEndEx(vcStart, 0, gmasa, gpaksa, gtithi, loc, out vce);
if (!vcs.IsBeforeThis(today))
{
oTithi = gpaksa * 15 + gtithi;
oMasa = gmasa;
oPaksa = gpaksa;
oYear = 0;
doc.Append("\t<celebration\n");
// doc.Append( "\t\t<tithi\n");
doc.Append("\t\trtithi=\"" + GPTithi.getName(oTithi) + "\"\n");
doc.Append("\t\trmasa=\"" + GPMasa.GetName(oMasa) + "\"\n");
doc.Append("\t\trpaksa=\"" + GPPaksa.getName(oPaksa) + "\"\n");
// test ci je ksaya
today.Copy(vcs);
today.setDayHours(0.5);
sun.SunCalc(today, loc);
sunrise = sun.getSunriseDayHours();
if (sunrise < vcs.getDayHours())
{
today.Copy(vce);
sun.SunCalc(today, loc);
sunrise = sun.getSunriseDayHours();
if (sunrise < vce.getDayHours())
{
// normal type
vcs.NextDay();
doc.Append("\t\ttype=\"normal\"\n");
}
else
{
// ksaya
vcs.NextDay();
day.calculateDayData(vcs, loc);
oTithi = day.nTithi;
oPaksa = day.nPaksa;
oMasa = day.determineMasa(vcs, out oYear);
doc.Append("\t\ttype=\"ksaya\"\n");
}
}
else
{
// normal, alebo prvy den vriddhi
today.Copy(vce);
sun.SunCalc(today, loc);
if (sun.getSunriseDayHours() < vce.getDayHours())
{
// first day of vriddhi type
doc.Append("\t\ttype=\"vriddhi\"\n");
}
else
{
// normal
doc.Append("\t\ttype=\"normal\"\n");
}
}
doc.Append("\t\tdate=\"" + vcs + "\"\n");
doc.Append("\t\totithi=\"" + GPTithi.getName(oTithi) + "\"\n");
doc.Append("\t\tomasa=\"" + GPMasa.GetName(oMasa) + "\"\n");
doc.Append("\t\topaksa=\"" + GPPaksa.getName(oPaksa) + "\"\n");
doc.Append("\t/>\n");
break;
}
else
{
vcStart.Copy(vcs);
vcs.NextDay();
}
}
doc.Append("\t</result>\n");
doc.Append("</xml>\n");
return(1);
}
public static int WriteXML_GaurabdaTithi(StringBuilder doc, GPLocationProvider loc, GPVedicTime vaStart, GPVedicTime vaEnd)
{
int gyearA = vaStart.gyear;
int gyearB = vaEnd.gyear;
int gmasa = vaStart.masa;
int gpaksa = vaStart.tithi / 15;
int gtithi = vaStart.tithi % 15;
if (gyearB < gyearA)
{
gyearB = gyearA;
}
doc.Append("<xml>\n");
doc.Append("\t<request name=\"Tithi\" version=\"" + GPFileHelper.FileVersion + "\">\n");
doc.Append("\t\t<arg name=\"longitude\" val=\"" + loc.getLocation(0).GetLongitudeEastPositive() + "\" />\n");
doc.Append("\t\t<arg name=\"latitude\" val=\"" + loc.getLocation(0).GetLatitudeNorthPositive() + "\" />\n");
doc.Append("\t\t<arg name=\"timezone\" val=\"" + loc.getLocation(0).getTimeZone().OffsetSeconds / 60 + "\" />\n");
if (gyearA > 1500)
{
doc.Append("\t\t<arg name=\"year-start\" val=\"" + gyearA + "\" />\n");
doc.Append("\t\t<arg name=\"year-end\" val=\"" + gyearB + "\" />\n");
}
else
{
doc.Append("\t\t<arg name=\"gaurabdayear-start\" val=\"" + gyearA + "\" />\n");
doc.Append("\t\t<arg name=\"gaurabdayear-end\" val=\"" + gyearB + "\" />\n");
}
doc.Append("\t\t<arg name=\"masa\" val=\"" + gmasa + "\" />\n");
doc.Append("\t\t<arg name=\"paksa\" val=\"" + gpaksa + "\" />\n");
doc.Append("\t\t<arg name=\"tithi\" val=\"" + gtithi + "\" />\n");
doc.Append("\t</request>\n");
doc.Append("\t<result name=\"Tithi\">\n");
GPGregorianTime vcs = new GPGregorianTime(loc), vce = new GPGregorianTime(loc), today = new GPGregorianTime(loc);
GPSun sun = new GPSun();
int A, B;
double sunrise;
GPAstroData day = new GPAstroData();
int oTithi, oPaksa, oMasa, oYear;
if (gyearA > 1500)
{
A = gyearA - 1487;
B = gyearB - 1485;
}
else
{
A = gyearA;
B = gyearB;
}
for (; A <= B; A++)
{
vcs = GPTithi.CalcTithiEnd(A, gmasa, gpaksa, gtithi, loc, out vce);
if (gyearA > 1500)
{
if ((vcs.getYear() < gyearA) || (vcs.getYear() > gyearB))
{
continue;
}
}
oTithi = gpaksa * 15 + gtithi;
oMasa = gmasa;
oPaksa = gpaksa;
oYear = 0;
doc.Append("\t<celebration\n");
doc.Append("\t\trtithi=\"" + GPTithi.getName(oTithi) + "\"\n");
doc.Append("\t\trmasa=\"" + GPMasa.GetName(oMasa) + "\"\n");
doc.Append("\t\trpaksa=\"" + GPPaksa.getName(oPaksa) + "\"\n");
// test ci je ksaya
today.Copy(vcs);
today.setDayHours(0.5);
sun.SunCalc(today, loc);
sunrise = sun.getSunriseDayHours();
if (sunrise < vcs.getDayHours())
{
today.Copy(vce);
sun.SunCalc(today, loc);
sunrise = sun.getSunriseDayHours();
if (sunrise < vce.getDayHours())
{
// normal type
vcs.NextDay();
doc.Append("\t\ttype=\"normal\"\n");
}
else
{
// ksaya
vcs.NextDay();
day.calculateDayData(vcs, loc);
oTithi = day.nTithi;
oPaksa = day.nPaksa;
oMasa = day.determineMasa(vcs, out oYear);
doc.Append("\t\ttype=\"ksaya\"\n");
}
}
else
{
// normal, alebo prvy den vriddhi
today.Copy(vce);
sun.SunCalc(today, loc);
if (sun.getSunriseDayHours() < vce.getDayHours())
{
// first day of vriddhi type
doc.Append("\t\ttype=\"vriddhi\"\n");
}
else
{
// normal
doc.Append("\t\ttype=\"normal\"\n");
}
}
doc.Append("\t\tdate=\"" + vcs + "\"\n");
doc.Append("\t\totithi=\"" + GPTithi.getName(oTithi) + "\"\n");
doc.Append("\t\tomasa=\"" + GPMasa.GetName(oMasa) + "\"\n");
doc.Append("\t\topaksa=\"" + GPPaksa.getName(oPaksa) + "\"\n");
doc.Append("\t/>\n");
// doc.Append( "\t\t</celebration>\n");
}
doc.Append("\t</result>\n");
doc.Append("</xml>\n");
return(1);
}
public static XmlDocument GetSankrantiXml(GPLocationProvider loc, GPGregorianTime vcStart, GPGregorianTime vcEnd)
{
XmlDocument doc = new XmlDocument();
XmlElement e1, e2, e3, eday, e5, e6;
GPGregorianTime d = new GPGregorianTime(loc);
int zodiac;
d.Copy(vcStart);
e1 = doc.CreateElement("xml");
doc.AppendChild(e1);
e2 = doc.CreateElement("request");
e1.AppendChild(e2);
e2.SetAttribute("name", "Sankranti");
e2.SetAttribute("version", GPFileHelper.FileVersion);
e3 = doc.CreateElement("arg");
e2.AppendChild(e3);
e3.SetAttribute("name", "longitude");
e3.SetAttribute("val", loc.GetLongitudeEastPositive().ToString());
e3 = doc.CreateElement("arg");
e2.AppendChild(e3);
e3.SetAttribute("name", "latitude");
e3.SetAttribute("val", loc.GetLatitudeNorthPositive().ToString());
e3 = doc.CreateElement("arg");
e2.AppendChild(e3);
e3.SetAttribute("name", "timezone");
e3.SetAttribute("val", (loc.getTimeZone().OffsetSeconds / 60).ToString());
e3 = doc.CreateElement("arg");
e2.AppendChild(e3);
e3.SetAttribute("name", "startdate");
e3.SetAttribute("val", vcStart.ToString());
e3 = doc.CreateElement("arg");
e2.AppendChild(e3);
e3.SetAttribute("name", "enddate");
e3.SetAttribute("val", vcEnd.ToString());
e2 = doc.CreateElement("result");
e1.AppendChild(e2);
e2.SetAttribute("name", "SankrantiList");
while (d.IsBeforeThis(vcEnd))
{
d = GPSankranti.GetNextSankranti(d, out zodiac);
eday = doc.CreateElement("sank");
e2.AppendChild(eday);
eday.SetAttribute("date", d.getLongDateString());
eday.SetAttribute("time", d.getLongTimeString());
eday.SetAttribute("dayweekid", d.getDayOfWeek().ToString());
eday.SetAttribute("dayweek", getSharedStringHtml(d.getDayOfWeek()));
e5 = doc.CreateElement("zodiac");
eday.AppendChild(e5);
e5.SetAttribute("sans", GPSankranti.GetNameSan(zodiac));
e5.SetAttribute("eng", GPSankranti.GetNameEng(zodiac));
e5.SetAttribute("id", zodiac.ToString());
d.NextDay();
d.NextDay();
}
return(doc);
}