I18N_Arabic
[ class tree: I18N_Arabic ] [ index: I18N_Arabic ] [ all elements ]

Source for file Salat.php

Documentation is available at Salat.php

  1. <?php
  2. /**
  3.  * ----------------------------------------------------------------------
  4.  *  
  5.  * Copyright (c) 2006-2016 Khaled Al-Sham'aa
  6.  *  
  7.  * http://www.ar-php.org
  8.  *  
  9.  * PHP Version 5
  10.  *  
  11.  * ----------------------------------------------------------------------
  12.  *  
  13.  * LICENSE
  14.  *
  15.  * This program is open source product; you can redistribute it and/or
  16.  * modify it under the terms of the GNU Lesser General Public License (LGPL)
  17.  * as published by the Free Software Foundation; either version 3
  18.  * of the License, or (at your option) any later version.
  19.  *  
  20.  * This program is distributed in the hope that it will be useful,
  21.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23.  * GNU Lesser General Public License for more details.
  24.  *  
  25.  * You should have received a copy of the GNU Lesser General Public License
  26.  * along with this program.  If not, see <http://www.gnu.org/licenses/lgpl.txt>.
  27.  *  
  28.  * ----------------------------------------------------------------------
  29.  *  
  30.  * Class Name: Muslim Prayer Times
  31.  *  
  32.  * Filename:   Salat.php
  33.  *  
  34.  * Original    Author(s): Khaled Al-Sham'aa <khaled@ar-php.org>
  35.  *  
  36.  * Purpose:    The five Islamic prayers are named Fajr, Zuhr, Asr, Maghrib
  37.  *             and Isha. The timing of these five prayers varies from place
  38.  *             to place and from day to day. It is obligatory for Muslims
  39.  *             to perform these prayers at the correct time.
  40.  *              
  41.  * ----------------------------------------------------------------------
  42.  *  
  43.  * Source: http://qasweb.org/qasforum/index.php?showtopic=177&st=0
  44.  * By: Mohamad Magdy <mohamad_magdy_egy@hotmail.com>
  45.  *  
  46.  * ----------------------------------------------------------------------
  47.  *  
  48.  * Muslim Prayer Times
  49.  *
  50.  * Using this PHP Class you can calculate the time of Muslim prayer
  51.  * according to the geographic location.
  52.  * 
  53.  * The five Islamic prayers are named Fajr, Zuhr, Asr, Maghrib and Isha. The timing
  54.  * of these five prayers varies from place to place and from day to day. It is
  55.  * obligatory for Muslims to perform these prayers at the correct time.
  56.  * 
  57.  * The prayer times for any given location on earth may be determined mathematically
  58.  * if the latitude and longitude of the location are known. However, the theoretical
  59.  * determination of prayer times is a lengthy process. Much of this tedium may be
  60.  * alleviated by using computer programs.
  61.  * 
  62.  * Definition of prayer times
  63.  * 
  64.  * - FAJR starts with the dawn or morning twilight. Fajr ends just before sunrise.
  65.  * - ZUHR begins after midday when the trailing limb of the sun has passed the
  66.  *   meridian. For convenience, many published prayer timetables add five minutes to
  67.  *   mid-day (zawal) to obtain the start of Zuhr. Zuhr ends at the start of Asr time.
  68.  * - The timing of ASR depends on the length of the shadow cast by an object.
  69.  *   According to the Shafi school of jurisprudence, Asr begins when the length of
  70.  *   the shadow of an object exceeds the length of the object. According to the
  71.  *   Hanafi school of jurisprudence, Asr begins when the length of the shadow
  72.  *   exceeds TWICE the length of the object. In both cases, the minimum length of
  73.  *   shadow (which occurs when the sun passes the meridian) is subtracted from the
  74.  *   length of the shadow before comparing it with the length of the object.
  75.  * - MAGHRIB begins at sunset and ends at the start of isha.
  76.  * - ISHA starts after dusk when the evening twilight disappears.
  77.  *
  78.  * Example:
  79.  * <code>
  80.  *     date_default_timezone_set('UTC');
  81.  *     
  82.  *     include('./I18N/Arabic.php');
  83.  *     $obj = new I18N_Arabic('Salat');
  84.  * 
  85.  *     $obj->setLocation(33.513,36.292,2);
  86.  *     $obj->setDate(date('j'), date('n'), date('Y'));
  87.  * 
  88.  *     $times = $obj->getPrayTime();
  89.  * 
  90.  *     echo '<b>Damascus, Syria</b><br />';
  91.  *     echo date('l F j, Y').'<br /><br />';
  92.  *        
  93.  *     echo "<b class=hilight>Imsak:</b> {$times[8]}<br />";
  94.  *     echo "<b class=hilight>Fajr:</b> {$times[0]}<br />";
  95.  *     echo "<b class=hilight>Sunrise:</b> {$times[1]}<br />";
  96.  *     echo "<b class=hilight>Zuhr:</b> {$times[2]}<br />";
  97.  *     echo "<b class=hilight>Asr:</b> {$times[3]}<br />";
  98.  *     echo "<b class=hilight>Sunset:</b> {$times[6]}<br />";
  99.  *     echo "<b class=hilight>Maghrib:</b> {$times[4]}<br />";
  100.  *     echo "<b class=hilight>Isha:</b> {$times[5]}<br />";
  101.  *     echo "<b class=hilight>Midnight:</b> {$times[7]}<br />";
  102.  * </code>
  103.  * 
  104.  * Qibla Determination Methods - Basic Spherical Trigonometric Formula
  105.  * 
  106.  * The problem of qibla determination has a simple formulation in spherical
  107.  * trigonometry. A is a given location, K is the Ka'ba, and N is the North Pole.
  108.  * The great circle arcs AN and KN are along the meridians through A and K,
  109.  * respectively, and both point to the north. The qibla is along the great circle
  110.  * arc AK. The spherical angle q = NAK is the angle at A from the north direction
  111.  * AN to the direction AK towards the Ka'ba, and so q is the qibla bearing to be
  112.  * computed. Let F and L be the latitude and longitude of A, and FK and LK be
  113.  * the latitude and longitude of K (the Ka'ba). If all angles and arc lengths
  114.  * are measured in degrees, then it is seen that the arcs AN and KN are of measure
  115.  * 90 - F and 90 - FK, respectively. Also, the angle ANK between the meridians
  116.  * of K and A equals the difference between the longitudes of A and K, that is,
  117.  * LK - L, no matter what the prime meridian is. Here we are given two sides and
  118.  * the included angle of a spherical triangle, and it is required to determine one
  119.  * other angle. One of the simplest solutions is given by the formula:
  120.  * <pre>
  121.  *                       -1              sin(LK - L)
  122.  *                q = tan   ------------------------------------------
  123.  *                              cos F tan FK - sin F cos(LK - L)
  124.  * </pre>
  125.  * In this Equation, the sign of the input quantities are assumed as follows:
  126.  * latitudes are positive if north, negative if south; longitudes are positive
  127.  * if east, negative if west. The quadrant of q is assumed to be so selected
  128.  * that sin q and cos q have the same sign as the numerator and denominator of
  129.  * this Equation. With these conventions, q will be positive for bearings east
  130.  * of north, negative for bearings west of north.
  131.  * 
  132.  * Reference:
  133.  * The Correct Qibla, S. Kamal Abdali <k.abdali@acm.org>
  134.  * PDF version in http://www.patriot.net/users/abdali/ftp/qibla.pdf
  135.  *
  136.  * Example:
  137.  * <code>
  138.  *     date_default_timezone_set('UTC');
  139.  *     
  140.  *     include('./I18N/Arabic.php');
  141.  *     $obj = new I18N_Arabic('Salat');
  142.  * 
  143.  *     $obj->setLocation(33.513,36.292,2);
  144.  *
  145.  *     $direction = $obj->getQibla();
  146.  *     echo "<b>Qibla Direction (from the north direction):</b> $direction<br />";
  147.  * </code>
  148.  *  
  149.  * @category  I18N
  150.  * @package   I18N_Arabic
  151.  * @author    Khaled Al-Sham'aa <khaled@ar-php.org>
  152.  * @copyright 2006-2016 Khaled Al-Sham'aa
  153.  *    
  154.  * @license   LGPL <http://www.gnu.org/licenses/lgpl.txt>
  155.  * @link      http://www.ar-php.org
  156.  */
  157.  
  158. /**
  159.  * This PHP class calculate the time of Muslim prayer according to the geographic
  160.  * location.
  161.  *  
  162.  * @category  I18N
  163.  * @package   I18N_Arabic
  164.  * @author    Khaled Al-Sham'aa <khaled@ar-php.org>
  165.  * @copyright 2006-2016 Khaled Al-Sham'aa
  166.  *    
  167.  * @license   LGPL <http://www.gnu.org/licenses/lgpl.txt>
  168.  * @link      http://www.ar-php.org
  169.  */ 
  170. {
  171.     /**
  172.      * السنة
  173.      * @ignore
  174.      */
  175.     protected $year 1975;
  176.     
  177.     /**
  178.      * الشهر
  179.      * @ignore
  180.      */
  181.     protected $month 8;
  182.     
  183.     /**
  184.      * اليوم
  185.      * @ignore
  186.      */
  187.     protected $day 2;
  188.     
  189.     /**
  190.      * فرق التوقيت العالمى
  191.      * @ignore
  192.      */
  193.     protected $zone 2;
  194.     
  195.     /**
  196.      * خط الطول الجغرافى للمكان
  197.      * @ignore
  198.      */
  199.     protected $long 37.15861;
  200.     
  201.     /**
  202.      * خط العرض الجغرافى
  203.      * @ignore
  204.      */
  205.     protected $lat 36.20278;
  206.     
  207.     /**
  208.      * الارتفاع عن سطح البحر
  209.      * @ignore
  210.      */
  211.     protected $elevation 0;
  212.     
  213.     /**
  214.      * زاوية الشروق والغروب
  215.      * @ignore
  216.      */
  217.     protected $AB2 = -0.833333;
  218.  
  219.     /**
  220.      * زاوية العشاء
  221.      * @ignore
  222.      */
  223.     protected $AG2 = -18;
  224.     
  225.     /**
  226.      * زاوية الفجر
  227.      * @ignore
  228.      */
  229.     protected $AJ2 = -18;
  230.     
  231.     /**
  232.      * المذهب
  233.      * @ignore
  234.      */
  235.     protected $school 'Shafi';
  236.     
  237.     /**
  238.      * الطائفة
  239.      * @ignore
  240.      */
  241.     protected $view 'Sunni';
  242.  
  243.     /**
  244.      * Loads initialize values
  245.      *
  246.      * @ignore
  247.      */         
  248.     public function __construct()
  249.     {
  250.     }
  251.         
  252.     /**
  253.      * Setting date of day for Salat calculation
  254.      *      
  255.      * @param integer $m Month of date you want to calculate Salat in
  256.      * @param integer $d Day of date you want to calculate Salat in
  257.      * @param integer $y Year (four digits) of date you want to calculate Salat in
  258.      *      
  259.      * @return object $this to build a fluent interface
  260.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  261.      */
  262.     public function setDate($m 8$d 2$y 1975)
  263.     {
  264.         if (is_numeric($y&& $y && $y 3000{
  265.             $this->year floor($y);
  266.         }
  267.         
  268.         if (is_numeric($m&& $m >= && $m <= 12{
  269.             $this->month floor($m);
  270.         }
  271.         
  272.         if (is_numeric($d&& $d >= && $d <= 31{
  273.             $this->day floor($d);
  274.         }
  275.         
  276.         return $this;
  277.     }
  278.     
  279.     /**
  280.      * Setting location information for Salat calculation
  281.      *      
  282.      * @param decimal $l1 Latitude of location you want to calculate Salat time in
  283.      * @param decimal $l2 Longitude of location you want to calculate Salat time in
  284.      * @param integer $z  Time Zone, offset from UTC (see also Greenwich Mean Time)
  285.      * @param integer $e  Elevation, it is the observer's height in meters.
  286.      *      
  287.      * @return object $this to build a fluent interface
  288.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  289.      */
  290.     public function setLocation($l1 36.20278$l2 37.15861$z 2$e 0)
  291.     {
  292.         if (is_numeric($l1&& $l1 >= -180 && $l1 <= 180{
  293.             $this->lat $l1;
  294.         }
  295.         
  296.         if (is_numeric($l2&& $l2 >= -180 && $l2 <= 180{
  297.             $this->long $l2;
  298.         }
  299.         
  300.         if (is_numeric($z&& $z >= -12 && $z <= 12{
  301.             $this->zone floor($z);
  302.         }
  303.         
  304.         if (is_numeric($e)) {
  305.             $this->elevation $e;
  306.         }
  307.         
  308.         return $this;
  309.     }
  310.     
  311.     /**
  312.      * Setting rest of Salat calculation configuration
  313.      * 
  314.      * Convention                                 Fajr Angle  Isha Angle
  315.      * 
  316.      * Muslim World League                              -18       -17
  317.      *      
  318.      * Islamic Society of North America (ISNA)          -15       -15
  319.      *      
  320.      * Egyptian General Authority of Survey               -19.5     -17.5
  321.      *      
  322.      * Umm al-Qura University, Makkah                   -18.5
  323.      * Isha 90  min after Maghrib, 120 min during Ramadan
  324.      *      
  325.      * University of Islamic Sciences, Karachi          -18       -18
  326.      *      
  327.      * Institute of Geophysics, University of Tehran      -17.7     -14(*)
  328.      *      
  329.      * Shia Ithna Ashari, Leva Research Institute, Qum  -16       -14
  330.      * 
  331.      * (*) Isha angle is not explicitly defined in Tehran method
  332.      * Fajr Angle = $fajrArc, Isha Angle = $ishaArc
  333.      *                 
  334.      * - حزب العلماء في لندن لدول
  335.      * أوروبا في خطوط عرض تزيد على 48
  336.      *       
  337.      *      $ishaArc = -17
  338.      *      $fajrArc = -17
  339.      *      
  340.      * @param string  $sch        [Shafi|Hanafi] to define Muslims Salat
  341.      *                             calculation method (affect Asr time)
  342.      * @param decimal $sunriseArc Sun rise arc (default value is -0.833333)
  343.      * @param decimal $ishaArc    Isha arc (default value is -18)
  344.      * @param decimal $fajrArc    Fajr arc (default value is -18)
  345.      * @param string  $view       [Sunni|Shia] to define Muslims Salat calculation
  346.      *                             method (affect Maghrib and Midnight time)
  347.      *      
  348.      * @return object $this to build a fluent interface
  349.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  350.      */
  351.     public function setConf(
  352.         $sch 'Shafi'$sunriseArc = -0.833333$ishaArc = -17.5
  353.         $fajrArc = -19.5$view 'Sunni'
  354.     {
  355.         $sch ucfirst($sch);
  356.         
  357.         if ($sch == 'Shafi' || $sch == 'Hanafi'{
  358.             $this->school $sch;
  359.         }
  360.         
  361.         if (is_numeric($sunriseArc&& $sunriseArc >= -180 && $sunriseArc <= 180{
  362.             $this->AB2 $sunriseArc;
  363.         }
  364.         
  365.         if (is_numeric($ishaArc&& $ishaArc >= -180 && $ishaArc <= 180{
  366.             $this->AG2 $ishaArc;
  367.         }
  368.         
  369.         if (is_numeric($fajrArc&& $fajrArc >= -180 && $fajrArc <= 180{
  370.             $this->AJ2 $fajrArc;
  371.         }
  372.         
  373.         if ($view == 'Sunni' || $view == 'Shia'{
  374.             $this->view $view;
  375.         }
  376.         
  377.         return $this;
  378.     }
  379.     
  380.     /**
  381.      * Alias for getPrayTime2 method
  382.      *                        
  383.      * @return array of Salat times + sun rise in the following format
  384.      *                hh:mm where hh is the hour in local format and 24 mode
  385.      *                mm is minutes with leading zero to be 2 digits always
  386.      *                array items is [$Fajr, $Sunrise, $Dhuhr, $Asr, $Maghrib,
  387.      *                $Isha, $Sunset, $Midnight, $Imsak, array $timestamps]
  388.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  389.      * @author Hamid Zarrabi-Zadeh <zarrabi@scs.carleton.ca>
  390.      * @source http://praytimes.org/calculation
  391.      */
  392.     public function getPrayTime()
  393.     {
  394.         $prayTime $this->getPrayTime2();
  395.         
  396.         return $prayTime;
  397.     }
  398.     
  399.     /**
  400.      * Calculate Salat times for the date set in setSalatDate methode, and
  401.      * location set in setSalatLocation.
  402.      *                        
  403.      * @return array of Salat times + sun rise in the following format
  404.      *                hh:mm where hh is the hour in local format and 24 mode
  405.      *                mm is minutes with leading zero to be 2 digits always
  406.      *                array items is [$Fajr, $Sunrise, $Dhuhr, $Asr, $Maghrib,
  407.      *                $Isha, $Sunset, $Midnight, $Imsak, array $timestamps]
  408.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  409.      * @author Hamid Zarrabi-Zadeh <zarrabi@scs.carleton.ca>
  410.      * @source http://praytimes.org/calculation
  411.      */
  412.     public function getPrayTime2()
  413.     {
  414.         $unixtimestamp mktime(000$this->month$this->day$this->year);
  415.  
  416.         // Calculate Julian date
  417.         if ($this->month <= 2{
  418.             $year  $this->year 1;
  419.             $month $this->month 12;
  420.         else {
  421.             $year  $this->year;
  422.             $month $this->month;
  423.         }
  424.         
  425.         $A floor($year 100);
  426.         $B $A floor($A 4);
  427.  
  428.         $jd floor(365.25 ($year 4716)) floor(30.6001 ($month 1)) 
  429.                 + $this->day $B 1524.5;
  430.         
  431.         // The following algorithm from U.S. Naval Observatory computes the 
  432.         // Sun's angular coordinates to an accuracy of about 1 arcminute within 
  433.         // two centuries of 2000. 
  434.         $d $jd 2451545.0;  // jd is the given Julian date 
  435.  
  436.         // The following algorithm from U.S. Naval Observatory computes the Sun's 
  437.         // angular coordinates to an accuracy of about 1 arcminute within two 
  438.         // centuries of 2000
  439.         // http://aa.usno.navy.mil/faq/docs/SunApprox.php
  440.         // Note: mod % in PHP ignore decimels!
  441.         $g 357.529 0.98560028 $d;
  442.         $g $g 360 ($g ceil($g1);
  443.         
  444.         $q 280.459 0.98564736 $d;
  445.         $q $q 360 ($q ceil($q1);
  446.         
  447.         $L $q 1.915 sin(deg2rad($g)) 0.020 sin(deg2rad($g));
  448.         $L $L 360 ($L ceil($L1);
  449.  
  450.         $R 1.00014 0.01671 cos(deg2rad($g)) 0.00014 cos(deg2rad($g));
  451.         $e 23.439 0.00000036 $d;
  452.         
  453.         $RA rad2deg(atan2(cos(deg2rad($e))sin(deg2rad($L))cos(deg2rad($L))))
  454.             / 15;
  455.         
  456.         if ($RA 0{
  457.             $RA 24 $RA;
  458.         }
  459.  
  460.         // The declination of the Sun is the angle between the rays of the sun and 
  461.         // the plane of the earth equator. The declination of the Sun changes 
  462.         // continuously throughout the year. This is a consequence of the Earth's 
  463.         // tilt, i.e. the difference in its rotational and revolutionary axes. 
  464.         // declination of the Sun
  465.         $D rad2deg(asin(sin(deg2rad($e))sin(deg2rad($L))));  
  466.         
  467.         // The equation of time is the difference between time as read from sundial 
  468.         // and a clock. It results from an apparent irregular movement of the Sun 
  469.         // caused by a combination of the obliquity of the Earth's rotation axis 
  470.         // and the eccentricity of its orbit. The sundial can be ahead (fast) by 
  471.         // as much as 16 min 33 s (around November 3) or fall behind by as much as 
  472.         // 14 min 6 s (around February 12), as shown in the following graph:
  473.         // http://en.wikipedia.org/wiki/File:Equation_of_time.png 
  474.         $EqT ($q/15$RA;  // equation of time
  475.         
  476.         // Dhuhr
  477.         // When the Sun begins to decline after reaching its highest point in the sky
  478.         $Dhuhr 12 $this->zone ($this->long/15$EqT;
  479.         if ($Dhuhr 0{
  480.             $Dhuhr 24 $Dhuhr;
  481.         }
  482.         
  483.         // Sunrise & Sunset 
  484.         // If the observer's location is higher than the surrounding terrain, we 
  485.         // can consider this elevation into consideration by increasing the above 
  486.         // constant 0.833 by 0.0347 × sqrt(elevation), where elevation is the  
  487.         // observer's height in meters. 
  488.         $alpha 0.833 0.0347 sqrt($this->elevation);
  489.         $n = -sin(deg2rad($alpha)) sin(deg2rad($this->lat)) sin(deg2rad($D));
  490.         $d cos(deg2rad($this->lat)) cos(deg2rad($D));
  491.  
  492.         // date_sun_info Returns an array with information about sunset/sunrise 
  493.         // and twilight begin/end
  494.         $Sunrise $Dhuhr (1/15rad2deg(acos($n $d));
  495.         $Sunset  $Dhuhr (1/15rad2deg(acos($n $d));
  496.         
  497.         // Fajr & Isha
  498.         // Imsak: The time to stop eating Sahur (for fasting), slightly before Fajr.
  499.         // Fajr:  When the sky begins to lighten (dawn).
  500.         // Isha:  The time at which darkness falls and there is no scattered light 
  501.         //        in the sky. 
  502.         $n     = -sin(deg2rad(abs($this->AJ2))) sin(deg2rad($this->lat)) 
  503.                 * sin(deg2rad($D));
  504.         $Fajr  $Dhuhr (1/15rad2deg(acos($n $d));
  505.         $Imsak $Fajr (10/60);
  506.         
  507.         $n    = -sin(deg2rad(abs($this->AG2))) sin(deg2rad($this->lat)) 
  508.                 * sin(deg2rad($D));
  509.         $Isha $Dhuhr (1/15rad2deg(acos($n $d));
  510.         
  511.         // Asr
  512.         // The following formula computes the time difference between the mid-day 
  513.         // and the time at which the object's shadow equals t times the length of 
  514.         // the object itself plus the length of that object's shadow at noon
  515.         if ($this->school == 'Shafi'{
  516.             $n sin(atan(1/(tan(deg2rad($this->lat $D))))) 
  517.                 - sin(deg2rad($this->lat)) sin(deg2rad($D));
  518.         else {
  519.             $n sin(atan(1/(tan(deg2rad($this->lat $D))))) 
  520.                 - sin(deg2rad($this->lat)) sin(deg2rad($D));
  521.         }
  522.         $Asr $Dhuhr (1/15rad2deg(acos($n $d));
  523.         
  524.         // Maghrib
  525.         // In the Sunni's point of view, the time for Maghrib prayer begins once 
  526.         // the Sun has completely set beneath the horizon, that is, Maghrib = Sunset 
  527.         // (some calculators suggest 1 to 3 minutes after Sunset for precaution)
  528.         $MaghribSunni $Sunset 2/60;
  529.         
  530.         // In the Shia's view, however, the dominant opinion is that as long as 
  531.         // the redness in the eastern sky appearing after sunset has not passed 
  532.         // overhead, Maghrib prayer should not be performed.
  533.         $n = -sin(deg2rad(4)) sin(deg2rad($this->lat)) sin(deg2rad($D));
  534.         $MaghribShia $Dhuhr (1/15rad2deg(acos($n $d));
  535.         
  536.         if ($this->view == 'Sunni'{
  537.             $Maghrib $MaghribSunni;
  538.         else {
  539.             $Maghrib $MaghribShia;
  540.         }
  541.  
  542.         // Midnight
  543.         // Midnight is generally calculated as the mean time from Sunset to Sunrise
  544.         $MidnightSunni $Sunset 0.5 ($Sunrise $Sunset);
  545.         if ($MidnightSunni 12{
  546.             $MidnightSunni $MidnightSunni 12;
  547.         }
  548.         
  549.         // In Shia point of view, the juridical midnight (the ending time for 
  550.         // performing Isha prayer) is the mean time from Sunset to Fajr
  551.         $MidnightShia 0.5 ($Fajr $Sunset);
  552.         if ($MidnightShia 12{
  553.             $MidnightShia $MidnightShia 12;
  554.         }
  555.         
  556.         if ($this->view == 'Sunni'{
  557.             $Midnight $MidnightSunni;
  558.         else {
  559.             $Midnight $MidnightShia;
  560.         }
  561.  
  562.         // Result.ThlthAkhir:= Result.Fajr-(24-Result.Maghrib + Result.Fajr)/3;
  563.         // Result.Doha      := Result.Sunrise+(15/60);
  564.         // if isRamadan then (Um-Al-Qura calendar)
  565.         // Result.Isha := Result.Maghrib+2 
  566.         // else Result.Isha := Result.Maghrib+1.5;
  567.         
  568.         $times array($Fajr$Sunrise$Dhuhr$Asr$Maghrib$Isha$Sunset
  569.                 $Midnight$Imsak);
  570.         
  571.         // Convert number after the decimal point into minutes 
  572.         foreach ($times as $index => $time{
  573.             $hours   floor($time);
  574.             $minutes round(($time $hours60);
  575.             
  576.             if ($minutes 10{
  577.                 $minutes "0$minutes";
  578.             }
  579.             
  580.             $times[$index"$hours:$minutes";
  581.             
  582.             $times[9][$index$unixtimestamp 3600 $hours 60 $minutes;
  583.             
  584.             if ($index == && $hours 6{
  585.                 $times[9][$index+= 24 3600;
  586.             }
  587.         }
  588.         
  589.         return $times;
  590.     }
  591.  
  592.     /**
  593.      * Determine Qibla direction using basic spherical trigonometric formula
  594.      *                        
  595.      * @return float Qibla Direction (from the north direction) in degrees
  596.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  597.      * @author S. Kamal Abdali <k.abdali@acm.org>
  598.      * @source http://www.patriot.net/users/abdali/ftp/qibla.pdf
  599.      */
  600.     public function getQibla (
  601.     {
  602.         // The geographical coordinates of the Ka'ba
  603.         $K_latitude  21.423333;
  604.         $K_longitude 39.823333;
  605.         
  606.         $latitude  $this->lat;
  607.         $longitude $this->long;
  608.  
  609.         $numerator   sin(deg2rad($K_longitude $longitude));
  610.         $denominator (cos(deg2rad($latitude)) tan(deg2rad($K_latitude))) -
  611.                        (sin(deg2rad($latitude)) 
  612.                        * cos(deg2rad($K_longitude $longitude)));
  613.  
  614.         $q atan($numerator $denominator);
  615.         $q rad2deg($q);
  616.         
  617.         if ($this->lat 21.423333{
  618.             $q += 180;
  619.         }
  620.         
  621.         return $q;
  622.     }
  623.     
  624.     /**
  625.      * Convert coordinates presented in degrees, minutes and seconds
  626.      * (i.e. 12°34'56"S formula) into usual float number in degree unit scale
  627.      * (i.e. -12.5822 value)
  628.      *      
  629.      * @param string $value Coordinate presented in degrees, minutes and seconds
  630.      *                       (i.e. 12°34'56"S formula)
  631.      *      
  632.      * @return float Equivalent float number in degree unit scale
  633.      *                (i.e. -12.5822 value)
  634.      * @author Khaled Al-Sham'aa <khaled@ar-php.org>
  635.      */
  636.     public function coordinate2deg ($value
  637.     {
  638.         $pattern "/(\d{1,2})°((\d{1,2})')?((\d{1,2})\")?([NSEW])/i";
  639.         
  640.         preg_match($pattern$value$matches);
  641.         
  642.         $degree $matches[1($matches[360($matches[5/3600);
  643.         
  644.         $direction strtoupper($matches[6]);
  645.         
  646.         if ($direction == 'S' || $direction == 'W'{
  647.             $degree = -$degree;
  648.         }
  649.         
  650.         return $degree;
  651.     }
  652. }

Documentation generated on Fri, 01 Jan 2016 10:26:22 +0200 by phpDocumentor 1.4.0