content: //--------------------- Copyright Block ----------------------
  /* 
  
  PrayTime.java: Prayer Times Calculator (ver 1.0)
  Copyright (C) 2007-2010 PrayTimes.org
  
  Java Code By: Hussain Ali Khan
  Original JS Code By: Hamid Zarrabi-Zadeh
  
  License: GNU LGPL v3.0
  
  TERMS OF USE:
  	Permission is granted to use this code, with or 
  	without modification, in any website or application 
  	provided that credit is given to the original work 
  	with a link back to PrayTimes.org.
  
  This program is distributed in the hope that it will 
  be useful, but WITHOUT ANY WARRANTY. 
  
  PLEASE DO NOT REMOVE THIS COPYRIGHT BLOCK.
  
  */
  
  package newpackage;
  
  
  import java.util.ArrayList;
  import java.util.Calendar;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.TimeZone;
  
  public class PrayTime {
  
      // ---------------------- Global Variables --------------------
      private int calcMethod; // caculation method
      private int asrJuristic; // Juristic method for Asr
      private int dhuhrMinutes; // minutes after mid-day for Dhuhr
      private int adjustHighLats; // adjusting method for higher latitudes
      private int timeFormat; // time format
      private double lat; // latitude
      private double lng; // longitude
      private double timeZone; // time-zone
      private double JDate; // Julian date
      // ------------------------------------------------------------
      // Calculation Methods
      private int Jafari; // Ithna Ashari
      private int Karachi; // University of Islamic Sciences, Karachi
      private int ISNA; // Islamic Society of North America (ISNA)
      private int MWL; // Muslim World League (MWL)
      private int Makkah; // Umm al-Qura, Makkah
      private int Egypt; // Egyptian General Authority of Survey
      private int Custom; // Custom Setting
      private int Tehran; // Institute of Geophysics, University of Tehran
      // Juristic Methods
      private int Shafii; // Shafii (standard)
      private int Hanafi; // Hanafi
      // Adjusting Methods for Higher Latitudes
      private int None; // No adjustment
      private int MidNight; // middle of night
      private int OneSeventh; // 1/7th of night
      private int AngleBased; // angle/60th of night
      // Time Formats
      private int Time24; // 24-hour format
      private int Time12; // 12-hour format
      private int Time12NS; // 12-hour format with no suffix
      private int Floating; // floating point number
      // Time Names
      private ArrayList<String> timeNames;
      private String InvalidTime; // The string used for invalid times
      // --------------------- Technical Settings --------------------
      private int numIterations; // number of iterations needed to compute times
      // ------------------- Calc Method Parameters --------------------
      private HashMap<Integer, double[]> methodParams;
  
      /*
       * this.methodParams[methodNum] = new Array(fa, ms, mv, is, iv);
       *
       * fa : fajr angle ms : maghrib selector (0 = angle; 1 = minutes after
       * sunset) mv : maghrib parameter value (in angle or minutes) is : isha
       * selector (0 = angle; 1 = minutes after maghrib) iv : isha parameter value
       * (in angle or minutes)
       */
      private double[] prayerTimesCurrent;
      private int[] offsets;
  
      public PrayTime() {
          // Initialize vars
  
          this.setCalcMethod(0);
          this.setAsrJuristic(0);
          this.setDhuhrMinutes(0);
          this.setAdjustHighLats(1);
          this.setTimeFormat(0);
  
          // Calculation Methods
          this.setJafari(0); // Ithna Ashari
          this.setKarachi(1); // University of Islamic Sciences, Karachi
          this.setISNA(2); // Islamic Society of North America (ISNA)
          this.setMWL(3); // Muslim World League (MWL)
          this.setMakkah(4); // Umm al-Qura, Makkah
          this.setEgypt(5); // Egyptian General Authority of Survey
          this.setTehran(6); // Institute of Geophysics, University of Tehran
          this.setCustom(7); // Custom Setting
  
          // Juristic Methods
          this.setShafii(0); // Shafii (standard)
          this.setHanafi(1); // Hanafi
  
          // Adjusting Methods for Higher Latitudes
          this.setNone(0); // No adjustment
          this.setMidNight(1); // middle of night
          this.setOneSeventh(2); // 1/7th of night
          this.setAngleBased(3); // angle/60th of night
  
          // Time Formats
          this.setTime24(0); // 24-hour format
          this.setTime12(1); // 12-hour format
          this.setTime12NS(2); // 12-hour format with no suffix
          this.setFloating(3); // floating point number
  
          // Time Names
          timeNames = new ArrayList<String>();
          timeNames.add("Fajr");
          timeNames.add("Sunrise");
          timeNames.add("Dhuhr");
          timeNames.add("Asr");
          timeNames.add("Sunset");
          timeNames.add("Maghrib");
          timeNames.add("Isha");
  
          InvalidTime = "-----"; // The string used for invalid times
  
          // --------------------- Technical Settings --------------------
  
          this.setNumIterations(1); // number of iterations needed to compute
          // times
  
          // ------------------- Calc Method Parameters --------------------
  
          // Tuning offsets {fajr, sunrise, dhuhr, asr, sunset, maghrib, isha}
          offsets = new int[7];
          offsets[0] = 0;
          offsets[1] = 0;
          offsets[2] = 0;
          offsets[3] = 0;
          offsets[4] = 0;
          offsets[5] = 0;
          offsets[6] = 0;
  
          /*
           *
           * fa : fajr angle ms : maghrib selector (0 = angle; 1 = minutes after
           * sunset) mv : maghrib parameter value (in angle or minutes) is : isha
           * selector (0 = angle; 1 = minutes after maghrib) iv : isha parameter
           * value (in angle or minutes)
           */
          methodParams = new HashMap<Integer, double[]>();
  
          // Jafari
          double[] Jvalues = {16,0,4,0,14};
          methodParams.put(Integer.valueOf(this.getJafari()), Jvalues);
  
          // Karachi
          double[] Kvalues = {18,1,0,0,18};
          methodParams.put(Integer.valueOf(this.getKarachi()), Kvalues);
  
          // ISNA
          double[] Ivalues = {15,1,0,0,15};
          methodParams.put(Integer.valueOf(this.getISNA()), Ivalues);
  
          // MWL
          double[] MWvalues = {18,1,0,0,17};
          methodParams.put(Integer.valueOf(this.getMWL()), MWvalues);
  
          // Makkah
          double[] MKvalues = {18.5,1,0,1,90};
          methodParams.put(Integer.valueOf(this.getMakkah()), MKvalues);
  
          // Egypt
          double[] Evalues = {19.5,1,0,0,17.5};
          methodParams.put(Integer.valueOf(this.getEgypt()), Evalues);
  
          // Tehran
          double[] Tvalues = {17.7,0,4.5,0,14};
          methodParams.put(Integer.valueOf(this.getTehran()), Tvalues);
  
          // Custom
          double[] Cvalues = {18,1,0,0,17};
          methodParams.put(Integer.valueOf(this.getCustom()), Cvalues);
  
      }
  
      // ---------------------- Trigonometric Functions -----------------------
      // range reduce angle in degrees.
      private double fixangle(double a) {
  
          a = a - (360 * (Math.floor(a / 360.0)));
  
          a = a < 0 ? (a + 360) : a;
  
          return a;
      }
  
      // range reduce hours to 0..23
      private double fixhour(double a) {
          a = a - 24.0 * Math.floor(a / 24.0);
          a = a < 0 ? (a + 24) : a;
          return a;
      }
  
      // radian to degree
      private double radiansToDegrees(double alpha) {
          return ((alpha * 180.0) / Math.PI);
      }
  
      // deree to radian
      private double DegreesToRadians(double alpha) {
          return ((alpha * Math.PI) / 180.0);
      }
  
      // degree sin
      private double dsin(double d) {
          return (Math.sin(DegreesToRadians(d)));
      }
  
      // degree cos
      private double dcos(double d) {
          return (Math.cos(DegreesToRadians(d)));
      }
  
      // degree tan
      private double dtan(double d) {
          return (Math.tan(DegreesToRadians(d)));
      }
  
      // degree arcsin
      private double darcsin(double x) {
          double val = Math.asin(x);
          return radiansToDegrees(val);
      }
  
      // degree arccos
      private double darccos(double x) {
          double val = Math.acos(x);
          return radiansToDegrees(val);
      }
  
      // degree arctan
      private double darctan(double x) {
          double val = Math.atan(x);
          return radiansToDegrees(val);
      }
  
      // degree arctan2
      private double darctan2(double y, double x) {
          double val = Math.atan2(y, x);
          return radiansToDegrees(val);
      }
  
      // degree arccot
      private double darccot(double x) {
          double val = Math.atan2(1.0, x);
          return radiansToDegrees(val);
      }
  
      // ---------------------- Time-Zone Functions -----------------------
      // compute local time-zone for a specific date
      private double getTimeZone1() {
          TimeZone timez = TimeZone.getDefault();
          double hoursDiff = (timez.getRawOffset() / 1000.0) / 3600;
          return hoursDiff;
      }
  
      // compute base time-zone of the system
      private double getBaseTimeZone() {
          TimeZone timez = TimeZone.getDefault();
          double hoursDiff = (timez.getRawOffset() / 1000.0) / 3600;
          return hoursDiff;
  
      }
  
      // detect daylight saving in a given date
      private double detectDaylightSaving() {
          TimeZone timez = TimeZone.getDefault();
          double hoursDiff = timez.getDSTSavings();
          return hoursDiff;
      }
  
      // ---------------------- Julian Date Functions -----------------------
      // calculate julian date from a calendar date
      private double julianDate(int year, int month, int day) {
          
          if (month <= 2) {
              year -= 1;
              month += 12;
          }
          double A = Math.floor(year / 100.0);
  
          double B = 2 - A + Math.floor(A / 4.0);
  
          double JD = Math.floor(365.25 * (year + 4716))
                  + Math.floor(30.6001 * (month + 1)) + day + B - 1524.5;
  
          return JD;
      }
  
      // convert a calendar date to julian date (second method)
      private double calcJD(int year, int month, int day) {
          double J1970 = 2440588.0;
          Date date = new Date(year, month - 1, day);
          
          double ms = date.getTime(); // # of milliseconds since midnight Jan 1,
          // 1970
          double days = Math.floor(ms / (1000.0 * 60.0 * 60.0 * 24.0));
          return J1970 + days - 0.5;
  
      }
  
      // ---------------------- Calculation Functions -----------------------
      // References:
      // http://www.ummah.net/astronomy/saltime
      // http://aa.usno.navy.mil/faq/docs/SunApprox.html
      // compute declination angle of sun and equation of time
      private double[] sunPosition(double jd) {
  
          double D = jd - 2451545;
          double g = fixangle(357.529 + 0.98560028 * D);
          double q = fixangle(280.459 + 0.98564736 * D);
          double L = fixangle(q + (1.915 * dsin(g)) + (0.020 * dsin(2 * g)));
         
          // double R = 1.00014 - 0.01671 * [self dcos:g] - 0.00014 * [self dcos:
          // (2*g)];
          double e = 23.439 - (0.00000036 * D);
          double d = darcsin(dsin(e) * dsin(L));
          double RA = (darctan2((dcos(e) * dsin(L)), (dcos(L))))/ 15.0;
          RA = fixhour(RA);
          double EqT = q/15.0 - RA;
          double[] sPosition = new double[2];
          sPosition[0] = d;
          sPosition[1] = EqT;
  
          return sPosition;
      }
  
      // compute equation of time
      private double equationOfTime(double jd) {
          double eq = sunPosition(jd)[1];
          return eq;
      }
  
      // compute declination angle of sun
      private double sunDeclination(double jd) {
          double d = sunPosition(jd)[0];
          return d;
      }
  
      // compute mid-day (Dhuhr, Zawal) time
      private double computeMidDay(double t) {
          double T = equationOfTime(this.getJDate() + t);
          double Z = fixhour(12 - T);
          return Z;
      }
  
      // compute time for a given angle G
      private double computeTime(double G, double t) {
  
          double D = sunDeclination(this.getJDate() + t);
          double Z = computeMidDay(t);
          double Beg = -dsin(G) - dsin(D) * dsin(this.getLat());
          double Mid = dcos(D) * dcos(this.getLat());
          double V = darccos(Beg/Mid)/15.0;
          
          return Z + (G > 90 ? -V : V);
      }
  
      // compute the time of Asr
      // Shafii: step=1, Hanafi: step=2
      private double computeAsr(double step, double t) {
          double D = sunDeclination(this.getJDate() + t);
          double G = -darccot(step + dtan(Math.abs(this.getLat() - D)));
          return computeTime(G, t);
      }
  
      // ---------------------- Misc Functions -----------------------
      // compute the difference between two times
      private double timeDiff(double time1, double time2) {
          return fixhour(time2 - time1);
      }
  
      // -------------------- Interface Functions --------------------
      // return prayer times for a given date
      private ArrayList<String> getDatePrayerTimes(int year, int month, int day,
              double latitude, double longitude, double tZone) {
          this.setLat(latitude);
          this.setLng(longitude);
          this.setTimeZone(tZone);
          this.setJDate(julianDate(year, month, day));
          double lonDiff = longitude / (15.0 * 24.0);
          this.setJDate(this.getJDate() - lonDiff);
          return computeDayTimes();
      }
  
      // return prayer times for a given date
      private ArrayList<String> getPrayerTimes(Calendar date, double latitude,
              double longitude, double tZone) {
  
          int year = date.get(Calendar.YEAR);
          int month = date.get(Calendar.MONTH);
          int day = date.get(Calendar.DATE);
  
          return getDatePrayerTimes(year, month+1, day, latitude, longitude, tZone);
      }
  
      // set custom values for calculation parameters
      private void setCustomParams(double[] params) {
  
          for (int i = 0; i < 5; i++) {
              if (params[i] == -1) {
                  params[i] = methodParams.get(this.getCalcMethod())[i];
                  methodParams.put(this.getCustom(), params);
              } else {
                  methodParams.get(this.getCustom())[i] = params[i];
              }
          }
          this.setCalcMethod(this.getCustom());
      }
  
      // set the angle for calculating Fajr
      public void setFajrAngle(double angle) {
          double[] params = {angle, -1, -1, -1, -1};
          setCustomParams(params);
      }
  
      // set the angle for calculating Maghrib
      public void setMaghribAngle(double angle) {
          double[] params = {-1, 0, angle, -1, -1};
          setCustomParams(params);
  
      }
  
      // set the angle for calculating Isha
      public void setIshaAngle(double angle) {
          double[] params = {-1, -1, -1, 0, angle};
          setCustomParams(params);
  
      }
  
      // set the minutes after Sunset for calculating Maghrib
      public void setMaghribMinutes(double minutes) {
          double[] params = {-1, 1, minutes, -1, -1};
          setCustomParams(params);
  
      }
  
      // set the minutes after Maghrib for calculating Isha
      public void setIshaMinutes(double minutes) {
          double[] params = {-1, -1, -1, 1, minutes};
          setCustomParams(params);
  
      }
  
      // convert double hours to 24h format
      public String floatToTime24(double time) {
  
          String result;
  
          if (Double.isNaN(time)) {
              return InvalidTime;
          }
  
          time = fixhour(time + 0.5 / 60.0); // add 0.5 minutes to round
          int hours = (int)Math.floor(time);
          double minutes = Math.floor((time - hours) * 60.0);
  
          if ((hours >= 0 && hours <= 9) && (minutes >= 0 && minutes <= 9)) {
              result = "0" + hours + ":0" + Math.round(minutes);
          } else if ((hours >= 0 && hours <= 9)) {
              result = "0" + hours + ":" + Math.round(minutes);
          } else if ((minutes >= 0 && minutes <= 9)) {
              result = hours + ":0" + Math.round(minutes);
          } else {
              result = hours + ":" + Math.round(minutes);
          }
          return result;
      }
  
      // convert double hours to 12h format
      public String floatToTime12(double time, boolean noSuffix) {
  
          if (Double.isNaN(time)) {
              return InvalidTime;
          }
  
          time = fixhour(time + 0.5 / 60); // add 0.5 minutes to round
          int hours = (int)Math.floor(time);
          double minutes = Math.floor((time - hours) * 60);
          String suffix, result;
          if (hours >= 12) {
              suffix = "pm";
          } else {
              suffix = "am";
          }
          hours = ((((hours+ 12) -1) % (12))+ 1);
          /*hours = (hours + 12) - 1;
          int hrs = (int) hours % 12;
          hrs += 1;*/
          if (noSuffix == false) {
              if ((hours >= 0 && hours <= 9) && (minutes >= 0 && minutes <= 9)) {
                  result = "0" + hours + ":0" + Math.round(minutes) + " "
                          + suffix;
              } else if ((hours >= 0 && hours <= 9)) {
                  result = "0" + hours + ":" + Math.round(minutes) + " " + suffix;
              } else if ((minutes >= 0 && minutes <= 9)) {
                  result = hours + ":0" + Math.round(minutes) + " " + suffix;
              } else {
                  result = hours + ":" + Math.round(minutes) + " " + suffix;
              }
  
          } else {
              if ((hours >= 0 && hours <= 9) && (minutes >= 0 && minutes <= 9)) {
                  result = "0" + hours + ":0" + Math.round(minutes);
              } else if ((hours >= 0 && hours <= 9)) {
                  result = "0" + hours + ":" + Math.round(minutes);
              } else if ((minutes >= 0 && minutes <= 9)) {
                  result = hours + ":0" + Math.round(minutes);
              } else {
                  result = hours + ":" + Math.round(minutes);
              }
          }
          return result;
  
      }
  
      // convert double hours to 12h format with no suffix
      public String floatToTime12NS(double time) {
          return floatToTime12(time, true);
      }
  
      // ---------------------- Compute Prayer Times -----------------------
      // compute prayer times at given julian date
      private double[] computeTimes(double[] times) {
  
          double[] t = dayPortion(times);
  
          double Fajr = this.computeTime(
                  180 - methodParams.get(this.getCalcMethod())[0], t[0]);
          
          double Sunrise = this.computeTime(180 - 0.833, t[1]);
          
          double Dhuhr = this.computeMidDay(t[2]);
          double Asr = this.computeAsr(1 + this.getAsrJuristic(), t[3]);
          double Sunset = this.computeTime(0.833, t[4]);
          
          double Maghrib = this.computeTime(
                  methodParams.get(this.getCalcMethod())[2], t[5]);
          double Isha = this.computeTime(
                  methodParams.get(this.getCalcMethod())[4], t[6]);
  
          double[] CTimes = {Fajr, Sunrise, Dhuhr, Asr, Sunset, Maghrib, Isha};
          
          return CTimes;
  
      }
  
      // compute prayer times at given julian date
      private ArrayList<String> computeDayTimes() {
          double[] times = {5, 6, 12, 13, 18, 18, 18}; // default times
  
          for (int i = 1; i <= this.getNumIterations(); i++) {
              times = computeTimes(times);
          }
          
          times = adjustTimes(times);
          times = tuneTimes(times);
          
          return adjustTimesFormat(times);
      }
  
      // adjust times in a prayer time array
      private double[] adjustTimes(double[] times) {
          for (int i = 0; i < times.length; i++) {
              times[i] += this.getTimeZone() - this.getLng() / 15;
          }
           
          times[2] += this.getDhuhrMinutes() / 60; // Dhuhr
          if (methodParams.get(this.getCalcMethod())[1] == 1) // Maghrib
          {
              times[5] = times[4] + methodParams.get(this.getCalcMethod())[2]/ 60;
          }
          if (methodParams.get(this.getCalcMethod())[3] == 1) // Isha
          {
              times[6] = times[5] + methodParams.get(this.getCalcMethod())[4]/ 60;
          }
          
          if (this.getAdjustHighLats() != this.getNone()) {
              times = adjustHighLatTimes(times);
          }
          
          return times;
      }
  
      // convert times array to given time format
      private ArrayList<String> adjustTimesFormat(double[] times) {
  
          ArrayList<String> result = new ArrayList<String>();
  
          if (this.getTimeFormat() == this.getFloating()) {
              for (double time : times) {
                  result.add(String.valueOf(time));
              }
              return result;
          }
  
          for (int i = 0; i < 7; i++) {
              if (this.getTimeFormat() == this.getTime12()) {
                  result.add(floatToTime12(times[i], false));
              } else if (this.getTimeFormat() == this.getTime12NS()) {
                  result.add(floatToTime12(times[i], true));
              } else {
                  result.add(floatToTime24(times[i]));
              }
          }
          return result;
      }
  
      // adjust Fajr, Isha and Maghrib for locations in higher latitudes
      private double[] adjustHighLatTimes(double[] times) {
          double nightTime = timeDiff(times[4], times[1]); // sunset to sunrise
          
          // Adjust Fajr
          double FajrDiff = nightPortion(methodParams.get(this.getCalcMethod())[0]) * nightTime;
          
          if (Double.isNaN(times[0]) || timeDiff(times[0], times[1]) > FajrDiff) {
              times[0] = times[1] - FajrDiff;
          }
  
          // Adjust Isha
          double IshaAngle = (methodParams.get(this.getCalcMethod())[3] == 0) ? methodParams.get(this.getCalcMethod())[4] : 18;
          double IshaDiff = this.nightPortion(IshaAngle) * nightTime;
          if (Double.isNaN(times[6]) || this.timeDiff(times[4], times[6]) > IshaDiff) {
              times[6] = times[4] + IshaDiff;
          }
  
          // Adjust Maghrib
          double MaghribAngle = (methodParams.get(this.getCalcMethod())[1] == 0) ? methodParams.get(this.getCalcMethod())[2] : 4;
          double MaghribDiff = nightPortion(MaghribAngle) * nightTime;
          if (Double.isNaN(times[5]) || this.timeDiff(times[4], times[5]) > MaghribDiff) {
              times[5] = times[4] + MaghribDiff;
          }
          
          return times;
      }
  
      // the night portion used for adjusting times in higher latitudes
      private double nightPortion(double angle) {
         double calc = 0;
  
  	if (adjustHighLats == AngleBased)
  		calc = (angle)/60.0;
  	else if (adjustHighLats == MidNight)
  		calc = 0.5;
  	else if (adjustHighLats == OneSeventh)
  		calc = 0.14286;
  
  	return calc;
      }
  
      // convert hours to day portions
      private double[] dayPortion(double[] times) {
          for (int i = 0; i < 7; i++) {
              times[i] /= 24;
          }
          return times;
      }
  
      // Tune timings for adjustments
      // Set time offsets
      public void tune(int[] offsetTimes) {
  
          for (int i = 0; i < offsetTimes.length; i++) { // offsetTimes length
              // should be 7 in order
              // of Fajr, Sunrise,
              // Dhuhr, Asr, Sunset,
              // Maghrib, Isha
              this.offsets[i] = offsetTimes[i];
          }
      }
  
      private double[] tuneTimes(double[] times) {
          for (int i = 0; i < times.length; i++) {
              times[i] = times[i] + this.offsets[i] / 60.0;
          }
  
          return times;
      }
  
      /**
       * @param args
       */
      public static void main(String[] args) {
          double latitude = -37.823689;
          double longitude = 145.121597;
          double timezone = 10;
          // Test Prayer times here
          PrayTime prayers = new PrayTime();
  
          prayers.setTimeFormat(prayers.Time12);
          prayers.setCalcMethod(prayers.Jafari);
          prayers.setAsrJuristic(prayers.Shafii);
          prayers.setAdjustHighLats(prayers.AngleBased);
          int[] offsets = {0, 0, 0, 0, 0, 0, 0}; // {Fajr,Sunrise,Dhuhr,Asr,Sunset,Maghrib,Isha}
          prayers.tune(offsets);
  
          Date now = new Date();
          Calendar cal = Calendar.getInstance();
          cal.setTime(now);
  
          ArrayList<String> prayerTimes = prayers.getPrayerTimes(cal,
                  latitude, longitude, timezone);
          ArrayList<String> prayerNames = prayers.getTimeNames();
  
          for (int i = 0; i < prayerTimes.size(); i++) {
              System.out.println(prayerNames.get(i) + " - " + prayerTimes.get(i));
          }
  
      }
  
      public int getCalcMethod() {
          return calcMethod;
      }
  
      public void setCalcMethod(int calcMethod) {
          this.calcMethod = calcMethod;
      }
  
      public int getAsrJuristic() {
          return asrJuristic;
      }
  
      public void setAsrJuristic(int asrJuristic) {
          this.asrJuristic = asrJuristic;
      }
  
      public int getDhuhrMinutes() {
          return dhuhrMinutes;
      }
  
      public void setDhuhrMinutes(int dhuhrMinutes) {
          this.dhuhrMinutes = dhuhrMinutes;
      }
  
      public int getAdjustHighLats() {
          return adjustHighLats;
      }
  
      public void setAdjustHighLats(int adjustHighLats) {
          this.adjustHighLats = adjustHighLats;
      }
  
      public int getTimeFormat() {
          return timeFormat;
      }
  
      public void setTimeFormat(int timeFormat) {
          this.timeFormat = timeFormat;
      }
  
      public double getLat() {
          return lat;
      }
  
      public void setLat(double lat) {
          this.lat = lat;
      }
  
      public double getLng() {
          return lng;
      }
  
      public void setLng(double lng) {
          this.lng = lng;
      }
  
      public double getTimeZone() {
          return timeZone;
      }
  
      public void setTimeZone(double timeZone) {
          this.timeZone = timeZone;
      }
  
      public double getJDate() {
          return JDate;
      }
  
      public void setJDate(double jDate) {
          JDate = jDate;
      }
  
      private int getJafari() {
          return Jafari;
      }
  
      private void setJafari(int jafari) {
          Jafari = jafari;
      }
  
      private int getKarachi() {
          return Karachi;
      }
  
      private void setKarachi(int karachi) {
          Karachi = karachi;
      }
  
      private int getISNA() {
          return ISNA;
      }
  
      private void setISNA(int iSNA) {
          ISNA = iSNA;
      }
  
      private int getMWL() {
          return MWL;
      }
  
      private void setMWL(int mWL) {
          MWL = mWL;
      }
  
      private int getMakkah() {
          return Makkah;
      }
  
      private void setMakkah(int makkah) {
          Makkah = makkah;
      }
  
      private int getEgypt() {
          return Egypt;
      }
  
      private void setEgypt(int egypt) {
          Egypt = egypt;
      }
  
      private int getCustom() {
          return Custom;
      }
  
      private void setCustom(int custom) {
          Custom = custom;
      }
  
      private int getTehran() {
          return Tehran;
      }
  
      private void setTehran(int tehran) {
          Tehran = tehran;
      }
  
      private int getShafii() {
          return Shafii;
      }
  
      private void setShafii(int shafii) {
          Shafii = shafii;
      }
  
      private int getHanafi() {
          return Hanafi;
      }
  
      private void setHanafi(int hanafi) {
          Hanafi = hanafi;
      }
  
      private int getNone() {
          return None;
      }
  
      private void setNone(int none) {
          None = none;
      }
  
      private int getMidNight() {
          return MidNight;
      }
  
      private void setMidNight(int midNight) {
          MidNight = midNight;
      }
  
      private int getOneSeventh() {
          return OneSeventh;
      }
  
      private void setOneSeventh(int oneSeventh) {
          OneSeventh = oneSeventh;
      }
  
      private int getAngleBased() {
          return AngleBased;
      }
  
      private void setAngleBased(int angleBased) {
          AngleBased = angleBased;
      }
  
      private int getTime24() {
          return Time24;
      }
  
      private void setTime24(int time24) {
          Time24 = time24;
      }
  
      private int getTime12() {
          return Time12;
      }
  
      private void setTime12(int time12) {
          Time12 = time12;
      }
  
      private int getTime12NS() {
          return Time12NS;
      }
  
      private void setTime12NS(int time12ns) {
          Time12NS = time12ns;
      }
  
      private int getFloating() {
          return Floating;
      }
  
      private void setFloating(int floating) {
          Floating = floating;
      }
  
      private int getNumIterations() {
          return numIterations;
      }
  
      private void setNumIterations(int numIterations) {
          this.numIterations = numIterations;
      }
  
      public ArrayList<String> getTimeNames() {
          return timeNames;
      }
  }
  