Professional Applications Programmers/Consultants برمجة واستشارات تطبيقات الإنترنت
Skip Navigation LinksHome » Code Library » PrayerTime

Public general use code classes and xml files that we've compiled and used over the years:

Prayer times support class.

   1:  //--------------------- Copyright Block ----------------------
   2:  /* 
   3:  
   4:  PrayTime.cs: Prayer Times Calculator (ver 1.2)
   5:  Copyright (C) 2007-2010 PrayTimes.org
   6:  
   7:  C# Code By: Jandost Khoso
   8:  Original JS Code By: Hamid Zarrabi-Zadeh
   9:  
  10:  License: GNU General Public License, ver 3
  11:  
  12:  TERMS OF USE:
  13:      Permission is granted to use this code, with or 
  14:      without modification, in any website or application 
  15:      provided that credit is given to the original work 
  16:      with a link back to PrayTimes.org.
  17:  
  18:  This program is distributed in the hope that it will 
  19:  be useful, but WITHOUT ANY WARRANTY. 
  20:  
  21:  PLEASE DO NOT REMOVE THIS COPYRIGHT BLOCK.
  22:  
  23:  */
  24:   
  25:  using System;
  26:   
  27:  namespace Ia.Cl.Model
  28:  {
  29:      /// <summary publish="true">
  30:      /// Prayer times support class.
  31:      /// </summary>
  32:      /// <remarks> 
  33:      /// Copyright � 2001-2015 Jasem Y. Al-Shamlan (info@ia.com.kw), Internet Applications - Kuwait. All Rights Reserved.
  34:      ///
  35:      /// This library is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by
  36:      /// the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
  37:      ///
  38:      /// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  39:      /// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  40:      /// 
  41:      /// You should have received a copy of the GNU General Public License along with this library. If not, see http://www.gnu.org/licenses.
  42:      /// 
  43:      /// Copyright notice: This notice may not be removed or altered from any source distribution.
  44:      /// </remarks>
  45:      public class PrayerTime
  46:      {
  47:          //------------------------ Constants --------------------------
  48:   
  49:          // Calculation Methods
  50:          /// <summary/>
  51:          public static int Jafari = 0;    // Ithna Ashari
  52:   
  53:          /// <summary/>
  54:          public static int Karachi = 1;    // University of Islamic Sciences, Karachi
  55:   
  56:          /// <summary/>
  57:          public static int ISNA = 2;    // Islamic Society of North America (ISNA)
  58:   
  59:          /// <summary/>
  60:          public static int MWL = 3;    // Muslim World League (MWL)
  61:   
  62:          /// <summary/>
  63:          public static int Makkah = 4;    // Umm al-Qura, Makkah
  64:   
  65:          /// <summary/>
  66:          public static int Egypt = 5;    // Egyptian General Authority of Survey
  67:   
  68:          /// <summary/>
  69:          public static int Custom = 6;    // Custom Setting
  70:   
  71:          /// <summary/>
  72:          public static int Tehran = 7;    // Institute of Geophysics, University of Tehran
  73:   
  74:          // Juristic Methods
  75:          /// <summary/>
  76:          public static int Shafii = 0;    // Shafii (standard)
  77:   
  78:          /// <summary/>
  79:          public static int Hanafi = 1;    // Hanafi
  80:   
  81:          // Adjusting Methods for Higher Latitudes
  82:          /// <summary/>
  83:          public static int None = 0;    // No adjustment
  84:   
  85:          /// <summary/>
  86:          public static int MidNight = 1;    // middle of night
  87:          /// <summary/>
  88:   
  89:          public static int OneSeventh = 2;    // 1/7th of night
  90:          /// <summary/>
  91:          public static int AngleBased = 3;    // angle/60th of night
  92:   
  93:   
  94:          // Time Formats
  95:          /// <summary/>
  96:          public static int Time24 = 0;    // 24-hour format
  97:   
  98:          /// <summary/>
  99:          public static int Time12 = 1;    // 12-hour format
 100:   
 101:          /// <summary/>
 102:          public static int Time12NS = 2;    // 12-hour format with no suffix
 103:   
 104:          /// <summary/>
 105:          public static int Floating = 3;    // floating point number
 106:   
 107:          // Time Names
 108:          /// <summary/>
 109:          public static string[] timeNames = { "Fajr", "Sunrise", "Dhuhr", "Asr", "Sunset", "Maghrib", "Isha" };
 110:          static string InvalidTime = "----";     // The string used for inv
 111:   
 112:   
 113:   
 114:   
 115:          //---------------------- Global Variables --------------------
 116:   
 117:   
 118:          private int calcMethod = 3;        // caculation method
 119:          private int asrJuristic;        // Juristic method for Asr
 120:          private int dhuhrMinutes = 0;        // minutes after mid-day for Dhuhr
 121:          private int adjustHighLats = 1;    // adjusting method for higher latitudes
 122:   
 123:          private int timeFormat = 0;        // time format
 124:   
 125:          private double lat;        // latitude
 126:          private double lng;        // longitude
 127:          private int timeZone;   // time-zone
 128:          private double JDate;      // Julian date
 129:   
 130:          private int[] times;
 131:   
 132:   
 133:          //--------------------- Technical Settings --------------------
 134:   
 135:   
 136:          private int numIterations = 1;        // number of iterations needed to compute times
 137:   
 138:   
 139:   
 140:          //------------------- Calc Method Parameters --------------------
 141:   
 142:          private double[][] methodParams;
 143:   
 144:          /// <summary/>
 145:          public PrayerTime()
 146:          {
 147:              times = new int[7];
 148:              methodParams = new double[8][];
 149:              this.methodParams[Jafari] = new double[] { 16, 0, 4, 0, 14 };
 150:              this.methodParams[Karachi] = new double[] { 18, 1, 0, 0, 18 };
 151:              this.methodParams[ISNA] = new double[] { 15, 1, 0, 0, 15 };
 152:              this.methodParams[MWL] = new double[] { 18, 1, 0, 0, 17 };
 153:              this.methodParams[Makkah] = new double[] { 18.5, 1, 0, 1, 90 };
 154:              this.methodParams[Egypt] = new double[] { 19.5, 1, 0, 0, 17.5 };
 155:              this.methodParams[Tehran] = new double[] { 17.7, 0, 4.5, 0, 14 };
 156:              this.methodParams[Custom] = new double[] { 18, 1, 0, 0, 17 };
 157:          }
 158:   
 159:          // return prayer times for a given date
 160:          /// <summary/>
 161:          public string[] GetPrayerTimes(int year, int month, int day, double latitude, double longitude, int timeZone)
 162:          {
 163:              return this.GetDatePrayerTimes(year, month + 1, day, latitude, longitude, timeZone);
 164:          }
 165:   
 166:          // set the calculation method
 167:          /// <summary/>
 168:          public void SetCalcMethod(int methodID)
 169:          {
 170:              this.calcMethod = methodID;
 171:          }
 172:   
 173:          // set the juristic method for Asr
 174:          /// <summary/>
 175:          public void SetAsrMethod(int methodID)
 176:          {
 177:              if (methodID < 0 || methodID > 1) return;
 178:              this.asrJuristic = methodID;
 179:          }
 180:   
 181:          // set the angle for calculating Fajr
 182:          /// <summary/>
 183:          public void SetFajrAngle(double angle)
 184:          {
 185:              this.SetCustomParams(new int[] { (int)angle, -1, -1, -1, -1 });
 186:          }
 187:   
 188:          // set the angle for calculating Maghrib
 189:          /// <summary/>
 190:          public void SetMaghribAngle(double angle)
 191:          {
 192:              this.SetCustomParams(new int[] { -1, 0, (int)angle, -1, -1 });
 193:          }
 194:   
 195:          // set the angle for calculating Isha
 196:          /// <summary/>
 197:          public void SetIshaAngle(double angle)
 198:          {
 199:              this.SetCustomParams(new int[] { -1, -1, -1, 0, (int)angle });
 200:          }
 201:   
 202:          // set the minutes after mid-day for calculating Dhuhr
 203:          /// <summary/>
 204:          public void SetDhuhrMinutes(int minutes)
 205:          {
 206:              this.dhuhrMinutes = minutes;
 207:          }
 208:   
 209:          // set the minutes after Sunset for calculating Maghrib
 210:          /// <summary/>
 211:          public void SetMaghribMinutes(int minutes)
 212:          {
 213:              this.SetCustomParams(new int[] { -1, 1, minutes, -1, -1 });
 214:          }
 215:   
 216:          // set the minutes after Maghrib for calculating Isha
 217:          /// <summary/>
 218:          public void SetIshaMinutes(int minutes)
 219:          {
 220:              this.SetCustomParams(new int[] { -1, -1, -1, 1, minutes });
 221:          }
 222:   
 223:          // set custom values for calculation parameters
 224:          /// <summary/>
 225:          public void SetCustomParams(int[] param)
 226:          {
 227:              for (int i = 0; i < 5; i++)
 228:              {
 229:                  if (param[i] == -1) this.methodParams[Custom][i] = this.methodParams[this.calcMethod][i];
 230:                  else this.methodParams[Custom][i] = param[i];
 231:              }
 232:   
 233:              this.calcMethod = Custom;
 234:          }
 235:   
 236:          // set adjusting method for higher latitudes
 237:          /// <summary/>
 238:          public void SetHighLatsMethod(int methodID)
 239:          {
 240:              this.adjustHighLats = methodID;
 241:          }
 242:   
 243:          // set the time format
 244:          /// <summary/>
 245:          public void SetTimeFormat(int timeFormat)
 246:          {
 247:              this.timeFormat = timeFormat;
 248:          }
 249:   
 250:          // convert float hours to 24h format
 251:          /// <summary/>
 252:          public string FloatToTime24(double time)
 253:          {
 254:              if (time < 0) return InvalidTime;
 255:              time = this.FixHour(time + 0.5 / 60);  // add 0.5 minutes to round
 256:              double hours = Math.Floor(time);
 257:              double minutes = Math.Floor((time - hours) * 60);
 258:              return this.TwoDigitsFormat((int)hours) + ":" + this.TwoDigitsFormat((int)minutes);
 259:          }
 260:   
 261:          // convert float hours to 12h format
 262:          /// <summary/>
 263:          public string FloatToTime12(double time, bool noSuffix)
 264:          {
 265:              if (time < 0) return InvalidTime;
 266:              time = this.FixHour(time + 0.5 / 60);  // add 0.5 minutes to round
 267:              double hours = Math.Floor(time);
 268:              double minutes = Math.Floor((time - hours) * 60);
 269:              string suffix = hours >= 12 ? " pm" : " am";
 270:              hours = (hours + 12 - 1) % 12 + 1;
 271:              return ((int)hours) + ":" + this.TwoDigitsFormat((int)minutes) + (noSuffix ? "" : suffix);
 272:          }
 273:   
 274:          // convert float hours to 12h format with no suffix
 275:          /// <summary/>
 276:          public string FloatToTime12NS(double time)
 277:          {
 278:              return this.FloatToTime12(time, true);
 279:          }
 280:   
 281:          //---------------------- Compute Prayer Times -----------------------
 282:   
 283:   
 284:          // return prayer times for a given date
 285:          /// <summary/>
 286:          public string[] GetDatePrayerTimes(int year, int month, int day, double latitude, double longitude, int timeZone)
 287:          {
 288:              this.lat = latitude;
 289:              this.lng = longitude;
 290:              this.timeZone = timeZone;
 291:              this.JDate = this.JulianDate(year, month, day) - longitude / (15 * 24);
 292:   
 293:              return this.ComputeDayTimes();
 294:          }
 295:   
 296:          // compute declination angle of sun and equation of time
 297:          /// <summary/>
 298:          public double[] SunPosition(double jd)
 299:          {
 300:              double D = jd - 2451545.0;
 301:              double g = this.FixAngle(357.529 + 0.98560028 * D);
 302:              double q = this.FixAngle(280.459 + 0.98564736 * D);
 303:              double L = this.FixAngle(q + 1.915 * this.Dsin(g) + 0.020 * this.Dsin(2 * g));
 304:   
 305:              double R = 1.00014 - 0.01671 * this.Dcos(g) - 0.00014 * this.Dcos(2 * g);
 306:              double e = 23.439 - 0.00000036 * D;
 307:   
 308:              double d = this.Darcsin(this.Dsin(e) * this.Dsin(L));
 309:              double RA = this.Darctan2(this.Dcos(e) * this.Dsin(L), this.Dcos(L)) / 15;
 310:              RA = this.FixHour(RA);
 311:              double EqT = q / 15 - RA;
 312:   
 313:              return new double[] { d, EqT };
 314:          }
 315:   
 316:          // compute equation of time
 317:          /// <summary/>
 318:          public double EquationOfTime(double jd)
 319:          {
 320:              return this.SunPosition(jd)[1];
 321:          }
 322:   
 323:          // compute declination angle of sun
 324:          /// <summary/>
 325:          public double SunDeclination(double jd)
 326:          {
 327:              return this.SunPosition(jd)[0];
 328:          }
 329:   
 330:          // compute mid-day (Dhuhr, Zawal) time
 331:          /// <summary/>
 332:          public double ComputeMidDay(double t)
 333:          {
 334:              double T = this.EquationOfTime(this.JDate + t);
 335:              double Z = this.FixHour(12 - T);
 336:              return Z;
 337:          }
 338:   
 339:          // compute time for a given angle G
 340:          /// <summary/>
 341:          public double ComputeTime(double G, double t)
 342:          {
 343:              //System.out.println("G: "+G);
 344:   
 345:              double D = this.SunDeclination(this.JDate + t);
 346:              double Z = this.ComputeMidDay(t);
 347:              double V = ((double)1 / 15) * this.Darccos((-this.Dsin(G) - this.Dsin(D) * this.Dsin(this.lat)) /
 348:                      (this.Dcos(D) * this.Dcos(this.lat)));
 349:              return Z + (G > 90 ? -V : V);
 350:          }
 351:   
 352:          // compute the time of Asr
 353:          /// <summary/>
 354:          public double ComputeAsr(int step, double t)  // Shafii: step=1, Hanafi: step=2
 355:          {
 356:              double D = this.SunDeclination(this.JDate + t);
 357:              double G = -this.Darccot(step + this.Dtan(Math.Abs(this.lat - D)));
 358:              return this.ComputeTime(G, t);
 359:          }
 360:   
 361:          //---------------------- Compute Prayer Times -----------------------
 362:   
 363:          // compute prayer times at given julian date
 364:          /// <summary/>
 365:          public double[] ComputeTimes(double[] times)
 366:          {
 367:              double[] t = this.DayPortion(times);
 368:   
 369:   
 370:              double Fajr = this.ComputeTime(180 - this.methodParams[this.calcMethod][0], t[0]);
 371:              double Sunrise = this.ComputeTime(180 - 0.833, t[1]);
 372:              double Dhuhr = this.ComputeMidDay(t[2]);
 373:              double Asr = this.ComputeAsr(1 + this.asrJuristic, t[3]);
 374:              double Sunset = this.ComputeTime(0.833, t[4]); ;
 375:              double Maghrib = this.ComputeTime(this.methodParams[this.calcMethod][2], t[5]);
 376:              double Isha = this.ComputeTime(this.methodParams[this.calcMethod][4], t[6]);
 377:   
 378:              return new double[] { Fajr, Sunrise, Dhuhr, Asr, Sunset, Maghrib, Isha };
 379:          }
 380:   
 381:          // adjust Fajr, Isha and Maghrib for locations in higher latitudes
 382:          /// <summary/>
 383:          public double[] AdjustHighLatTimes(double[] times)
 384:          {
 385:              double nightTime = this.GetTimeDifference(times[4], times[1]); // sunset to sunrise
 386:   
 387:              // Adjust Fajr
 388:              double FajrDiff = this.NightPortion(this.methodParams[this.calcMethod][0]) * nightTime;
 389:              if (this.GetTimeDifference(times[0], times[1]) > FajrDiff)
 390:                  times[0] = times[1] - FajrDiff;
 391:   
 392:              // Adjust Isha
 393:              double IshaAngle = (this.methodParams[this.calcMethod][3] == 0) ? this.methodParams
 394:   
 395:          [this.calcMethod][4] : 18;
 396:              double IshaDiff = this.NightPortion(IshaAngle) * nightTime;
 397:              if (this.GetTimeDifference(times[4], times[6]) > IshaDiff)
 398:                  times[6] = times[4] + IshaDiff;
 399:   
 400:              // Adjust Maghrib
 401:              double MaghribAngle = (methodParams[this.calcMethod][1] == 0) ? this.methodParams
 402:   
 403:          [this.calcMethod][2] : 4;
 404:              double MaghribDiff = this.NightPortion(MaghribAngle) * nightTime;
 405:              if (this.GetTimeDifference(times[4], times[5]) > MaghribDiff)
 406:                  times[5] = times[4] + MaghribDiff;
 407:   
 408:              return times;
 409:          }
 410:   
 411:          // the night portion used for adjusting times in higher latitudes
 412:          /// <summary/>
 413:          public double NightPortion(double angle)
 414:          {
 415:              double val = 0;
 416:              if (this.adjustHighLats == AngleBased)
 417:                  val = 1.0 / 60.0 * angle;
 418:              if (this.adjustHighLats == MidNight)
 419:                  val = 1.0 / 2.0;
 420:              if (this.adjustHighLats == OneSeventh)
 421:                  val = 1.0 / 7.0;
 422:   
 423:              return val;
 424:          }
 425:   
 426:          /// <summary/>
 427:          public double[] DayPortion(double[] times)
 428:          {
 429:              for (int i = 0; i < times.Length; i++)
 430:              {
 431:                  times[i] /= 24;
 432:              }
 433:              return times;
 434:          }
 435:   
 436:          // compute prayer times at given julian date
 437:          /// <summary/>
 438:          public string[] ComputeDayTimes()
 439:          {
 440:              double[] times = { 5, 6, 12, 13, 18, 18, 18 }; //default times
 441:   
 442:              for (int i = 0; i < this.numIterations; i++)
 443:              {
 444:                  times = this.ComputeTimes(times);
 445:              }
 446:   
 447:              times = this.AdjustTimes(times);
 448:              return this.AdjustTimesFormat(times);
 449:          }
 450:   
 451:   
 452:          // adjust times in a prayer time array
 453:          /// <summary/>
 454:          public double[] AdjustTimes(double[] times)
 455:          {
 456:              for (int i = 0; i < 7; i++)
 457:              {
 458:                  times[i] += this.timeZone - this.lng / 15;
 459:              }
 460:              times[2] += this.dhuhrMinutes / 60; //Dhuhr
 461:              if (this.methodParams[this.calcMethod][1] == 1) // Maghrib
 462:                  times[5] = times[4] + this.methodParams[this.calcMethod][2] / 60.0;
 463:              if (this.methodParams[this.calcMethod][3] == 1) // Isha
 464:                  times[6] = times[5] + this.methodParams[this.calcMethod][4] / 60.0;
 465:   
 466:              if (this.adjustHighLats != None)
 467:              {
 468:                  times = this.AdjustHighLatTimes(times);
 469:              }
 470:   
 471:              return times;
 472:          }
 473:   
 474:          /// <summary/>
 475:          public string[] AdjustTimesFormat(double[] times)
 476:          {
 477:              string[] formatted = new string[times.Length];
 478:   
 479:              if (this.timeFormat == Floating)
 480:              {
 481:                  for (int i = 0; i < times.Length; ++i)
 482:                  {
 483:                      formatted[i] = times[i] + "";
 484:                  }
 485:                  return formatted;
 486:              }
 487:   
 488:              for (int i = 0; i < 7; i++)
 489:              {
 490:                  if (this.timeFormat == Time12)
 491:                      formatted[i] = this.FloatToTime12(times[i], true);
 492:                  else if (this.timeFormat == Time12NS)
 493:                      formatted[i] = this.FloatToTime12NS(times[i]);
 494:                  else
 495:                      formatted[i] = this.FloatToTime24(times[i]);
 496:              }
 497:              return formatted;
 498:          }
 499:   
 500:          //---------------------- Misc Functions -----------------------
 501:   
 502:          // compute the difference between two times
 503:          /// <summary/>
 504:          public double GetTimeDifference(double c1, double c2)
 505:          {
 506:              double diff = this.FixHour(c2 - c1); ;
 507:              return diff;
 508:          }
 509:   
 510:          // add a leading 0 if necessary
 511:          /// <summary/>
 512:          public string TwoDigitsFormat(int num)
 513:          {
 514:   
 515:              return (num < 10) ? "0" + num : num + "";
 516:          }
 517:   
 518:          //---------------------- Julian Date Functions -----------------------
 519:   
 520:          // calculate julian date from a calendar date
 521:          /// <summary/>
 522:          public double JulianDate(int year, int month, int day)
 523:          {
 524:              if (month <= 2)
 525:              {
 526:                  year -= 1;
 527:                  month += 12;
 528:              }
 529:   
 530:              double A = (double)Math.Floor(year / 100.0);
 531:              double B = 2 - A + Math.Floor(A / 4);
 532:   
 533:              double JD = Math.Floor(365.25 * (year + 4716)) + Math.Floor(30.6001 * (month + 1)) + day + B - 1524.5;
 534:              return JD;
 535:          }
 536:   
 537:   
 538:          //---------------------- Time-Zone Functions -----------------------
 539:   
 540:   
 541:          // detect daylight saving in a given date
 542:          /// <summary/>
 543:          public bool UseDayLightaving(int year, int month, int day)
 544:          {
 545:              return System.TimeZoneInfo.Local.IsDaylightSavingTime(new DateTime(year, month, day));
 546:              // TimeZone . CurrentTimeZone . IsDaylightSavingTime ( new DateTime ( year , month , day ) ); 
 547:          }
 548:   
 549:          // ---------------------- Trigonometric Functions -----------------------
 550:   
 551:          // degree sin
 552:          /// <summary/>
 553:          public double Dsin(double d)
 554:          {
 555:              return Math.Sin(this.DegreeToRadian(d));
 556:          }
 557:   
 558:          // degree cos
 559:          /// <summary/>
 560:          public double Dcos(double d)
 561:          {
 562:              return Math.Cos(this.DegreeToRadian(d));
 563:          }
 564:   
 565:          // degree tan
 566:          /// <summary/>
 567:          public double Dtan(double d)
 568:          {
 569:              return Math.Tan(this.DegreeToRadian(d));
 570:          }
 571:   
 572:          // degree arcsin
 573:          /// <summary/>
 574:          public double Darcsin(double x)
 575:          {
 576:              return this.RadianToDegree(Math.Asin(x));
 577:          }
 578:   
 579:          // degree arccos
 580:          /// <summary/>
 581:          public double Darccos(double x)
 582:          {
 583:              return this.RadianToDegree(Math.Acos(x));
 584:          }
 585:   
 586:          // degree arctan
 587:          /// <summary/>
 588:          public double Darctan(double x)
 589:          {
 590:              return this.RadianToDegree(Math.Atan(x));
 591:          }
 592:   
 593:          // degree arctan2
 594:          /// <summary/>
 595:          public double Darctan2(double y, double x)
 596:          {
 597:              return this.RadianToDegree(Math.Atan2(y, x));
 598:          }
 599:   
 600:          // degree arccot
 601:          /// <summary/>
 602:          public double Darccot(double x)
 603:          {
 604:              return this.RadianToDegree(Math.Atan(1 / x));
 605:          }
 606:   
 607:   
 608:          // Radian to Degree
 609:          /// <summary/>
 610:          public double RadianToDegree(double radian)
 611:          {
 612:              return (radian * 180.0) / Math.PI;
 613:          }
 614:   
 615:          // degree to radian
 616:          /// <summary/>
 617:          public double DegreeToRadian(double degree)
 618:          {
 619:              return (degree * Math.PI) / 180.0;
 620:          }
 621:   
 622:          /// <summary/>
 623:          public double FixAngle(double angel)
 624:          {
 625:              angel = angel - 360.0 * (Math.Floor(angel / 360.0));
 626:              angel = angel < 0 ? angel + 360.0 : angel;
 627:              return angel;
 628:          }
 629:   
 630:          // range reduce hours to 0..23
 631:          /// <summary/>
 632:          public double FixHour(double hour)
 633:          {
 634:              hour = hour - 24.0 * (Math.Floor(hour / 24.0));
 635:              hour = hour < 0 ? hour + 24.0 : hour;
 636:              return hour;
 637:          }
 638:      }
 639:  }