| version 1.1, 2005/06/05 12:14:12 |
version 1.2, 2005/11/07 20:37:29 |
|
|
| <?php |
<?php |
| |
|
| // The constant telling us what day starts the week. Monday (1) is the |
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */ |
| // international standard. Redefine this to 0 if you want weeks to |
|
| // begin on Sunday. |
|
| if (!defined('DATE_CALC_BEGIN_WEEKDAY')) { |
|
| define('DATE_CALC_BEGIN_WEEKDAY', 1); |
|
| } |
|
| |
|
| /** |
/** |
| * Date_Calc is a calendar class used to calculate and |
* Calculates, manipulates and retrieves dates |
| * manipulate calendar dates and retrieve dates in a calendar |
|
| * format. It does not rely on 32-bit system date stamps, so |
|
| * you can display calendars and compare dates that date |
|
| * pre 1970 and post 2038. |
|
| * |
* |
| * This source file is subject to version 2.02 of the PHP license, |
* It does not rely on 32-bit system time stamps, so it works dates |
| * that is bundled with this package in the file LICENSE, and is |
* before 1970 and after 2038. |
| * available at through the world-wide-web at |
|
| * http://www.php.net/license/2_02.txt. |
|
| * If you did not receive a copy of the PHP license and are unable to |
|
| * obtain it through the world-wide-web, please send a note to |
|
| * license@php.net so we can mail you a copy immediately. |
|
| * |
* |
| * Copyright (c) 1999, 2002, 2003 ispi |
* PHP versions 4 and 5 |
| * |
* |
| * @access public |
* LICENSE: This source file is subject to version 2.02 of the PHP license |
| |
* that is available through the world-wide-web at the following URI: |
| |
* http://www.php.net/license/2_02.txt. If you did not receive a copy of |
| |
* the PHP License and are unable to obtain it through the web, please |
| |
* send a note to license@php.net so we can mail you a copy immediately. |
| * |
* |
| * @version 1.2.6 |
* @category Date and Time |
| * @author Monte Ohrt <monte@ispi.net> |
* @package Date |
| |
* @author Monte Ohrt <monte@ispi.net> |
| |
* @author Daniel Convissor <danielc@php.net> |
| |
* @copyright 1999, 2002, 2003 ispi |
| |
* @license http://www.php.net/license/2_02.txt PHP License |
| |
* @version CVS: $Id$ |
| |
* @link http://pear.php.net/package/Date |
| |
* @since File available since Release 1.2 |
| */ |
*/ |
| |
|
| class Date_Calc |
if (!defined('DATE_CALC_BEGIN_WEEKDAY')) { |
| { |
|
| /** |
/** |
| * Returns the current local date. NOTE: This function |
* Defines what day starts the week |
| * retrieves the local date using strftime(), which may |
|
| * or may not be 32-bit safe on your system. |
|
| * |
* |
| * @param string the strftime() format to return the date |
* Monday (1) is the international standard. |
| |
* Redefine this to 0 if you want weeks to begin on Sunday. |
| |
*/ |
| |
define('DATE_CALC_BEGIN_WEEKDAY', 1); |
| |
} |
| |
|
| |
if (!defined('DATE_CALC_FORMAT')) { |
| |
/** |
| |
* The default value for each method's $format parameter |
| * |
* |
| * @access public |
* The default is '%Y%m%d'. To override this default, define |
| |
* this constant before including Calc.php. |
| * |
* |
| * @return string the current date in specified format |
* @since Constant available since Release 1.5.0 |
| */ |
*/ |
| |
define('DATE_CALC_FORMAT', '%Y%m%d'); |
| |
} |
| |
|
| function dateNow($format='%Y%m%d') |
/** |
| { |
* Calculates, manipulates and retrieves dates |
| return(strftime($format,time())); |
* |
| |
* It does not rely on 32-bit system time stamps, so it works dates |
| } // end func dateNow |
* before 1970 and after 2038. |
| |
* |
| /** |
* @author Monte Ohrt <monte@ispi.net> |
| * Returns true for valid date, false for invalid date. |
* @author Daniel Convissor <danielc@php.net> |
| |
* @copyright 1999, 2002, 2003 ispi |
| |
* @license http://www.php.net/license/2_02.txt PHP License |
| |
* @version Release: 1.4.5 |
| |
* @link http://pear.php.net/package/Date |
| |
* @since Class available since Release 1.2 |
| |
*/ |
| |
class Date_Calc |
| |
{ |
| |
/** |
| |
* Formats the date in the given format, much like strfmt() |
| * |
* |
| * @param string year in format CCYY |
* This function is used to alleviate the problem with 32-bit numbers for |
| * @param string month in format MM |
* dates pre 1970 or post 2038, as strfmt() has on most systems. |
| * @param string day in format DD |
* Most of the formatting options are compatible. |
| |
* |
| |
* Formatting options: |
| |
* <pre> |
| |
* %a abbreviated weekday name (Sun, Mon, Tue) |
| |
* %A full weekday name (Sunday, Monday, Tuesday) |
| |
* %b abbreviated month name (Jan, Feb, Mar) |
| |
* %B full month name (January, February, March) |
| |
* %d day of month (range 00 to 31) |
| |
* %e day of month, single digit (range 0 to 31) |
| |
* %E number of days since unspecified epoch (integer) |
| |
* (%E is useful for passing a date in a URL as |
| |
* an integer value. Then simply use |
| |
* daysToDate() to convert back to a date.) |
| |
* %j day of year (range 001 to 366) |
| |
* %m month as decimal number (range 1 to 12) |
| |
* %n newline character (\n) |
| |
* %t tab character (\t) |
| |
* %w weekday as decimal (0 = Sunday) |
| |
* %U week number of current year, first sunday as first week |
| |
* %y year as decimal (range 00 to 99) |
| |
* %Y year as decimal including century (range 0000 to 9999) |
| |
* %% literal '%' |
| |
* </pre> |
| |
* |
| |
* @param int $day the day of the month |
| |
* @param int $month the month |
| |
* @param int $year the year. Use the complete year instead of the |
| |
* abbreviated version. E.g. use 2005, not 05. |
| |
* Do not add leading 0's for years prior to 1000. |
| |
* @param string $format the format string |
| |
* |
| |
* @return string the date in the desired format |
| * |
* |
| * @access public |
* @access public |
| * |
* @static |
| * @return boolean true/false |
|
| */ |
*/ |
| |
function dateFormat($day, $month, $year, $format) |
| function isValidDate($day, $month, $year) |
|
| { |
{ |
| if ($year < 0 || $year > 9999) { |
if (!Date_Calc::isValidDate($day, $month, $year)) { |
| return false; |
$year = Date_Calc::dateNow('%Y'); |
| } |
$month = Date_Calc::dateNow('%m'); |
| if (!checkdate($month,$day,$year)) { |
$day = Date_Calc::dateNow('%d'); |
| return false; |
|
| } |
} |
| |
|
| return true; |
$output = ''; |
| } // end func isValidDate |
|
| |
|
| /** |
for ($strpos = 0; $strpos < strlen($format); $strpos++) { |
| * Returns true for a leap year, else false |
$char = substr($format, $strpos, 1); |
| |
if ($char == '%') { |
| |
$nextchar = substr($format, $strpos + 1, 1); |
| |
switch($nextchar) { |
| |
case 'a': |
| |
$output .= Date_Calc::getWeekdayAbbrname($day, $month, $year); |
| |
break; |
| |
case 'A': |
| |
$output .= Date_Calc::getWeekdayFullname($day, $month, $year); |
| |
break; |
| |
case 'b': |
| |
$output .= Date_Calc::getMonthAbbrname($month); |
| |
break; |
| |
case 'B': |
| |
$output .= Date_Calc::getMonthFullname($month); |
| |
break; |
| |
case 'd': |
| |
$output .= sprintf('%02d', $day); |
| |
break; |
| |
case 'e': |
| |
$output .= $day; |
| |
break; |
| |
case 'E': |
| |
$output .= Date_Calc::dateToDays($day, $month, $year); |
| |
break; |
| |
case 'j': |
| |
$output .= Date_Calc::julianDate($day, $month, $year); |
| |
break; |
| |
case 'm': |
| |
$output .= sprintf('%02d', $month); |
| |
break; |
| |
case 'n': |
| |
$output .= "\n"; |
| |
break; |
| |
case 't': |
| |
$output .= "\t"; |
| |
break; |
| |
case 'w': |
| |
$output .= Date_Calc::dayOfWeek($day, $month, $year); |
| |
break; |
| |
case 'U': |
| |
$output .= Date_Calc::weekOfYear($day, $month, $year); |
| |
break; |
| |
case 'y': |
| |
$output .= substr($year, 2, 2); |
| |
break; |
| |
case 'Y': |
| |
$output .= $year; |
| |
break; |
| |
case '%': |
| |
$output .= '%'; |
| |
break; |
| |
default: |
| |
$output .= $char.$nextchar; |
| |
} |
| |
$strpos++; |
| |
} else { |
| |
$output .= $char; |
| |
} |
| |
} |
| |
return $output; |
| |
} |
| |
|
| |
/** |
| |
* Turns a two digit year into a four digit year |
| * |
* |
| * @param string year in format CCYY |
* From '51 to '99 is in the 1900's, otherwise it's in the 2000's. |
| * |
* |
| * @access public |
* @param int $year the 2 digit year |
| * |
* |
| * @return boolean true/false |
* @return string the 4 digit year |
| |
* |
| |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function defaultCentury($year) |
| function isLeapYear($year='') |
|
| { |
{ |
| if (empty($year)) { |
if (strlen($year) == 1) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = '0' . $year; |
| } |
|
| |
|
| if (preg_match('/\D/',$year)) { |
|
| return false; |
|
| } |
|
| |
|
| if ($year < 1000) { |
|
| return false; |
|
| } |
} |
| |
if ($year > 50) { |
| if ($year < 1582) { |
return '19' . $year; |
| // pre Gregorio XIII - 1582 |
|
| return ($year % 4 == 0); |
|
| } else { |
} else { |
| // post Gregorio XIII - 1582 |
return '20' . $year; |
| return ( (($year % 4 == 0) and ($year % 100 != 0)) or ($year % 400 == 0) ); |
|
| } |
} |
| } // end func isLeapYear |
} |
| |
|
| /** |
/** |
| * Determines if given date is a future date from now. |
* Converts a date to number of days since a distant unspecified epoch |
| * |
* |
| * @param string day in format DD |
* @param int $day the day of the month |
| * @param string month in format MM |
* @param int $month the month |
| * @param string year in format CCYY |
* @param int $year the year. Use the complete year instead of the |
| |
* abbreviated version. E.g. use 2005, not 05. |
| |
* Do not add leading 0's for years prior to 1000. |
| * |
* |
| * @access public |
* @return integer the number of days since the Date_Calc epoch |
| * |
* |
| * @return boolean true/false |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function dateToDays($day, $month, $year) |
| function isFutureDate($day,$month,$year) |
|
| { |
{ |
| $this_year = Date_Calc::dateNow('%Y'); |
$century = (int)substr($year, 0, 2); |
| $this_month = Date_Calc::dateNow('%m'); |
$year = (int)substr($year, 2, 2); |
| $this_day = Date_Calc::dateNow('%d'); |
if ($month > 2) { |
| |
$month -= 3; |
| if ($year > $this_year) { |
} else { |
| return true; |
$month += 9; |
| } elseif ($year == $this_year) { |
if ($year) { |
| if ($month > $this_month) { |
$year--; |
| return true; |
} else { |
| } elseif ($month == $this_month) { |
$year = 99; |
| if ($day > $this_day) { |
$century --; |
| return true; |
|
| } |
|
| } |
} |
| } |
} |
| |
|
| return false; |
return (floor((146097 * $century) / 4 ) + |
| } // end func isFutureDate |
floor((1461 * $year) / 4 ) + |
| |
floor((153 * $month + 2) / 5 ) + |
| |
$day + 1721119); |
| |
} |
| |
|
| /** |
/** |
| * Determines if given date is a past date from now. |
* Converts number of days to a distant unspecified epoch |
| * |
* |
| * @param string day in format DD |
* @param int $days the number of days since the Date_Calc epoch |
| * @param string month in format MM |
* @param string $format the string indicating how to format the output |
| * @param string year in format CCYY |
|
| * |
* |
| * @access public |
* @return string the date in the desired format |
| * |
* |
| * @return boolean true/false |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function daysToDate($days, $format = DATE_CALC_FORMAT) |
| function isPastDate($day,$month,$year) |
|
| { |
{ |
| $this_year = Date_Calc::dateNow('%Y'); |
$days -= 1721119; |
| $this_month = Date_Calc::dateNow('%m'); |
$century = floor((4 * $days - 1) / 146097); |
| $this_day = Date_Calc::dateNow('%d'); |
$days = floor(4 * $days - 1 - 146097 * $century); |
| |
$day = floor($days / 4); |
| |
|
| if ($year < $this_year) { |
$year = floor((4 * $day + 3) / 1461); |
| return true; |
$day = floor(4 * $day + 3 - 1461 * $year); |
| } elseif ($year == $this_year) { |
$day = floor(($day + 4) / 4); |
| if ($month < $this_month) { |
|
| return true; |
$month = floor((5 * $day - 3) / 153); |
| } elseif ($month == $this_month) { |
$day = floor(5 * $day - 3 - 153 * $month); |
| if ($day < $this_day) { |
$day = floor(($day + 5) / 5); |
| return true; |
|
| } |
if ($month < 10) { |
| |
$month +=3; |
| |
} else { |
| |
$month -=9; |
| |
if ($year++ == 99) { |
| |
$year = 0; |
| |
$century++; |
| } |
} |
| } |
} |
| |
|
| return false; |
$century = sprintf('%02d', $century); |
| } // end func isPastDate |
$year = sprintf('%02d', $year); |
| |
return Date_Calc::dateFormat($day, $month, $century . $year, $format); |
| |
} |
| |
|
| /** |
/** |
| * Returns day of week for given date, 0=Sunday |
* Converts from Gregorian Year-Month-Day to ISO Year-WeekNumber-WeekDay |
| * |
* |
| * @param string day in format DD, default is current local day |
* Uses ISO 8601 definitions. Algorithm by Rick McCarty, 1999 at |
| * @param string month in format MM, default is current local month |
* http://personal.ecu.edu/mccartyr/ISOwdALG.txt . |
| * @param string year in format CCYY, default is current local year |
* Transcribed to PHP by Jesus M. Castagnetto. |
| * |
* |
| * @access public |
* @param int $day the day of the month |
| |
* @param int $month the month |
| |
* @param int $year the year. Use the complete year instead of the |
| |
* abbreviated version. E.g. use 2005, not 05. |
| |
* Do not add leading 0's for years prior to 1000. |
| |
* |
| |
* @return string the date in ISO Year-WeekNumber-WeekDay format |
| * |
* |
| * @return int $weekday_number |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function gregorianToISO($day, $month, $year) { |
| function dayOfWeek($day='',$month='',$year='') |
$mnth = array (0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334); |
| { |
$y_isleap = Date_Calc::isLeapYear($year); |
| if (empty($year)) { |
$y_1_isleap = Date_Calc::isLeapYear($year - 1); |
| $year = Date_Calc::dateNow('%Y'); |
$day_of_year_number = $day + $mnth[$month - 1]; |
| |
if ($y_isleap && $month > 2) { |
| |
$day_of_year_number++; |
| } |
} |
| if (empty($month)) { |
// find Jan 1 weekday (monday = 1, sunday = 7) |
| $month = Date_Calc::dateNow('%m'); |
$yy = ($year - 1) % 100; |
| |
$c = ($year - 1) - $yy; |
| |
$g = $yy + intval($yy / 4); |
| |
$jan1_weekday = 1 + intval((((($c / 100) % 4) * 5) + $g) % 7); |
| |
// weekday for year-month-day |
| |
$h = $day_of_year_number + ($jan1_weekday - 1); |
| |
$weekday = 1 + intval(($h - 1) % 7); |
| |
// find if Y M D falls in YearNumber Y-1, WeekNumber 52 or |
| |
if ($day_of_year_number <= (8 - $jan1_weekday) && $jan1_weekday > 4){ |
| |
$yearnumber = $year - 1; |
| |
if ($jan1_weekday == 5 || ($jan1_weekday == 6 && $y_1_isleap)) { |
| |
$weeknumber = 53; |
| |
} else { |
| |
$weeknumber = 52; |
| |
} |
| |
} else { |
| |
$yearnumber = $year; |
| } |
} |
| if (empty($day)) { |
// find if Y M D falls in YearNumber Y+1, WeekNumber 1 |
| $day = Date_Calc::dateNow('%d'); |
if ($yearnumber == $year) { |
| |
if ($y_isleap) { |
| |
$i = 366; |
| |
} else { |
| |
$i = 365; |
| |
} |
| |
if (($i - $day_of_year_number) < (4 - $weekday)) { |
| |
$yearnumber++; |
| |
$weeknumber = 1; |
| |
} |
| } |
} |
| |
// find if Y M D falls in YearNumber Y, WeekNumber 1 through 53 |
| if ($month > 2) { |
if ($yearnumber == $year) { |
| $month -= 2; |
$j = $day_of_year_number + (7 - $weekday) + ($jan1_weekday - 1); |
| } else { |
$weeknumber = intval($j / 7); |
| $month += 10; |
if ($jan1_weekday > 4) { |
| $year--; |
$weeknumber--; |
| |
} |
| } |
} |
| |
// put it all together |
| |
if ($weeknumber < 10) { |
| |
$weeknumber = '0'.$weeknumber; |
| |
} |
| |
return $yearnumber . '-' . $weeknumber . '-' . $weekday; |
| |
} |
| |
|
| $day = ( floor((13 * $month - 1) / 5) + |
/** |
| $day + ($year % 100) + |
* Determines julian date of the given season |
| floor(($year % 100) / 4) + |
* |
| floor(($year / 100) / 4) - 2 * |
* Adapted from previous work in Java by James Mark Hamilton. |
| floor($year / 100) + 77); |
* |
| |
* @param string $season the season to get the date for: VERNALEQUINOX, |
| $weekday_number = (($day - 7 * floor($day / 7))); |
* SUMMERSOLSTICE, AUTUMNALEQUINOX, |
| |
* or WINTERSOLSTICE |
| return $weekday_number; |
* @param string $year the year in four digit format. Must be between |
| } // end func dayOfWeek |
* -1000BC and 3000AD. |
| |
* |
| |
* @return float the julian date the season starts on |
| |
* |
| |
* @author James Mark Hamilton <mhamilton@qwest.net> |
| |
* @author Robert Butler <rob@maxwellcreek.org> |
| |
* @access public |
| |
* @static |
| |
*/ |
| |
function dateSeason($season, $year = 0) { |
| |
if ($year == '') { |
| |
$year = Date_Calc::dateNow('%Y'); |
| |
} |
| |
if (($year >= -1000) && ($year <= 1000)) { |
| |
$y = $year / 1000.0; |
| |
switch ($season) { |
| |
case 'VERNALEQUINOX': |
| |
$juliandate = (((((((-0.00071 * $y) - 0.00111) * $y) + 0.06134) * $y) + 365242.1374) * $y) + 1721139.29189; |
| |
break; |
| |
case 'SUMMERSOLSTICE': |
| |
$juliandate = (((((((0.00025 * $y) + 0.00907) * $y) - 0.05323) * $y) + 365241.72562) * $y) + 1721233.25401; |
| |
break; |
| |
case 'AUTUMNALEQUINOX': |
| |
$juliandate = (((((((0.00074 * $y) - 0.00297) * $y) - 0.11677) * $y) + 365242.49558) * $y) + 1721325.70455; |
| |
break; |
| |
case 'WINTERSOLSTICE': |
| |
default: |
| |
$juliandate = (((((((-0.00006 * $y) - 0.00933) * $y) - 0.00769) * $y) + 365242.88257) * $y) + 1721414.39987; |
| |
} |
| |
} elseif (($year > 1000) && ($year <= 3000)) { |
| |
$y = ($year - 2000) / 1000; |
| |
switch ($season) { |
| |
case 'VERNALEQUINOX': |
| |
$juliandate = (((((((-0.00057 * $y) - 0.00411) * $y) + 0.05169) * $y) + 365242.37404) * $y) + 2451623.80984; |
| |
break; |
| |
case 'SUMMERSOLSTICE': |
| |
$juliandate = (((((((-0.0003 * $y) + 0.00888) * $y) + 0.00325) * $y) + 365241.62603) * $y) + 2451716.56767; |
| |
break; |
| |
case 'AUTUMNALEQUINOX': |
| |
$juliandate = (((((((0.00078 * $y) + 0.00337) * $y) - 0.11575) * $y) + 365242.01767) * $y) + 2451810.21715; |
| |
break; |
| |
case 'WINTERSOLSTICE': |
| |
default: |
| |
$juliandate = (((((((0.00032 * $y) - 0.00823) * $y) - 0.06223) * $y) + 365242.74049) * $y) + 2451900.05952; |
| |
} |
| |
} |
| |
return $juliandate; |
| |
} |
| |
|
| /** |
/** |
| * Returns week of the year, first Sunday is first day of first week |
* Returns the current local date |
| * |
* |
| * @param string day in format DD, default is current local day |
* NOTE: This function retrieves the local date using strftime(), |
| * @param string month in format MM, default is current local month |
* which may or may not be 32-bit safe on your system. |
| * @param string year in format CCYY, default is current local year |
|
| * |
* |
| * @access public |
* @param string $format the string indicating how to format the output |
| * |
* |
| * @return integer $week_number |
* @return string the current date in the specified format |
| |
* |
| |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function dateNow($format = DATE_CALC_FORMAT) |
| |
{ |
| |
return strftime($format, time()); |
| |
} |
| |
|
| function weekOfYear($day='',$month='',$year='') |
/** |
| |
* Returns the current local year in format CCYY |
| |
* |
| |
* @return string the current year in four digit format |
| |
* |
| |
* @access public |
| |
* @static |
| |
*/ |
| |
function getYear() |
| { |
{ |
| if (empty($year)) { |
return Date_Calc::dateNow('%Y'); |
| $year = Date_Calc::dateNow('%Y'); |
} |
| } |
|
| if (empty($month)) { |
|
| $month = Date_Calc::dateNow('%m'); |
|
| } |
|
| if (empty($day)) { |
|
| $day = Date_Calc::dateNow('%d'); |
|
| } |
|
| $iso = Date_Calc::gregorianToISO($day, $month, $year); |
|
| $parts = explode('-',$iso); |
|
| $week_number = intval($parts[1]); |
|
| return $week_number; |
|
| } // end func weekOfYear |
|
| |
|
| /** |
/** |
| * Returns number of days since 31 December of year before given date. |
* Returns the current local month in format MM |
| * |
* |
| * @param string day in format DD, default is current local day |
* @return string the current month in two digit format |
| * @param string month in format MM, default is current local month |
|
| * @param string year in format CCYY, default is current local year |
|
| * |
* |
| * @access public |
* @access public |
| |
* @static |
| |
*/ |
| |
function getMonth() |
| |
{ |
| |
return Date_Calc::dateNow('%m'); |
| |
} |
| |
|
| |
/** |
| |
* Returns the current local day in format DD |
| * |
* |
| * @return int $julian |
* @return string the current day of the month in two digit format |
| |
* |
| |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function getDay() |
| |
{ |
| |
return Date_Calc::dateNow('%d'); |
| |
} |
| |
|
| function julianDate($day='',$month='',$year='') |
/** |
| |
* Returns number of days since 31 December of year before given date |
| |
* |
| |
* @param int $day the day of the month, default is current local day |
| |
* @param int $month the month, default is current local month |
| |
* @param int $year the year in four digit format, default is current local year |
| |
* |
| |
* @return int the julian date for the date |
| |
* |
| |
* @access public |
| |
* @static |
| |
*/ |
| |
function julianDate($day = 0, $month = 0, $year = 0) |
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
|
|
| if (empty($day)) { |
if (empty($day)) { |
| $day = Date_Calc::dateNow('%d'); |
$day = Date_Calc::dateNow('%d'); |
| } |
} |
| |
$days = array(0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334); |
| $days = array(0,31,59,90,120,151,181,212,243,273,304,334); |
|
| |
|
| $julian = ($days[$month - 1] + $day); |
$julian = ($days[$month - 1] + $day); |
| |
|
| if ($month > 2 && Date_Calc::isLeapYear($year)) { |
if ($month > 2 && Date_Calc::isLeapYear($year)) { |
| $julian++; |
$julian++; |
| } |
} |
| |
return $julian; |
| return($julian); |
} |
| } // end func julianDate |
|
| |
|
| /** |
/** |
| * Returns quarter of the year for given date |
* Returns the full weekday name for the given date |
| * |
* |
| * @param string day in format DD, default is current local day |
* @param int $day the day of the month, default is current local day |
| * @param string month in format MM, default is current local month |
* @param int $month the month, default is current local month |
| * @param string year in format CCYY, default is current local year |
* @param int $year the year in four digit format, default is current local year |
| * |
* |
| * @access public |
* @return string the full name of the day of the week |
| * |
* |
| * @return int $year_quarter |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function getWeekdayFullname($day = 0, $month = 0, $year = 0) |
| function quarterOfYear($day='',$month='',$year='') |
|
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
|
|
| if (empty($day)) { |
if (empty($day)) { |
| $day = Date_Calc::dateNow('%d'); |
$day = Date_Calc::dateNow('%d'); |
| } |
} |
| |
$weekday_names = Date_Calc::getWeekDays(); |
| $year_quarter = (intval(($month - 1) / 3 + 1)); |
$weekday = Date_Calc::dayOfWeek($day, $month, $year); |
| |
return $weekday_names[$weekday]; |
| return $year_quarter; |
} |
| } // end func quarterOfYear |
|
| |
|
| /** |
/** |
| * Returns date of begin of next month of given date. |
* Returns the abbreviated weekday name for the given date |
| * |
* |
| * @param string day in format DD, default is current local day |
* @param int $day the day of the month, default is current local day |
| * @param string month in format MM, default is current local month |
* @param int $month the month, default is current local month |
| * @param string year in format CCYY, default is current local year |
* @param int $year the year in four digit format, default is current local year |
| * @param string format for returned date |
* @param int $length the length of abbreviation |
| * |
* |
| * @access public |
* @return string the abbreviated name of the day of the week |
| * |
* |
| * @return string date in given format |
* @access public |
| |
* @static |
| |
* @see Date_Calc::getWeekdayFullname() |
| */ |
*/ |
| |
function getWeekdayAbbrname($day = 0, $month = 0, $year = 0, $length = 3) |
| function beginOfNextMonth($day='',$month='',$year='',$format='%Y%m%d') |
|
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
|
|
| if (empty($day)) { |
if (empty($day)) { |
| $day = Date_Calc::dateNow('%d'); |
$day = Date_Calc::dateNow('%d'); |
| } |
} |
| |
return substr(Date_Calc::getWeekdayFullname($day, $month, $year), |
| if ($month < 12) { |
0, $length); |
| $month++; |
} |
| $day=1; |
|
| } else { |
|
| $year++; |
|
| $month=1; |
|
| $day=1; |
|
| } |
|
| |
|
| return Date_Calc::dateFormat($day,$month,$year,$format); |
|
| } // end func beginOfNextMonth |
|
| |
|
| /** |
/** |
| * Returns date of the last day of next month of given date. |
* Returns the full month name for the given month |
| * |
* |
| * @param string day in format DD, default is current local day |
* @param int $month the month |
| * @param string month in format MM, default is current local month |
|
| * @param string year in format CCYY, default is current local year |
|
| * @param string format for returned date |
|
| * |
* |
| * @access public |
* @return string the full name of the month |
| * |
* |
| * @return string date in given format |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function getMonthFullname($month) |
| function endOfNextMonth($day='',$month='',$year='',$format='%Y%m%d') |
|
| { |
{ |
| if (empty($year)) { |
$month = (int)$month; |
| $year = Date_Calc::dateNow('%Y'); |
|
| } |
|
| if (empty($month)) { |
if (empty($month)) { |
| $month = Date_Calc::dateNow('%m'); |
$month = (int)Date_Calc::dateNow('%m'); |
| } |
|
| if (empty($day)) { |
|
| $day = Date_Calc::dateNow('%d'); |
|
| } |
} |
| |
$month_names = Date_Calc::getMonthNames(); |
| if ($month < 12) { |
return $month_names[$month]; |
| $month++; |
} |
| } else { |
|
| $year++; |
|
| $month=1; |
|
| } |
|
| |
|
| $day = Date_Calc::daysInMonth($month,$year); |
|
| |
|
| return Date_Calc::dateFormat($day,$month,$year,$format); |
|
| } // end func endOfNextMonth |
|
| |
|
| /** |
/** |
| * Returns date of the first day of previous month of given date. |
* Returns the abbreviated month name for the given month |
| * |
* |
| * @param string day in format DD, default is current local day |
* @param int $month the month |
| * @param string month in format MM, default is current local month |
* @param int $length the length of abbreviation |
| * @param string year in format CCYY, default is current local year |
|
| * @param string format for returned date |
|
| * |
* |
| * @access public |
* @return string the abbreviated name of the month |
| * |
* |
| * @return string date in given format |
* @access public |
| |
* @static |
| |
* @see Date_Calc::getMonthFullname |
| */ |
*/ |
| |
function getMonthAbbrname($month, $length = 3) |
| function beginOfPrevMonth($day='',$month='',$year='',$format='%Y%m%d') |
|
| { |
{ |
| if (empty($year)) { |
$month = (int)$month; |
| $year = Date_Calc::dateNow('%Y'); |
|
| } |
|
| if (empty($month)) { |
if (empty($month)) { |
| $month = Date_Calc::dateNow('%m'); |
$month = Date_Calc::dateNow('%m'); |
| } |
} |
| if (empty($day)) { |
return substr(Date_Calc::getMonthFullname($month), 0, $length); |
| $day = Date_Calc::dateNow('%d'); |
} |
| } |
|
| |
|
| if ($month > 1) { |
/** |
| $month--; |
* Returns the numeric month from the month name or an abreviation |
| $day=1; |
* |
| } else { |
* Both August and Aug would return 8. |
| $year--; |
* |
| $month=12; |
* @param string $month the name of the month to examine. |
| $day=1; |
* Case insensitive. |
| |
* |
| |
* @return integer the month's number |
| |
* |
| |
* @access public |
| |
* @static |
| |
*/ |
| |
function getMonthFromFullName($month) |
| |
{ |
| |
$month = strtolower($month); |
| |
$months = Date_Calc::getMonthNames(); |
| |
while(list($id, $name) = each($months)) { |
| |
if (ereg($month, strtolower($name))) { |
| |
return $id; |
| |
} |
| } |
} |
| |
return 0; |
| return Date_Calc::dateFormat($day,$month,$year,$format); |
} |
| } // end func beginOfPrevMonth |
|
| |
|
| /** |
/** |
| * Returns date of the last day of previous month for given date. |
* Returns an array of month names |
| * |
* |
| * @param string day in format DD, default is current local day |
* Used to take advantage of the setlocale function to return |
| * @param string month in format MM, default is current local month |
* language specific month names. |
| * @param string year in format CCYY, default is current local year |
|
| * @param string format for returned date |
|
| * |
* |
| * @access public |
* TODO: cache values to some global array to avoid preformace |
| |
* hits when called more than once. |
| |
* |
| |
* @returns array an array of month names |
| * |
* |
| * @return string date in given format |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function getMonthNames() |
| function endOfPrevMonth($day='',$month='',$year='',$format='%Y%m%d') |
|
| { |
{ |
| if (empty($year)) { |
for ($i = 1; $i < 13; $i++) { |
| $year = Date_Calc::dateNow('%Y'); |
$months[$i] = strftime('%B', mktime(0, 0, 0, $i, 1, 2001)); |
| } |
|
| if (empty($month)) { |
|
| $month = Date_Calc::dateNow('%m'); |
|
| } |
|
| if (empty($day)) { |
|
| $day = Date_Calc::dateNow('%d'); |
|
| } |
} |
| |
return $months; |
| |
} |
| |
|
| if ($month > 1) { |
/** |
| $month--; |
* Returns an array of week days |
| } else { |
* |
| $year--; |
* Used to take advantage of the setlocale function to |
| $month=12; |
* return language specific week days. |
| |
* |
| |
* TODO: cache values to some global array to avoid preformace |
| |
* hits when called more than once. |
| |
* |
| |
* @returns array an array of week day names |
| |
* |
| |
* @access public |
| |
* @static |
| |
*/ |
| |
function getWeekDays() |
| |
{ |
| |
for ($i = 0; $i < 7; $i++) { |
| |
$weekdays[$i] = strftime('%A', mktime(0, 0, 0, 1, $i, 2001)); |
| } |
} |
| |
return $weekdays; |
| $day = Date_Calc::daysInMonth($month,$year); |
} |
| |
|
| return Date_Calc::dateFormat($day,$month,$year,$format); |
|
| } // end func endOfPrevMonth |
|
| |
|
| /** |
/** |
| * Returns date of the next weekday of given date, |
* Returns day of week for given date (0 = Sunday) |
| * skipping from Friday to Monday. |
* |
| |
* @param int $day the day of the month, default is current local day |
| |
* @param int $month the month, default is current local month |
| |
* @param int $year the year in four digit format, default is current local year |
| * |
* |
| * @param string day in format DD, default is current local day |
* @return int the number of the day in the week |
| * @param string month in format MM, default is current local month |
|
| * @param string year in format CCYY, default is current local year |
|
| * @param string format for returned date |
|
| * |
* |
| * @access public |
* @access public |
| * |
* @static |
| * @return string date in given format |
|
| */ |
*/ |
| |
function dayOfWeek($day = 0, $month = 0, $year = 0) |
| function nextWeekday($day='',$month='',$year='',$format='%Y%m%d') |
|
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
|
|
| if (empty($day)) { |
if (empty($day)) { |
| $day = Date_Calc::dateNow('%d'); |
$day = Date_Calc::dateNow('%d'); |
| } |
} |
| |
if ($month > 2) { |
| $days = Date_Calc::dateToDays($day,$month,$year); |
$month -= 2; |
| |
|
| if (Date_Calc::dayOfWeek($day,$month,$year) == 5) { |
|
| $days += 3; |
|
| } elseif (Date_Calc::dayOfWeek($day,$month,$year) == 6) { |
|
| $days += 2; |
|
| } else { |
} else { |
| $days += 1; |
$month += 10; |
| |
$year--; |
| } |
} |
| |
|
| return(Date_Calc::daysToDate($days,$format)); |
$day = (floor((13 * $month - 1) / 5) + |
| } // end func nextWeekday |
$day + ($year % 100) + |
| |
floor(($year % 100) / 4) + |
| |
floor(($year / 100) / 4) - 2 * |
| |
floor($year / 100) + 77); |
| |
|
| |
$weekday_number = $day - 7 * floor($day / 7); |
| |
return $weekday_number; |
| |
} |
| |
|
| /** |
/** |
| * Returns date of the previous weekday, |
* Returns week of the year, first Sunday is first day of first week |
| * skipping from Monday to Friday. |
|
| * |
* |
| * @param string day in format DD, default is current local day |
* @param int $day the day of the month, default is current local day |
| * @param string month in format MM, default is current local month |
* @param int $month the month, default is current local month |
| * @param string year in format CCYY, default is current local year |
* @param int $year the year in four digit format, default is current local year |
| * @param string format for returned date |
|
| * |
* |
| * @access public |
* @return int the number of the week in the year |
| * |
* |
| * @return string date in given format |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function weekOfYear($day = 0, $month = 0, $year = 0) |
| function prevWeekday($day='',$month='',$year='',$format='%Y%m%d') |
|
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
|
|
| if (empty($day)) { |
if (empty($day)) { |
| $day = Date_Calc::dateNow('%d'); |
$day = Date_Calc::dateNow('%d'); |
| } |
} |
| |
$iso = Date_Calc::gregorianToISO($day, $month, $year); |
| $days = Date_Calc::dateToDays($day,$month,$year); |
$parts = explode('-', $iso); |
| |
$week_number = intval($parts[1]); |
| if (Date_Calc::dayOfWeek($day,$month,$year) == 1) { |
return $week_number; |
| $days -= 3; |
} |
| } elseif (Date_Calc::dayOfWeek($day,$month,$year) == 0) { |
|
| $days -= 2; |
|
| } else { |
|
| $days -= 1; |
|
| } |
|
| |
|
| return(Date_Calc::daysToDate($days,$format)); |
|
| } // end func prevWeekday |
|
| |
|
| /** |
/** |
| * Returns date of the next specific day of the week |
* Returns quarter of the year for given date |
| * from the given date. |
|
| * |
* |
| * @param int day of week, 0=Sunday |
* @param int $day the day of the month, default is current local day |
| * @param string day in format DD, default is current local day |
* @param int $month the month, default is current local month |
| * @param string month in format MM, default is current local month |
* @param int $year the year in four digit format, default is current local year |
| * @param string year in format CCYY, default is current local year |
|
| * @param boolean onOrAfter if true and days are same, returns current day |
|
| * @param string format for returned date |
|
| * |
* |
| * @access public |
* @return int the number of the quarter in the year |
| * |
* |
| * @return string date in given format |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function quarterOfYear($day = 0, $month = 0, $year = 0) |
| function nextDayOfWeek($dow,$day='',$month='',$year='',$format='%Y%m%d',$onOrAfter=false) |
|
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
|
|
| if (empty($day)) { |
if (empty($day)) { |
| $day = Date_Calc::dateNow('%d'); |
$day = Date_Calc::dateNow('%d'); |
| } |
} |
| |
$year_quarter = intval(($month - 1) / 3 + 1); |
| $days = Date_Calc::dateToDays($day,$month,$year); |
return $year_quarter; |
| $curr_weekday = Date_Calc::dayOfWeek($day,$month,$year); |
} |
| |
|
| if ($curr_weekday == $dow) { |
|
| if (!$onOrAfter) { |
|
| $days += 7; |
|
| } |
|
| } |
|
| elseif ($curr_weekday > $dow) { |
|
| $days += 7 - ( $curr_weekday - $dow ); |
|
| } else { |
|
| $days += $dow - $curr_weekday; |
|
| } |
|
| |
|
| return(Date_Calc::daysToDate($days,$format)); |
|
| } // end func nextDayOfWeek |
|
| |
|
| /** |
/** |
| * Returns date of the previous specific day of the week |
* Find the number of days in the given month |
| * from the given date. |
|
| * |
* |
| * @param int day of week, 0=Sunday |
* @param int $month the month, default is current local month |
| * @param string day in format DD, default is current local day |
* @param int $year the year in four digit format, default is current local year |
| * @param string month in format MM, default is current local month |
|
| * @param string year in format CCYY, default is current local year |
|
| * @param boolean onOrBefore if true and days are same, returns current day |
|
| * @param string format for returned date |
|
| * |
* |
| * @access public |
* @return int the number of days the month has |
| * |
* |
| * @return string date in given format |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function daysInMonth($month = 0, $year = 0) |
| function prevDayOfWeek($dow,$day='',$month='',$year='',$format='%Y%m%d',$onOrBefore=false) |
|
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
|
|
| if (empty($month)) { |
if (empty($month)) { |
| $month = Date_Calc::dateNow('%m'); |
$month = Date_Calc::dateNow('%m'); |
| } |
} |
| if (empty($day)) { |
|
| $day = Date_Calc::dateNow('%d'); |
|
| } |
|
| |
|
| $days = Date_Calc::dateToDays($day,$month,$year); |
if ($year == 1582 && $month == 10) { |
| $curr_weekday = Date_Calc::dayOfWeek($day,$month,$year); |
return 21; // October 1582 only had 1st-4th and 15th-31st |
| |
} |
| |
|
| if ($curr_weekday == $dow) { |
if ($month == 2) { |
| if (!$onOrBefore) { |
if (Date_Calc::isLeapYear($year)) { |
| $days -= 7; |
return 29; |
| |
} else { |
| |
return 28; |
| } |
} |
| } |
} elseif ($month == 4 or $month == 6 or $month == 9 or $month == 11) { |
| elseif ($curr_weekday < $dow) { |
return 30; |
| $days -= 7 - ( $dow - $curr_weekday ); |
|
| } else { |
} else { |
| $days -= $curr_weekday - $dow; |
return 31; |
| } |
} |
| |
} |
| return(Date_Calc::daysToDate($days,$format)); |
|
| } // end func prevDayOfWeek |
|
| |
|
| /** |
/** |
| * Returns date of the next specific day of the week |
* Returns the number of rows on a calendar month |
| * on or after the given date. |
|
| * |
* |
| * @param int day of week, 0=Sunday |
* Useful for determining the number of rows when displaying a typical |
| * @param string day in format DD, default is current local day |
* month calendar. |
| * @param string month in format MM, default is current local month |
|
| * @param string year in format CCYY, default is current local year |
|
| * @param string format for returned date |
|
| * |
|
| * @access public |
|
| * |
* |
| * @return string date in given format |
* @param int $month the month, default is current local month |
| */ |
* @param int $year the year in four digit format, default is current local year |
| |
|
| function nextDayOfWeekOnOrAfter($dow,$day='',$month='',$year='',$format='%Y%m%d') |
|
| { |
|
| return(Date_Calc::nextDayOfWeek($dow,$day,$month,$year,$format,true)); |
|
| } // end func nextDayOfWeekOnOrAfter |
|
| |
|
| /** |
|
| * Returns date of the previous specific day of the week |
|
| * on or before the given date. |
|
| * |
* |
| * @param int day of week, 0=Sunday |
* @return int the number of weeks the month has |
| * @param string day in format DD, default is current local day |
|
| * @param string month in format MM, default is current local month |
|
| * @param string year in format CCYY, default is current local year |
|
| * @param string format for returned date |
|
| * |
* |
| * @access public |
* @access public |
| * |
* @static |
| * @return string date in given format |
|
| */ |
*/ |
| |
function weeksInMonth($month = 0, $year = 0) |
| function prevDayOfWeekOnOrBefore($dow,$day='',$month='',$year='',$format='%Y%m%d') |
|
| { |
{ |
| return(Date_Calc::prevDayOfWeek($dow,$day,$month,$year,$format,true)); |
if (empty($year)) { |
| } // end func prevDayOfWeekOnOrAfter |
$year = Date_Calc::dateNow('%Y'); |
| |
} |
| |
if (empty($month)) { |
| |
$month = Date_Calc::dateNow('%m'); |
| |
} |
| |
$FDOM = Date_Calc::firstOfMonthWeekday($month, $year); |
| |
if (DATE_CALC_BEGIN_WEEKDAY==1 && $FDOM==0) { |
| |
$first_week_days = 7 - $FDOM + DATE_CALC_BEGIN_WEEKDAY; |
| |
$weeks = 1; |
| |
} elseif (DATE_CALC_BEGIN_WEEKDAY==0 && $FDOM == 6) { |
| |
$first_week_days = 7 - $FDOM + DATE_CALC_BEGIN_WEEKDAY; |
| |
$weeks = 1; |
| |
} else { |
| |
$first_week_days = DATE_CALC_BEGIN_WEEKDAY - $FDOM; |
| |
$weeks = 0; |
| |
} |
| |
$first_week_days %= 7; |
| |
return ceil((Date_Calc::daysInMonth($month, $year) |
| |
- $first_week_days) / 7) + $weeks; |
| |
} |
| |
|
| /** |
/** |
| * Returns date of day after given date. |
* Return an array with days in week |
| * |
* |
| * @param string day in format DD, default is current local day |
* @param int $day the day of the month, default is current local day |
| * @param string month in format MM, default is current local month |
* @param int $month the month, default is current local month |
| * @param string year in format CCYY, default is current local year |
* @param int $year the year in four digit format, default is current local year |
| * @param string format for returned date |
* @param string $format the string indicating how to format the output |
| * |
* |
| * @access public |
* @return array $week[$weekday] |
| * |
* |
| * @return string date in given format |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function getCalendarWeek($day = 0, $month = 0, $year = 0, |
| function nextDay($day='',$month='',$year='',$format='%Y%m%d') |
$format = DATE_CALC_FORMAT) |
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
|
|
| $day = Date_Calc::dateNow('%d'); |
$day = Date_Calc::dateNow('%d'); |
| } |
} |
| |
|
| $days = Date_Calc::dateToDays($day,$month,$year); |
$week_array = array(); |
| |
|
| |
// date for the column of week |
| |
|
| |
$curr_day = Date_Calc::beginOfWeek($day, $month, $year,'%E'); |
| |
|
| return(Date_Calc::daysToDate($days + 1,$format)); |
for ($counter = 0; $counter <= 6; $counter++) { |
| } // end func nextDay |
$week_array[$counter] = Date_Calc::daysToDate($curr_day, $format); |
| |
$curr_day++; |
| |
} |
| |
return $week_array; |
| |
} |
| |
|
| /** |
/** |
| * Returns date of day before given date. |
* Return a set of arrays to construct a calendar month for the given date |
| * |
* |
| * @param string day in format DD, default is current local day |
* @param int $month the month, default is current local month |
| * @param string month in format MM, default is current local month |
* @param int $year the year in four digit format, default is current local year |
| * @param string year in format CCYY, default is current local year |
* @param string $format the string indicating how to format the output |
| * @param string format for returned date |
|
| * |
* |
| * @access public |
* @return array $month[$row][$col] |
| * |
* |
| * @return string date in given format |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function getCalendarMonth($month = 0, $year = 0, |
| function prevDay($day='',$month='',$year='',$format='%Y%m%d') |
$format = DATE_CALC_FORMAT) |
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
|
|
| if (empty($month)) { |
if (empty($month)) { |
| $month = Date_Calc::dateNow('%m'); |
$month = Date_Calc::dateNow('%m'); |
| } |
} |
| if (empty($day)) { |
|
| $day = Date_Calc::dateNow('%d'); |
$month_array = array(); |
| |
|
| |
// date for the first row, first column of calendar month |
| |
if (DATE_CALC_BEGIN_WEEKDAY == 1) { |
| |
if (Date_Calc::firstOfMonthWeekday($month, $year) == 0) { |
| |
$curr_day = Date_Calc::dateToDays('01', $month, $year) - 6; |
| |
} else { |
| |
$curr_day = Date_Calc::dateToDays('01', $month, $year) |
| |
- Date_Calc::firstOfMonthWeekday($month, $year) + 1; |
| |
} |
| |
} else { |
| |
$curr_day = (Date_Calc::dateToDays('01', $month, $year) |
| |
- Date_Calc::firstOfMonthWeekday($month, $year)); |
| } |
} |
| |
|
| $days = Date_Calc::dateToDays($day,$month,$year); |
// number of days in this month |
| |
$daysInMonth = Date_Calc::daysInMonth($month, $year); |
| |
|
| |
$weeksInMonth = Date_Calc::weeksInMonth($month, $year); |
| |
for ($row_counter = 0; $row_counter < $weeksInMonth; $row_counter++) { |
| |
for ($column_counter = 0; $column_counter <= 6; $column_counter++) { |
| |
$month_array[$row_counter][$column_counter] = |
| |
Date_Calc::daysToDate($curr_day , $format); |
| |
$curr_day++; |
| |
} |
| |
} |
| |
|
| return(Date_Calc::daysToDate($days - 1,$format)); |
return $month_array; |
| } // end func prevDay |
} |
| |
|
| /** |
/** |
| * Sets century for 2 digit year. |
* Return a set of arrays to construct a calendar year for the given date |
| * 51-99 is 19, else 20 |
|
| * |
* |
| * @param string 2 digit year |
* @param int $year the year in four digit format, default current local year |
| |
* @param string $format the string indicating how to format the output |
| * |
* |
| * @access public |
* @return array $year[$month][$row][$col] |
| * |
* |
| * @return string 4 digit year |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function getCalendarYear($year = 0, $format = DATE_CALC_FORMAT) |
| function defaultCentury($year) |
|
| { |
{ |
| if (strlen($year) == 1) { |
if (empty($year)) { |
| $year = "0$year"; |
$year = Date_Calc::dateNow('%Y'); |
| } |
} |
| if ($year > 50) { |
|
| return( "19$year" ); |
$year_array = array(); |
| } else { |
|
| return( "20$year" ); |
for ($curr_month = 0; $curr_month <= 11; $curr_month++) { |
| |
$year_array[$curr_month] = |
| |
Date_Calc::getCalendarMonth($curr_month + 1, |
| |
$year, $format); |
| } |
} |
| } // end func defaultCentury |
|
| |
return $year_array; |
| |
} |
| |
|
| /** |
/** |
| * Returns number of days between two given dates. |
* Returns date of day before given date |
| * |
* |
| * @param string $day1 day in format DD |
* @param int $day the day of the month, default is current local day |
| * @param string $month1 month in format MM |
* @param int $month the month, default is current local month |
| * @param string $year1 year in format CCYY |
* @param int $year the year in four digit format, default is current local year |
| * @param string $day2 day in format DD |
* @param string $format the string indicating how to format the output |
| * @param string $month2 month in format MM |
|
| * @param string $year2 year in format CCYY |
|
| * |
* |
| * @access public |
* @return string the date in the desired format |
| * |
* |
| * @return int absolute number of days between dates, |
* @access public |
| * -1 if there is an error. |
* @static |
| */ |
*/ |
| |
function prevDay($day = 0, $month = 0, $year = 0, |
| function dateDiff($day1,$month1,$year1,$day2,$month2,$year2) |
$format = DATE_CALC_FORMAT) |
| { |
{ |
| if (!Date_Calc::isValidDate($day1,$month1,$year1)) { |
if (empty($year)) { |
| return -1; |
$year = Date_Calc::dateNow('%Y'); |
| } |
} |
| if (!Date_Calc::isValidDate($day2,$month2,$year2)) { |
if (empty($month)) { |
| return -1; |
$month = Date_Calc::dateNow('%m'); |
| } |
} |
| |
if (empty($day)) { |
| return(abs((Date_Calc::dateToDays($day1,$month1,$year1)) |
$day = Date_Calc::dateNow('%d'); |
| - (Date_Calc::dateToDays($day2,$month2,$year2)))); |
|
| } // end func dateDiff |
|
| |
|
| /** |
|
| * Compares two dates |
|
| * |
|
| * @param string $day1 day in format DD |
|
| * @param string $month1 month in format MM |
|
| * @param string $year1 year in format CCYY |
|
| * @param string $day2 day in format DD |
|
| * @param string $month2 month in format MM |
|
| * @param string $year2 year in format CCYY |
|
| * |
|
| * @access public |
|
| * @return int 0 on equality, 1 if date 1 is greater, -1 if smaller |
|
| */ |
|
| function compareDates($day1,$month1,$year1,$day2,$month2,$year2) |
|
| { |
|
| $ndays1 = Date_Calc::dateToDays($day1, $month1, $year1); |
|
| $ndays2 = Date_Calc::dateToDays($day2, $month2, $year2); |
|
| if ($ndays1 == $ndays2) { |
|
| return 0; |
|
| } |
} |
| return ($ndays1 > $ndays2) ? 1 : -1; |
$days = Date_Calc::dateToDays($day, $month, $year); |
| } // end func compareDates |
return Date_Calc::daysToDate($days - 1, $format); |
| |
} |
| |
|
| /** |
/** |
| * Find the number of days in the given month. |
* Returns date of day after given date |
| * |
* |
| * @param string month in format MM, default is current local month |
* @param int $day the day of the month, default is current local day |
| * @param string year in format CCYY, default is current local year |
* @param int $month the month, default is current local month |
| |
* @param int $year the year in four digit format, default is current local year |
| |
* @param string $format the string indicating how to format the output |
| * |
* |
| * @access public |
* @return string the date in the desired format |
| * |
* |
| * @return int number of days |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function nextDay($day = 0, $month = 0, $year = 0, |
| function daysInMonth($month='',$year='') |
$format = DATE_CALC_FORMAT) |
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
|
| Line 1008 class Date_Calc |
|
| if (empty($month)) { |
if (empty($month)) { |
| $month = Date_Calc::dateNow('%m'); |
$month = Date_Calc::dateNow('%m'); |
| } |
} |
| |
if (empty($day)) { |
| if ($year == 1582 && $month == 10) { |
$day = Date_Calc::dateNow('%d'); |
| return 21; // October 1582 only had 1st-4th and 15th-31st |
|
| } |
|
| |
|
| if ($month == 2) { |
|
| if (Date_Calc::isLeapYear($year)) { |
|
| return 29; |
|
| } else { |
|
| return 28; |
|
| } |
|
| } elseif ($month == 4 or $month == 6 or $month == 9 or $month == 11) { |
|
| return 30; |
|
| } else { |
|
| return 31; |
|
| } |
} |
| } // end func daysInMonth |
$days = Date_Calc::dateToDays($day, $month, $year); |
| |
return Date_Calc::daysToDate($days + 1, $format); |
| |
} |
| |
|
| /** |
/** |
| * Returns the number of rows on a calendar month. Useful for |
* Returns date of the previous weekday, skipping from Monday to Friday |
| * determining the number of rows when displaying a typical |
|
| * month calendar. |
|
| * |
* |
| * @param string month in format MM, default is current local month |
* @param int $day the day of the month, default is current local day |
| * @param string year in format CCYY, default is current local year |
* @param int $month the month, default is current local month |
| |
* @param int $year the year in four digit format, default is current local year |
| |
* @param string $format the string indicating how to format the output |
| * |
* |
| * @access public |
* @return string the date in the desired format |
| * |
* |
| * @return int number of weeks |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function prevWeekday($day = 0, $month = 0, $year = 0, |
| function weeksInMonth($month='',$year='') |
$format = DATE_CALC_FORMAT) |
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
|
| Line 1037 class Date_Calc |
|
| if (empty($month)) { |
if (empty($month)) { |
| $month = Date_Calc::dateNow('%m'); |
$month = Date_Calc::dateNow('%m'); |
| } |
} |
| $FDOM = Date_Calc::firstOfMonthWeekday($month, $year); |
if (empty($day)) { |
| if (DATE_CALC_BEGIN_WEEKDAY==1 && $FDOM==0) { |
$day = Date_Calc::dateNow('%d'); |
| $first_week_days = 7 - $FDOM + DATE_CALC_BEGIN_WEEKDAY; |
} |
| $weeks = 1; |
$days = Date_Calc::dateToDays($day, $month, $year); |
| } elseif (DATE_CALC_BEGIN_WEEKDAY==0 && $FDOM == 6) { |
if (Date_Calc::dayOfWeek($day, $month, $year) == 1) { |
| $first_week_days = 7 - $FDOM + DATE_CALC_BEGIN_WEEKDAY; |
$days -= 3; |
| $weeks = 1; |
} elseif (Date_Calc::dayOfWeek($day, $month, $year) == 0) { |
| |
$days -= 2; |
| } else { |
} else { |
| $first_week_days = DATE_CALC_BEGIN_WEEKDAY - $FDOM; |
$days -= 1; |
| $weeks = 0; |
|
| } |
} |
| $first_week_days %= 7; |
return Date_Calc::daysToDate($days, $format); |
| return (ceil((Date_Calc::daysInMonth($month, $year) - $first_week_days) / 7) + $weeks); |
} |
| } // end func weeksInMonth |
|
| |
|
| /** |
/** |
| * Find the day of the week for the first of the month of given date. |
* Returns date of the next weekday of given date, skipping from |
| |
* Friday to Monday |
| * |
* |
| * @param string month in format MM, default is current local month |
* @param int $day the day of the month, default is current local day |
| * @param string year in format CCYY, default is current local year |
* @param int $month the month, default is current local month |
| |
* @param int $year the year in four digit format, default is current local year |
| |
* @param string $format the string indicating how to format the output |
| * |
* |
| * @access public |
* @return string the date in the desired format |
| * |
* |
| * @return int number of weekday for the first day, 0=Sunday |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function nextWeekday($day = 0, $month = 0, $year = 0, |
| function firstOfMonthWeekday($month='',$year='') |
$format = DATE_CALC_FORMAT) |
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
|
| Line 1074 class Date_Calc |
|
| if (empty($month)) { |
if (empty($month)) { |
| $month = Date_Calc::dateNow('%m'); |
$month = Date_Calc::dateNow('%m'); |
| } |
} |
| |
if (empty($day)) { |
| return(Date_Calc::dayOfWeek('01',$month,$year)); |
$day = Date_Calc::dateNow('%d'); |
| } // end func firstOfMonthWeekday |
} |
| |
$days = Date_Calc::dateToDays($day, $month, $year); |
| |
if (Date_Calc::dayOfWeek($day, $month, $year) == 5) { |
| |
$days += 3; |
| |
} elseif (Date_Calc::dayOfWeek($day, $month, $year) == 6) { |
| |
$days += 2; |
| |
} else { |
| |
$days += 1; |
| |
} |
| |
return Date_Calc::daysToDate($days, $format); |
| |
} |
| |
|
| /** |
/** |
| * Return date of first day of month of given date. |
* Returns date of the previous specific day of the week |
| |
* from the given date |
| * |
* |
| * @param string month in format MM, default is current local month |
* @param int day of week, 0=Sunday |
| * @param string year in format CCYY, default is current local year |
* @param int $day the day of the month, default is current local day |
| * @param string format for returned date |
* @param int $month the month, default is current local month |
| |
* @param int $year the year in four digit format, default is current local year |
| |
* @param bool $onOrBefore if true and days are same, returns current day |
| |
* @param string $format the string indicating how to format the output |
| * |
* |
| * @access public |
* @return string the date in the desired format |
| * |
* |
| * @return string date in given format |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function prevDayOfWeek($dow, $day = 0, $month = 0, $year = 0, |
| function beginOfMonth($month='',$year='',$format='%Y%m%d') |
$format = DATE_CALC_FORMAT, $onOrBefore = false) |
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
|
| Line 1113 class Date_Calc |
|
| if (empty($month)) { |
if (empty($month)) { |
| $month = Date_Calc::dateNow('%m'); |
$month = Date_Calc::dateNow('%m'); |
| } |
} |
| |
if (empty($day)) { |
| return(Date_Calc::dateFormat('01',$month,$year,$format)); |
$day = Date_Calc::dateNow('%d'); |
| } // end of func beginOfMonth |
} |
| |
$days = Date_Calc::dateToDays($day, $month, $year); |
| |
$curr_weekday = Date_Calc::dayOfWeek($day, $month, $year); |
| |
if ($curr_weekday == $dow) { |
| |
if (!$onOrBefore) { |
| |
$days -= 7; |
| |
} |
| |
} elseif ($curr_weekday < $dow) { |
| |
$days -= 7 - ($dow - $curr_weekday); |
| |
} else { |
| |
$days -= $curr_weekday - $dow; |
| |
} |
| |
return Date_Calc::daysToDate($days, $format); |
| |
} |
| |
|
| /** |
/** |
| * Find the month day of the beginning of week for given date, |
* Returns date of the next specific day of the week |
| * using DATE_CALC_BEGIN_WEEKDAY. (can return weekday of prev month.) |
* from the given date |
| * |
* |
| * @param string day in format DD, default is current local day |
* @param int $dow the day of the week (0 = Sunday) |
| * @param string month in format MM, default is current local month |
* @param int $day the day of the month, default is current local day |
| * @param string year in format CCYY, default is current local year |
* @param int $month the month, default is current local month |
| * @param string format for returned date |
* @param int $year the year in four digit format, default is current local year |
| |
* @param bool $onOrAfter if true and days are same, returns current day |
| |
* @param string $format the string indicating how to format the output |
| * |
* |
| * @access public |
* @return string the date in the desired format |
| * |
* |
| * @return string date in given format |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function nextDayOfWeek($dow, $day = 0, $month = 0, $year = 0, |
| function beginOfWeek($day='',$month='',$year='',$format='%Y%m%d') |
$format = DATE_CALC_FORMAT, $onOrAfter = false) |
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
|
| Line 1159 class Date_Calc |
|
| $day = Date_Calc::dateNow('%d'); |
$day = Date_Calc::dateNow('%d'); |
| } |
} |
| |
|
| $this_weekday = Date_Calc::dayOfWeek($day,$month,$year); |
$days = Date_Calc::dateToDays($day, $month, $year); |
| |
$curr_weekday = Date_Calc::dayOfWeek($day, $month, $year); |
| |
|
| $interval = (7 - DATE_CALC_BEGIN_WEEKDAY + $this_weekday) % 7; |
if ($curr_weekday == $dow) { |
| |
if (!$onOrAfter) { |
| |
$days += 7; |
| |
} |
| |
} elseif ($curr_weekday > $dow) { |
| |
$days += 7 - ($curr_weekday - $dow); |
| |
} else { |
| |
$days += $dow - $curr_weekday; |
| |
} |
| |
|
| return(Date_Calc::daysToDate(Date_Calc::dateToDays($day,$month,$year) - $interval,$format)); |
return Date_Calc::daysToDate($days, $format); |
| } // end of func beginOfWeek |
} |
| |
|
| /** |
/** |
| * Find the month day of the end of week for given date, |
* Returns date of the previous specific day of the week |
| * using DATE_CALC_BEGIN_WEEKDAY. (can return weekday |
* on or before the given date |
| * of following month.) |
|
| * |
* |
| * @param string day in format DD, default is current local day |
* @param int $dow the day of the week (0 = Sunday) |
| * @param string month in format MM, default is current local month |
* @param int $day the day of the month, default is current local day |
| * @param string year in format CCYY, default is current local year |
* @param int $month the month, default is current local month |
| * @param string format for returned date |
* @param int $year the year in four digit format, default is current local year |
| |
* @param string $format the string indicating how to format the output |
| |
* |
| |
* @return string the date in the desired format |
| * |
* |
| * @access public |
* @access public |
| |
* @static |
| |
*/ |
| |
function prevDayOfWeekOnOrBefore($dow, $day = 0, $month = 0, $year = 0, |
| |
$format = DATE_CALC_FORMAT) |
| |
{ |
| |
return Date_Calc::prevDayOfWeek($dow, $day, $month, $year, $format, |
| |
true); |
| |
} |
| |
|
| |
/** |
| |
* Returns date of the next specific day of the week |
| |
* on or after the given date |
| |
* |
| |
* @param int $dow the day of the week (0 = Sunday) |
| |
* @param int $day the day of the month, default is current local day |
| |
* @param int $month the month, default is current local month |
| |
* @param int $year the year in four digit format, default is current local year |
| |
* @param string $format the string indicating how to format the output |
| * |
* |
| * @return string date in given format |
* @return string the date in the desired format |
| |
* |
| |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function nextDayOfWeekOnOrAfter($dow, $day = 0, $month = 0, $year = 0, |
| |
$format = DATE_CALC_FORMAT) |
| |
{ |
| |
return Date_Calc::nextDayOfWeek($dow, $day, $month, $year, $format, |
| |
true); |
| |
} |
| |
|
| function endOfWeek($day='',$month='',$year='',$format='%Y%m%d') |
/** |
| |
* Find the month day of the beginning of week for given date, |
| |
* using DATE_CALC_BEGIN_WEEKDAY |
| |
* |
| |
* Can return weekday of prev month. |
| |
* |
| |
* @param int $day the day of the month, default is current local day |
| |
* @param int $month the month, default is current local month |
| |
* @param int $year the year in four digit format, default is current local year |
| |
* @param string $format the string indicating how to format the output |
| |
* |
| |
* @return string the date in the desired format |
| |
* |
| |
* @access public |
| |
* @static |
| |
*/ |
| |
function beginOfWeek($day = 0, $month = 0, $year = 0, |
| |
$format = DATE_CALC_FORMAT) |
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
|
| Line 1247 class Date_Calc |
|
| if (empty($day)) { |
if (empty($day)) { |
| $day = Date_Calc::dateNow('%d'); |
$day = Date_Calc::dateNow('%d'); |
| } |
} |
| |
$this_weekday = Date_Calc::dayOfWeek($day, $month, $year); |
| |
$interval = (7 - DATE_CALC_BEGIN_WEEKDAY + $this_weekday) % 7; |
| $this_weekday = Date_Calc::dayOfWeek($day,$month,$year); |
return Date_Calc::daysToDate(Date_Calc::dateToDays($day, $month, $year) |
| |
- $interval, $format); |
| $interval = (6 + DATE_CALC_BEGIN_WEEKDAY - $this_weekday) % 7; |
} |
| |
|
| return(Date_Calc::daysToDate(Date_Calc::dateToDays($day,$month,$year) + $interval,$format)); |
|
| } // end func endOfWeek |
|
| |
|
| /** |
/** |
| * Find the month day of the beginning of week after given date, |
* Find the month day of the end of week for given date, |
| * using DATE_CALC_BEGIN_WEEKDAY. (can return weekday of prev month.) |
* using DATE_CALC_BEGIN_WEEKDAY |
| * |
* |
| * @param string day in format DD, default is current local day |
* Can return weekday of following month. |
| * @param string month in format MM, default is current local month |
|
| * @param string year in format CCYY, default is current local year |
|
| * @param string format for returned date |
|
| * |
* |
| * @access public |
* @param int $day the day of the month, default is current local day |
| |
* @param int $month the month, default is current local month |
| |
* @param int $year the year in four digit format, default is current local year |
| |
* @param string $format the string indicating how to format the output |
| * |
* |
| * @return string date in given format |
* @return string the date in the desired format |
| |
* |
| |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function endOfWeek($day = 0, $month = 0, $year = 0, |
| function beginOfNextWeek($day='',$month='',$year='',$format='%Y%m%d') |
$format = DATE_CALC_FORMAT) |
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow("%Y"); |
$year = Date_Calc::dateNow('%Y'); |
| } |
} |
| if (empty($month)) { |
if (empty($month)) { |
| $month = Date_Calc::dateNow("%m"); |
$month = Date_Calc::dateNow('%m'); |
| } |
} |
| if (empty($day)) { |
if (empty($day)) { |
| $day = Date_Calc::dateNow("%d"); |
$day = Date_Calc::dateNow('%d'); |
| } |
} |
| |
$this_weekday = Date_Calc::dayOfWeek($day, $month, $year); |
| $date = Date_Calc::daysToDate( |
$interval = (6 + DATE_CALC_BEGIN_WEEKDAY - $this_weekday) % 7; |
| Date_Calc::dateToDays($day+7,$month,$year),"%Y%m%d" |
return Date_Calc::daysToDate(Date_Calc::dateToDays($day, $month, $year) |
| ); |
+ $interval, $format); |
| |
} |
| $next_week_year = substr($date,0,4); |
|
| $next_week_month = substr($date,4,2); |
|
| $next_week_day = substr($date,6,2); |
|
| |
|
| return Date_Calc::beginOfWeek( |
|
| $next_week_day,$next_week_month,$next_week_year, |
|
| $format |
|
| ); |
|
| |
|
| $date = Date_Calc::daysToDate(Date_Calc::dateToDays($day+7,$month,$year),"%Y%m%d"); |
|
| } // end func beginOfNextWeek |
|
| |
|
| /** |
/** |
| * Find the month day of the beginning of week before given date, |
* Find the month day of the beginning of week before given date, |
| * using DATE_CALC_BEGIN_WEEKDAY. (can return weekday of prev month.) |
* using DATE_CALC_BEGIN_WEEKDAY |
| * |
* |
| * @param string day in format DD, default is current local day |
* Can return weekday of prev month. |
| * @param string month in format MM, default is current local month |
|
| * @param string year in format CCYY, default is current local year |
|
| * @param string format for returned date |
|
| * |
* |
| * @access public |
* @param int $day the day of the month, default is current local day |
| |
* @param int $month the month, default is current local month |
| |
* @param int $year the year in four digit format, default is current local year |
| |
* @param string $format the string indicating how to format the output |
| |
* |
| |
* @return string the date in the desired format |
| * |
* |
| * @return string date in given format |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function beginOfPrevWeek($day = 0, $month = 0, $year = 0, |
| function beginOfPrevWeek($day='',$month='',$year='',$format='%Y%m%d') |
$format = DATE_CALC_FORMAT) |
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow("%Y"); |
$year = Date_Calc::dateNow('%Y'); |
| } |
} |
| if (empty($month)) { |
if (empty($month)) { |
| $month = Date_Calc::dateNow("%m"); |
$month = Date_Calc::dateNow('%m'); |
| } |
} |
| if (empty($day)) { |
if (empty($day)) { |
| $day = Date_Calc::dateNow("%d"); |
$day = Date_Calc::dateNow('%d'); |
| } |
} |
| |
|
| $date = Date_Calc::daysToDate( |
$date = Date_Calc::daysToDate(Date_Calc::dateToDays($day-7, |
| Date_Calc::dateToDays($day-7,$month,$year),"%Y%m%d" |
$month, |
| ); |
$year), |
| |
'%Y%m%d'); |
| $prev_week_year = substr($date,0,4); |
|
| $prev_week_month = substr($date,4,2); |
$prev_week_year = substr($date, 0, 4); |
| $prev_week_day = substr($date,6,2); |
$prev_week_month = substr($date, 4, 2); |
| |
$prev_week_day = substr($date, 6, 2); |
| return Date_Calc::beginOfWeek($prev_week_day,$prev_week_month,$prev_week_year,$format); |
|
| |
|
| |
|
| $date = Date_Calc::daysToDate(Date_Calc::dateToDays($day-7,$month,$year),"%Y%m%d"); |
return Date_Calc::beginOfWeek($prev_week_day, $prev_week_month, |
| } // end func beginOfPrevWeek |
$prev_week_year, $format); |
| |
} |
| |
|
| /** |
/** |
| * Return an array with days in week |
* Find the month day of the beginning of week after given date, |
| |
* using DATE_CALC_BEGIN_WEEKDAY |
| * |
* |
| * @param string day in format DD, default is current local day |
* Can return weekday of prev month. |
| * @param string month in format MM, default is current local month |
|
| * @param string year in format CCYY, default is current local year |
|
| * @param string format for returned date |
|
| * |
* |
| * @access public |
* @param int $day the day of the month, default is current local day |
| |
* @param int $month the month, default is current local month |
| |
* @param int $year the year in four digit format, default is current local year |
| |
* @param string $format the string indicating how to format the output |
| * |
* |
| * @return array $week[$weekday] |
* @return string the date in the desired format |
| |
* |
| |
* @access public |
| |
* @static |
| */ |
*/ |
| |
function beginOfNextWeek($day = 0, $month = 0, $year = 0, |
| function getCalendarWeek($day='',$month='',$year='',$format='%Y%m%d') |
$format = DATE_CALC_FORMAT) |
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
| Line 1094 class Date_Calc |
|
| Line 1358 class Date_Calc |
|
| $day = Date_Calc::dateNow('%d'); |
$day = Date_Calc::dateNow('%d'); |
| } |
} |
| |
|
| $week_array = array(); |
$date = Date_Calc::daysToDate(Date_Calc::dateToDays($day + 7, |
| |
$month, |
| // date for the column of week |
$year), |
| |
'%Y%m%d'); |
| $curr_day = Date_Calc::beginOfWeek($day,$month,$year,'%E'); |
|
| |
$next_week_year = substr($date, 0, 4); |
| |
$next_week_month = substr($date, 4, 2); |
| |
$next_week_day = substr($date, 6, 2); |
| |
|
| for($counter=0; $counter <= 6; $counter++) { |
return Date_Calc::beginOfWeek($next_week_day, $next_week_month, |
| $week_array[$counter] = Date_Calc::daysToDate($curr_day,$format); |
$next_week_year, $format); |
| $curr_day++; |
} |
| } |
|
| |
|
| return $week_array; |
|
| } // end func getCalendarWeek |
|
| |
|
| /** |
/** |
| * Return a set of arrays to construct a calendar month for |
* Return date of first day of month of given date |
| * the given date. |
|
| * |
* |
| * @param string month in format MM, default is current local month |
* @param int $month the month, default is current local month |
| * @param string year in format CCYY, default is current local year |
* @param int $year the year in four digit format, default is current local year |
| * @param string format for returned date |
* @param string $format the string indicating how to format the output |
| * |
* |
| * @access public |
* @return string the date in the desired format |
| * |
* |
| * @return array $month[$row][$col] |
* @access public |
| |
* @static |
| |
* @see Date_Calc::beginOfMonthBySpan() |
| |
* @deprecated Method deprecated in Release 1.5.0 |
| */ |
*/ |
| |
function beginOfMonth($month = 0, $year = 0, $format = DATE_CALC_FORMAT) |
| function getCalendarMonth($month='',$year='',$format='%Y%m%d') |
|
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
| Line 1129 class Date_Calc |
|
| Line 1393 class Date_Calc |
|
| if (empty($month)) { |
if (empty($month)) { |
| $month = Date_Calc::dateNow('%m'); |
$month = Date_Calc::dateNow('%m'); |
| } |
} |
| |
return Date_Calc::dateFormat('01', $month, $year, $format); |
| $month_array = array(); |
} |
| |
|
| // date for the first row, first column of calendar month |
|
| if (DATE_CALC_BEGIN_WEEKDAY == 1) { |
|
| if (Date_Calc::firstOfMonthWeekday($month,$year) == 0) { |
|
| $curr_day = Date_Calc::dateToDays('01',$month,$year) - 6; |
|
| } else { |
|
| $curr_day = Date_Calc::dateToDays('01',$month,$year) |
|
| - Date_Calc::firstOfMonthWeekday($month,$year) + 1; |
|
| } |
|
| } else { |
|
| $curr_day = (Date_Calc::dateToDays('01',$month,$year) |
|
| - Date_Calc::firstOfMonthWeekday($month,$year)); |
|
| } |
|
| |
|
| // number of days in this month |
|
| $daysInMonth = Date_Calc::daysInMonth($month,$year); |
|
| |
|
| $weeksInMonth = Date_Calc::weeksInMonth($month,$year); |
|
| for($row_counter=0; $row_counter < $weeksInMonth; $row_counter++) { |
|
| for($column_counter=0; $column_counter <= 6; $column_counter++) { |
|
| $month_array[$row_counter][$column_counter] = |
|
| Date_Calc::daysToDate($curr_day,$format); |
|
| $curr_day++; |
|
| } |
|
| } |
|
| |
|
| return $month_array; |
|
| } // end func getCalendarMonth |
|
| |
|
| /** |
/** |
| * Return a set of arrays to construct a calendar year for |
* Returns date of the first day of previous month of given date |
| * the given date. |
|
| * |
* |
| * @param string year in format CCYY, default current local year |
* @param int $day the day of the month, default is current local day |
| * @param string format for returned date |
* @param int $month the month, default is current local month |
| |
* @param int $year the year in four digit format, default is current local year |
| |
* @param string $format the string indicating how to format the output |
| * |
* |
| * @access public |
* @return string the date in the desired format |
| * |
* |
| * @return array $year[$month][$row][$col] |
* @access public |
| |
* @static |
| |
* @see Date_Calc::beginOfMonthBySpan() |
| |
* @deprecated Method deprecated in Release 1.5.0 |
| */ |
*/ |
| |
function beginOfPrevMonth($day = 0, $month = 0, $year = 0, |
| function getCalendarYear($year='',$format='%Y%m%d') |
$format = DATE_CALC_FORMAT) |
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
| } |
} |
| |
if (empty($month)) { |
| $year_array = array(); |
$month = Date_Calc::dateNow('%m'); |
| |
|
| for($curr_month=0; $curr_month <=11; $curr_month++) { |
|
| $year_array[$curr_month] = |
|
| Date_Calc::getCalendarMonth(sprintf('%02d',$curr_month+1),$year,$format); |
|
| } |
|
| |
|
| return $year_array; |
|
| } // end func getCalendarYear |
|
| |
|
| /** |
|
| * Converts a date to number of days since a |
|
| * distant unspecified epoch. |
|
| * |
|
| * @param string day in format DD |
|
| * @param string month in format MM |
|
| * @param string year in format CCYY |
|
| * |
|
| * @access public |
|
| * |
|
| * @return integer number of days |
|
| */ |
|
| |
|
| function dateToDays($day,$month,$year) |
|
| { |
|
| |
|
| $century = (int) substr($year,0,2); |
|
| $year = (int) substr($year,2,2); |
|
| |
|
| if ($month > 2) { |
|
| $month -= 3; |
|
| } else { |
|
| $month += 9; |
|
| if ($year) { |
|
| $year--; |
|
| } else { |
|
| $year = 99; |
|
| $century --; |
|
| } |
|
| } |
} |
| |
if (empty($day)) { |
| return (floor(( 146097 * $century) / 4 ) + |
$day = Date_Calc::dateNow('%d'); |
| floor(( 1461 * $year) / 4 ) + |
|
| floor(( 153 * $month + 2) / 5 ) + |
|
| $day + 1721119); |
|
| } // end func dateToDays |
|
| |
|
| /** |
|
| * Converts number of days to a distant unspecified epoch. |
|
| * |
|
| * @param int number of days |
|
| * @param string format for returned date |
|
| * |
|
| * @access public |
|
| * |
|
| * @return string date in specified format |
|
| */ |
|
| |
|
| function daysToDate($days,$format='%Y%m%d') |
|
| { |
|
| |
|
| $days -= 1721119; |
|
| $century = floor(( 4 * $days - 1) / 146097); |
|
| $days = floor(4 * $days - 1 - 146097 * $century); |
|
| $day = floor($days / 4); |
|
| |
|
| $year = floor(( 4 * $day + 3) / 1461); |
|
| $day = floor(4 * $day + 3 - 1461 * $year); |
|
| $day = floor(($day + 4) / 4); |
|
| |
|
| $month = floor(( 5 * $day - 3) / 153); |
|
| $day = floor(5 * $day - 3 - 153 * $month); |
|
| $day = floor(($day + 5) / 5); |
|
| |
|
| if ($month < 10) { |
|
| $month +=3; |
|
| } else { |
|
| $month -=9; |
|
| if ($year++ == 99) { |
|
| $year = 0; |
|
| $century++; |
|
| } |
|
| } |
} |
| |
if ($month > 1) { |
| $century = sprintf('%02d',$century); |
$month--; |
| $year = sprintf('%02d',$year); |
$day = 1; |
| return(Date_Calc::dateFormat($day,$month,$century.$year,$format)); |
|
| } // end func daysToDate |
|
| |
|
| /** |
|
| * Calculates the date of the Nth weekday of the month, |
|
| * such as the second Saturday of January 2000. |
|
| * |
|
| * @param string occurance: 1=first, 2=second, 3=third, etc. |
|
| * @param string dayOfWeek: 0=Sunday, 1=Monday, etc. |
|
| * @param string month in format MM |
|
| * @param string year in format CCYY |
|
| * @param string format for returned date |
|
| * |
|
| * @access public |
|
| * |
|
| * @return string date in given format |
|
| */ |
|
| |
|
| function NWeekdayOfMonth($occurance,$dayOfWeek,$month,$year,$format='%Y%m%d') |
|
| { |
|
| $year = sprintf('%04d',$year); |
|
| $month = sprintf('%02d',$month); |
|
| |
|
| $DOW1day = sprintf('%02d',(($occurance - 1) * 7 + 1)); |
|
| $DOW1 = Date_Calc::dayOfWeek($DOW1day,$month,$year); |
|
| |
|
| $wdate = ($occurance - 1) * 7 + 1 + |
|
| (7 + $dayOfWeek - $DOW1) % 7; |
|
| |
|
| if ( $wdate > Date_Calc::daysInMonth($month,$year)) { |
|
| return -1; |
|
| } else { |
} else { |
| return(Date_Calc::dateFormat($wdate,$month,$year,$format)); |
$year--; |
| |
$month = 12; |
| |
$day = 1; |
| } |
} |
| } // end func NWeekdayOfMonth |
return Date_Calc::dateFormat($day, $month, $year, $format); |
| |
} |
| |
|
| /** |
/** |
| * Formats the date in the given format, much like |
* Returns date of the last day of previous month for given date |
| * strfmt(). This function is used to alleviate the |
|
| * problem with 32-bit numbers for dates pre 1970 |
|
| * or post 2038, as strfmt() has on most systems. |
|
| * Most of the formatting options are compatible. |
|
| * |
|
| * formatting options: |
|
| * |
* |
| * %a abbreviated weekday name (Sun, Mon, Tue) |
* @param int $day the day of the month, default is current local day |
| * %A full weekday name (Sunday, Monday, Tuesday) |
* @param int $month the month, default is current local month |
| * %b abbreviated month name (Jan, Feb, Mar) |
* @param int $year the year in four digit format, default is current local year |
| * %B full month name (January, February, March) |
* @param string $format the string indicating how to format the output |
| * %d day of month (range 00 to 31) |
|
| * %e day of month, single digit (range 0 to 31) |
|
| * %E number of days since unspecified epoch (integer) |
|
| * (%E is useful for passing a date in a URL as |
|
| * an integer value. Then simply use |
|
| * daysToDate() to convert back to a date.) |
|
| * %j day of year (range 001 to 366) |
|
| * %m month as decimal number (range 1 to 12) |
|
| * %n newline character (\n) |
|
| * %t tab character (\t) |
|
| * %w weekday as decimal (0 = Sunday) |
|
| * %U week number of current year, first sunday as first week |
|
| * %y year as decimal (range 00 to 99) |
|
| * %Y year as decimal including century (range 0000 to 9999) |
|
| * %% literal '%' |
|
| * |
* |
| * @param string day in format DD |
* @return string the date in the desired format |
| * @param string month in format MM |
|
| * @param string year in format CCYY |
|
| * @param string format for returned date |
|
| * |
* |
| * @access public |
* @access public |
| * |
* @static |
| * @return string date in given format |
* @see Date_Calc::endOfMonthBySpan() |
| |
* @deprecated Method deprecated in Release 1.5.0 |
| */ |
*/ |
| |
function endOfPrevMonth($day = 0, $month = 0, $year = 0, |
| function dateFormat($day,$month,$year,$format) |
$format = DATE_CALC_FORMAT) |
| { |
{ |
| if (!Date_Calc::isValidDate($day,$month,$year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
| |
} |
| |
if (empty($month)) { |
| $month = Date_Calc::dateNow('%m'); |
$month = Date_Calc::dateNow('%m'); |
| |
} |
| |
if (empty($day)) { |
| $day = Date_Calc::dateNow('%d'); |
$day = Date_Calc::dateNow('%d'); |
| } |
} |
| |
if ($month > 1) { |
| $output = ''; |
$month--; |
| |
} else { |
| for($strpos = 0; $strpos < strlen($format); $strpos++) { |
$year--; |
| $char = substr($format,$strpos,1); |
$month = 12; |
| if ($char == '%') { |
|
| $nextchar = substr($format,$strpos + 1,1); |
|
| switch($nextchar) { |
|
| case 'a': |
|
| $output .= Date_Calc::getWeekdayAbbrname($day,$month,$year); |
|
| break; |
|
| case 'A': |
|
| $output .= Date_Calc::getWeekdayFullname($day,$month,$year); |
|
| break; |
|
| case 'b': |
|
| $output .= Date_Calc::getMonthAbbrname($month); |
|
| break; |
|
| case 'B': |
|
| $output .= Date_Calc::getMonthFullname($month); |
|
| break; |
|
| case 'd': |
|
| $output .= sprintf('%02d',$day); |
|
| break; |
|
| case 'e': |
|
| $output .= $day; |
|
| break; |
|
| case 'E': |
|
| $output .= Date_Calc::dateToDays($day,$month,$year); |
|
| break; |
|
| case 'j': |
|
| $output .= Date_Calc::julianDate($day,$month,$year); |
|
| break; |
|
| case 'm': |
|
| $output .= sprintf('%02d',$month); |
|
| break; |
|
| case 'n': |
|
| $output .= "\n"; |
|
| break; |
|
| case "t": |
|
| $output .= "\t"; |
|
| break; |
|
| case 'w': |
|
| $output .= Date_Calc::dayOfWeek($day,$month,$year); |
|
| break; |
|
| case 'U': |
|
| $output .= Date_Calc::weekOfYear($day,$month,$year); |
|
| break; |
|
| case 'y': |
|
| $output .= substr($year,2,2); |
|
| break; |
|
| case 'Y': |
|
| $output .= $year; |
|
| break; |
|
| case '%': |
|
| $output .= '%'; |
|
| break; |
|
| default: |
|
| $output .= $char.$nextchar; |
|
| } |
|
| $strpos++; |
|
| } else { |
|
| $output .= $char; |
|
| } |
|
| } |
} |
| return $output; |
$day = Date_Calc::daysInMonth($month, $year); |
| } // end func dateFormat |
return Date_Calc::dateFormat($day, $month, $year, $format); |
| |
} |
| /** |
|
| * Returns the current local year in format CCYY |
|
| * |
|
| * @access public |
|
| * |
|
| * @return string year in format CCYY |
|
| */ |
|
| |
|
| function getYear() |
|
| { |
|
| return Date_Calc::dateNow('%Y'); |
|
| } // end func getYear |
|
| |
|
| /** |
/** |
| * Returns the current local month in format MM |
* Returns date of begin of next month of given date |
| * |
* |
| * @access public |
* @param int $day the day of the month, default is current local day |
| |
* @param int $month the month, default is current local month |
| |
* @param int $year the year in four digit format, default is current local year |
| |
* @param string $format the string indicating how to format the output |
| * |
* |
| * @return string month in format MM |
* @return string the date in the desired format |
| */ |
|
| |
|
| function getMonth() |
|
| { |
|
| return Date_Calc::dateNow('%m'); |
|
| } // end func getMonth |
|
| |
|
| /** |
|
| * Returns the current local day in format DD |
|
| * |
* |
| * @access public |
* @access public |
| * |
* @static |
| * @return string day in format DD |
* @see Date_Calc::beginOfMonthBySpan() |
| |
* @deprecated Method deprecated in Release 1.5.0 |
| */ |
*/ |
| |
function beginOfNextMonth($day = 0, $month = 0, $year = 0, |
| function getDay() |
$format = DATE_CALC_FORMAT) |
| { |
{ |
| return Date_Calc::dateNow('%d'); |
if (empty($year)) { |
| } // end func getDay |
$year = Date_Calc::dateNow('%Y'); |
| |
} |
| |
if (empty($month)) { |
| |
$month = Date_Calc::dateNow('%m'); |
| |
} |
| |
if (empty($day)) { |
| |
$day = Date_Calc::dateNow('%d'); |
| |
} |
| |
if ($month < 12) { |
| |
$month++; |
| |
$day = 1; |
| |
} else { |
| |
$year++; |
| |
$month = 1; |
| |
$day = 1; |
| |
} |
| |
return Date_Calc::dateFormat($day, $month, $year, $format); |
| |
} |
| |
|
| /** |
/** |
| * Returns the full month name for the given month |
* Returns date of the last day of next month of given date |
| * |
* |
| * @param string month in format MM |
* @param int $day the day of the month, default is current local day |
| |
* @param int $month the month, default is current local month |
| |
* @param int $year the year in four digit format, default is current local year |
| |
* @param string $format the string indicating how to format the output |
| * |
* |
| * @access public |
* @return string the date in the desired format |
| * |
* |
| * @return string full month name |
* @access public |
| |
* @static |
| |
* @see Date_Calc::endOfMonthBySpan() |
| |
* @deprecated Method deprecated in Release 1.5.0 |
| */ |
*/ |
| |
function endOfNextMonth($day = 0, $month = 0, $year = 0, |
| function getMonthFullname($month) |
$format = DATE_CALC_FORMAT) |
| { |
{ |
| $month = (int)$month; |
if (empty($year)) { |
| |
$year = Date_Calc::dateNow('%Y'); |
| |
} |
| if (empty($month)) { |
if (empty($month)) { |
| $month = (int) Date_Calc::dateNow('%m'); |
$month = Date_Calc::dateNow('%m'); |
| } |
} |
| |
if (empty($day)) { |
| $month_names = Date_Calc::getMonthNames(); |
$day = Date_Calc::dateNow('%d'); |
| |
} |
| return $month_names[$month]; |
if ($month < 12) { |
| // getMonthNames returns months with correct indexes |
$month++; |
| //return $month_names[($month - 1)]; |
} else { |
| } // end func getMonthFullname |
$year++; |
| |
$month = 1; |
| |
} |
| |
$day = Date_Calc::daysInMonth($month, $year); |
| |
return Date_Calc::dateFormat($day, $month, $year, $format); |
| |
} |
| |
|
| /** |
/** |
| * Returns the abbreviated month name for the given month |
* Returns date of the first day of the month in the number of months |
| |
* from the given date |
| * |
* |
| * @param string month in format MM |
* @param int $months the number of months from the date provided. |
| * @param int optional length of abbreviation, default is 3 |
* Positive numbers go into the future. |
| |
* Negative numbers go into the past. |
| |
* 0 is the month presented in $month. |
| |
* @param string $month the month, default is current local month |
| |
* @param string $year the year in four digit format, default is the |
| |
* current local year |
| |
* @param string $format the string indicating how to format the output |
| * |
* |
| * @access public |
* @return string the date in the desired format |
| * |
* |
| * @return string abbreviated month name |
* @access public |
| * @see Date_Calc::getMonthFullname |
* @static |
| |
* @since Method available since Release 1.5.0 |
| */ |
*/ |
| |
function beginOfMonthBySpan($months = 0, $month = 0, $year = 0, |
| function getMonthAbbrname($month,$length=3) |
$format = DATE_CALC_FORMAT) |
| { |
{ |
| $month = (int)$month; |
if (empty($year)) { |
| |
$year = Date_Calc::dateNow('%Y'); |
| |
} |
| if (empty($month)) { |
if (empty($month)) { |
| $month = Date_Calc::dateNow('%m'); |
$month = Date_Calc::dateNow('%m'); |
| } |
} |
| |
if ($months > 0) { |
| return substr(Date_Calc::getMonthFullname($month), 0, $length); |
// future month |
| } // end func getMonthAbbrname |
$tmp_mo = $month + $months; |
| |
$month = $tmp_mo % 12; |
| |
if ($month == 0) { |
| |
$month = 12; |
| |
$year = $year + floor(($tmp_mo - 1) / 12); |
| |
} else { |
| |
$year = $year + floor($tmp_mo / 12); |
| |
} |
| |
} else { |
| |
// past or present month |
| |
$tmp_mo = $month + $months; |
| |
if ($tmp_mo > 0) { |
| |
// same year |
| |
$month = $tmp_mo; |
| |
} elseif ($tmp_mo == 0) { |
| |
// prior dec |
| |
$month = 12; |
| |
$year--; |
| |
} else { |
| |
// some time in a prior year |
| |
$month = 12 + ($tmp_mo % 12); |
| |
$year = $year + floor($tmp_mo / 12); |
| |
} |
| |
} |
| |
return Date_Calc::dateFormat(1, $month, $year, $format); |
| |
} |
| |
|
| /** |
/** |
| * Returns the full weekday name for the given date |
* Returns date of the last day of the month in the number of months |
| |
* from the given date |
| * |
* |
| * @param string day in format DD, default is current local day |
* @param int $months the number of months from the date provided. |
| * @param string month in format MM, default is current local month |
* Positive numbers go into the future. |
| * @param string year in format CCYY, default is current local year |
* Negative numbers go into the past. |
| |
* 0 is the month presented in $month. |
| |
* @param string $month the month, default is current local month |
| |
* @param string $year the year in four digit format, default is the |
| |
* current local year |
| |
* @param string $format the string indicating how to format the output |
| * |
* |
| * @access public |
* @return string the date in the desired format |
| * |
* |
| * @return string full month name |
* @access public |
| |
* @static |
| |
* @since Method available since Release 1.5.0 |
| */ |
*/ |
| |
function endOfMonthBySpan($months = 0, $month = 0, $year = 0, |
| function getWeekdayFullname($day='',$month='',$year='') |
$format = DATE_CALC_FORMAT) |
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
| Line 1520 class Date_Calc |
|
| Line 1631 class Date_Calc |
|
| if (empty($month)) { |
if (empty($month)) { |
| $month = Date_Calc::dateNow('%m'); |
$month = Date_Calc::dateNow('%m'); |
| } |
} |
| if (empty($day)) { |
if ($months > 0) { |
| $day = Date_Calc::dateNow('%d'); |
// future month |
| |
$tmp_mo = $month + $months; |
| |
$month = $tmp_mo % 12; |
| |
if ($month == 0) { |
| |
$month = 12; |
| |
$year = $year + floor(($tmp_mo - 1) / 12); |
| |
} else { |
| |
$year = $year + floor($tmp_mo / 12); |
| |
} |
| |
} else { |
| |
// past or present month |
| |
$tmp_mo = $month + $months; |
| |
if ($tmp_mo > 0) { |
| |
// same year |
| |
$month = $tmp_mo; |
| |
} elseif ($tmp_mo == 0) { |
| |
// prior dec |
| |
$month = 12; |
| |
$year--; |
| |
} else { |
| |
// some time in a prior year |
| |
$month = 12 + ($tmp_mo % 12); |
| |
$year = $year + floor($tmp_mo / 12); |
| |
} |
| } |
} |
| |
return Date_Calc::dateFormat(Date_Calc::daysInMonth($month, $year), |
| $weekday_names = Date_Calc::getWeekDays(); |
$month, $year, $format); |
| $weekday = Date_Calc::dayOfWeek($day,$month,$year); |
} |
| |
|
| return $weekday_names[$weekday]; |
|
| } // end func getWeekdayFullname |
|
| |
|
| /** |
/** |
| * Returns the abbreviated weekday name for the given date |
* Find the day of the week for the first of the month of given date |
| * |
* |
| * @param string day in format DD, default is current local day |
* @param int $month the month, default is current local month |
| * @param string month in format MM, default is current local month |
* @param int $year the year in four digit format, default is current local year |
| * @param string year in format CCYY, default is current local year |
|
| * @param int optional length of abbreviation, default is 3 |
|
| * |
* |
| * @access public |
* @return int number of weekday for the first day, 0=Sunday |
| * |
* |
| * @return string full month name |
* @access public |
| * @see Date_Calc::getWeekdayFullname |
* @static |
| */ |
*/ |
| |
function firstOfMonthWeekday($month = 0, $year = 0) |
| function getWeekdayAbbrname($day='',$month='',$year='',$length=3) |
|
| { |
{ |
| if (empty($year)) { |
if (empty($year)) { |
| $year = Date_Calc::dateNow('%Y'); |
$year = Date_Calc::dateNow('%Y'); |
| Line 1552 class Date_Calc |
|
| Line 1680 class Date_Calc |
|
| if (empty($month)) { |
if (empty($month)) { |
| $month = Date_Calc::dateNow('%m'); |
$month = Date_Calc::dateNow('%m'); |
| } |
} |
| if (empty($day)) { |
return Date_Calc::dayOfWeek('01', $month, $year); |
| $day = Date_Calc::dateNow('%d'); |
} |
| } |
|
| |
|
| return substr(Date_Calc::getWeekdayFullname($day,$month,$year),0,$length); |
|
| } // end func getWeekdayFullname |
|
| |
|
| /** |
/** |
| * Returns the numeric month from the month name or an abreviation |
* Calculates the date of the Nth weekday of the month, |
| * |
* such as the second Saturday of January 2000 |
| * Both August and Aug would return 8. |
* |
| * Month name is case insensitive. |
* @param int $week the number of the week to get |
| * |
* (1 = first, etc. Also can be 'last'.) |
| * @param string month name |
* @param int $dow the day of the week (0 = Sunday) |
| * @return integer month number |
* @param int $month the month |
| */ |
* @param int $year the year. Use the complete year instead of the |
| function getMonthFromFullName($month) |
* abbreviated version. E.g. use 2005, not 05. |
| { |
* Do not add leading 0's for years prior to 1000. |
| $month = strtolower($month); |
* @param string $format the string indicating how to format the output |
| $months = Date_Calc::getMonthNames(); |
* |
| while(list($id, $name) = each($months)) { |
* @return string the date in the desired format |
| if (ereg($month, strtolower($name))) { |
* |
| return($id); |
* @access public |
| |
* @static |
| |
*/ |
| |
function NWeekdayOfMonth($week, $dow, $month, $year, |
| |
$format = DATE_CALC_FORMAT) |
| |
{ |
| |
if (is_numeric($week)) { |
| |
$DOW1day = ($week - 1) * 7 + 1; |
| |
$DOW1 = Date_Calc::dayOfWeek($DOW1day, $month, $year); |
| |
$wdate = ($week - 1) * 7 + 1 + (7 + $dow - $DOW1) % 7; |
| |
if ($wdate > Date_Calc::daysInMonth($month, $year)) { |
| |
return -1; |
| |
} else { |
| |
return Date_Calc::dateFormat($wdate, $month, $year, $format); |
| |
} |
| |
} elseif ($week == 'last' && $dow < 7) { |
| |
$lastday = Date_Calc::daysInMonth($month, $year); |
| |
$lastdow = Date_Calc::dayOfWeek($lastday, $month, $year); |
| |
$diff = $dow - $lastdow; |
| |
if ($diff > 0) { |
| |
return Date_Calc::dateFormat($lastday - (7 - $diff), $month, |
| |
$year, $format); |
| |
} else { |
| |
return Date_Calc::dateFormat($lastday + $diff, $month, |
| |
$year, $format); |
| } |
} |
| |
} else { |
| |
return -1; |
| } |
} |
| |
} |
| return(0); |
|
| } // end func getMonthFromFullName |
|
| |
|
| /** |
/** |
| * Returns an array of month names |
* Returns true for valid date, false for invalid date |
| * |
* |
| * Used to take advantage of the setlocale function to return |
* @param int $day the day of the month |
| * language specific month names. |
* @param int $month the month |
| * XXX cache values to some global array to avoid preformace |
* @param int $year the year. Use the complete year instead of the |
| * hits when called more than once. |
* abbreviated version. E.g. use 2005, not 05. |
| * |
* Do not add leading 0's for years prior to 1000. |
| * @returns array An array of month names |
* |
| */ |
* @return boolean |
| function getMonthNames() |
* |
| |
* @access public |
| |
* @static |
| |
*/ |
| |
function isValidDate($day, $month, $year) |
| { |
{ |
| for($i=1;$i<13;$i++) { |
if ($year < 0 || $year > 9999) { |
| $months[$i] = strftime('%B', mktime(0, 0, 0, $i, 1, 2001)); |
return false; |
| } |
} |
| return($months); |
if (!checkdate($month, $day, $year)) { |
| } // end func getMonthNames |
return false; |
| |
|
| /** |
|
| * Returns an array of week days |
|
| * |
|
| * Used to take advantage of the setlocale function to |
|
| * return language specific week days |
|
| * XXX cache values to some global array to avoid preformace |
|
| * hits when called more than once. |
|
| * |
|
| * @returns array An array of week day names |
|
| */ |
|
| function getWeekDays() |
|
| { |
|
| for($i=0;$i<7;$i++) { |
|
| $weekdays[$i] = strftime('%A', mktime(0, 0, 0, 1, $i, 2001)); |
|
| } |
} |
| return($weekdays); |
return true; |
| } // end func getWeekDays |
} |
| |
|
| /** |
/** |
| * Converts from Gregorian Year-Month-Day to |
* Returns true for a leap year, else false |
| * ISO YearNumber-WeekNumber-WeekDay |
|
| * |
* |
| * Uses ISO 8601 definitions. |
* @param int $year the year. Use the complete year instead of the |
| * Algorithm from Rick McCarty, 1999 at |
* abbreviated version. E.g. use 2005, not 05. |
| * http://personal.ecu.edu/mccartyr/ISOwdALG.txt |
* Do not add leading 0's for years prior to 1000. |
| |
* |
| |
* @return boolean |
| * |
* |
| * @param string day in format DD |
|
| * @param string month in format MM |
|
| * @param string year in format CCYY |
|
| * @return string |
|
| * @access public |
* @access public |
| |
* @static |
| */ |
*/ |
| // Transcribed to PHP by Jesus M. Castagnetto (blame him if it is fubared ;-) |
function isLeapYear($year = 0) |
| function gregorianToISO($day,$month,$year) { |
{ |
| $mnth = array (0,31,59,90,120,151,181,212,243,273,304,334); |
if (empty($year)) { |
| $y_isleap = Date_Calc::isLeapYear($year); |
$year = Date_Calc::dateNow('%Y'); |
| $y_1_isleap = Date_Calc::isLeapYear($year - 1); |
|
| $day_of_year_number = $day + $mnth[$month - 1]; |
|
| if ($y_isleap && $month > 2) { |
|
| $day_of_year_number++; |
|
| } |
} |
| // find Jan 1 weekday (monday = 1, sunday = 7) |
if (preg_match('/\D/', $year)) { |
| $yy = ($year - 1) % 100; |
return false; |
| $c = ($year - 1) - $yy; |
|
| $g = $yy + intval($yy/4); |
|
| $jan1_weekday = 1 + intval((((($c / 100) % 4) * 5) + $g) % 7); |
|
| // weekday for year-month-day |
|
| $h = $day_of_year_number + ($jan1_weekday - 1); |
|
| $weekday = 1 + intval(($h - 1) % 7); |
|
| // find if Y M D falls in YearNumber Y-1, WeekNumber 52 or |
|
| if ($day_of_year_number <= (8 - $jan1_weekday) && $jan1_weekday > 4){ |
|
| $yearnumber = $year - 1; |
|
| if ($jan1_weekday == 5 || ($jan1_weekday == 6 && $y_1_isleap)) { |
|
| $weeknumber = 53; |
|
| } else { |
|
| $weeknumber = 52; |
|
| } |
|
| } else { |
|
| $yearnumber = $year; |
|
| } |
} |
| // find if Y M D falls in YearNumber Y+1, WeekNumber 1 |
if ($year < 1000) { |
| if ($yearnumber == $year) { |
return false; |
| if ($y_isleap) { |
|
| $i = 366; |
|
| } else { |
|
| $i = 365; |
|
| } |
|
| if (($i - $day_of_year_number) < (4 - $weekday)) { |
|
| $yearnumber++; |
|
| $weeknumber = 1; |
|
| } |
|
| } |
} |
| // find if Y M D falls in YearNumber Y, WeekNumber 1 through 53 |
if ($year < 1582) { |
| if ($yearnumber == $year) { |
// pre Gregorio XIII - 1582 |
| $j = $day_of_year_number + (7 - $weekday) + ($jan1_weekday - 1); |
return ($year % 4 == 0); |
| $weeknumber = intval($j / 7); |
} else { |
| if ($jan1_weekday > 4) { |
// post Gregorio XIII - 1582 |
| $weeknumber--; |
return (($year % 4 == 0) && ($year % 100 != 0)) || ($year % 400 == 0); |
| |
} |
| |
} |
| |
|
| |
/** |
| |
* Determines if given date is a future date from now |
| |
* |
| |
* @param int $day the day of the month |
| |
* @param int $month the month |
| |
* @param int $year the year. Use the complete year instead of the |
| |
* abbreviated version. E.g. use 2005, not 05. |
| |
* Do not add leading 0's for years prior to 1000. |
| |
* |
| |
* @return boolean |
| |
* |
| |
* @access public |
| |
* @static |
| |
*/ |
| |
function isFutureDate($day, $month, $year) |
| |
{ |
| |
$this_year = Date_Calc::dateNow('%Y'); |
| |
$this_month = Date_Calc::dateNow('%m'); |
| |
$this_day = Date_Calc::dateNow('%d'); |
| |
|
| |
if ($year > $this_year) { |
| |
return true; |
| |
} elseif ($year == $this_year) { |
| |
if ($month > $this_month) { |
| |
return true; |
| |
} elseif ($month == $this_month) { |
| |
if ($day > $this_day) { |
| |
return true; |
| |
} |
| } |
} |
| } |
} |
| // put it all together |
return false; |
| if ($weeknumber < 10) |
|
| $weeknumber = '0'.$weeknumber; |
|
| return "{$yearnumber}-{$weeknumber}-{$weekday}"; |
|
| } |
} |
| |
|
| /** |
/** |
| * Determines julian date of the given season |
* Determines if given date is a past date from now |
| * Adapted from previous work in Java by James Mark Hamilton, mhamilton@qwest.net |
* |
| * |
* @param int $day the day of the month |
| * @author Robert Butler <rob@maxwellcreek.org> |
* @param int $month the month |
| * |
* @param int $year the year. Use the complete year instead of the |
| * @param string is VERNALEQUINOX, SUMMERSOLSTICE, AUTUMNALEQUINOX, or WINTERSOLSTICE. |
* abbreviated version. E.g. use 2005, not 05. |
| * @param string year in format CCYY, must be a calendar year between -1000BC and 3000AD. |
* Do not add leading 0's for years prior to 1000. |
| * |
* |
| * @access public |
* @return boolean |
| * |
* |
| * @return float $juliandate |
* @access public |
| */ |
* @static |
| |
*/ |
| function dateSeason ($season, $year = '') { |
function isPastDate($day, $month, $year) |
| if ($year == '') { |
{ |
| $year = Date_Calc::dateNow('%Y'); |
$this_year = Date_Calc::dateNow('%Y'); |
| } |
$this_month = Date_Calc::dateNow('%m'); |
| |
$this_day = Date_Calc::dateNow('%d'); |
| if (($year >= -1000) && ($year <= 1000)) { |
|
| $y = $year / 1000.0; |
if ($year < $this_year) { |
| if ($season == 'VERNALEQUINOX') { |
return true; |
| $juliandate = (((((((-0.00071 * $y) - 0.00111) * $y) + 0.06134) * $y) + 365242.1374) * $y) + 1721139.29189; |
} elseif ($year == $this_year) { |
| } else if ($season == 'SUMMERSOLSTICE') { |
if ($month < $this_month) { |
| $juliandate = ((((((( 0.00025 * $y) + 0.00907) * $y) - 0.05323) * $y) + 365241.72562) * $y) + 1721233.25401; |
return true; |
| } else if ($season == 'AUTUMNALEQUINOX') { |
} elseif ($month == $this_month) { |
| $juliandate = ((((((( 0.00074 * $y) - 0.00297) * $y) - 0.11677) * $y) + 365242.49558) * $y) + 1721325.70455; |
if ($day < $this_day) { |
| } else if ($season == 'WINTERSOLSTICE') { |
return true; |
| $juliandate = (((((((-0.00006 * $y) - 0.00933) * $y) - 0.00769) * $y) + 365242.88257) * $y) + 1721414.39987; |
} |
| } |
|
| } elseif (($year > 1000) && ($year <= 3000)) { |
|
| $y = ($year - 2000) / 1000; |
|
| if ($season == 'VERNALEQUINOX') { |
|
| $juliandate = (((((((-0.00057 * $y) - 0.00411) * $y) + 0.05169) * $y) + 365242.37404) * $y) + 2451623.80984; |
|
| } else if ($season == 'SUMMERSOLSTICE') { |
|
| $juliandate = (((((((-0.0003 * $y) + 0.00888) * $y) + 0.00325) * $y) + 365241.62603) * $y) + 2451716.56767; |
|
| } else if ($season == 'AUTUMNALEQUINOX') { |
|
| $juliandate = ((((((( 0.00078 * $y) + 0.00337) * $y) - 0.11575) * $y) + 365242.01767) * $y) + 2451810.21715; |
|
| } else if ($season == 'WINTERSOLSTICE') { |
|
| $juliandate = ((((((( 0.00032 * $y) - 0.00823) * $y) - 0.06223) * $y) + 365242.74049) * $y) + 2451900.05952; |
|
| } |
|
| } |
} |
| |
} |
| |
return false; |
| |
} |
| |
|
| return ($juliandate); |
/** |
| } // end func dateSeason |
* Returns number of days between two given dates |
| |
* |
| |
* @param int $day1 the day of the month |
| |
* @param int $month1 the month |
| |
* @param int $year1 the year. Use the complete year instead of the |
| |
* abbreviated version. E.g. use 2005, not 05. |
| |
* Do not add leading 0's for years prior to 1000. |
| |
* @param int $day2 the day of the month |
| |
* @param int $month2 the month |
| |
* @param int $year2 the year. Use the complete year instead of the |
| |
* abbreviated version. E.g. use 2005, not 05. |
| |
* Do not add leading 0's for years prior to 1000. |
| |
* |
| |
* @return int the absolute number of days between the two dates. |
| |
* If an error occurs, -1 is returned. |
| |
* |
| |
* @access public |
| |
* @static |
| |
*/ |
| |
function dateDiff($day1, $month1, $year1, $day2, $month2, $year2) |
| |
{ |
| |
if (!Date_Calc::isValidDate($day1, $month1, $year1)) { |
| |
return -1; |
| |
} |
| |
if (!Date_Calc::isValidDate($day2, $month2, $year2)) { |
| |
return -1; |
| |
} |
| |
return abs(Date_Calc::dateToDays($day1, $month1, $year1) |
| |
- Date_Calc::dateToDays($day2, $month2, $year2)); |
| |
} |
| |
|
| } // end class Date_Calc |
/** |
| |
* Compares two dates |
| |
* |
| |
* @param int $day1 the day of the month |
| |
* @param int $month1 the month |
| |
* @param int $year1 the year. Use the complete year instead of the |
| |
* abbreviated version. E.g. use 2005, not 05. |
| |
* Do not add leading 0's for years prior to 1000. |
| |
* @param int $day2 the day of the month |
| |
* @param int $month2 the month |
| |
* @param int $year2 the year. Use the complete year instead of the |
| |
* abbreviated version. E.g. use 2005, not 05. |
| |
* Do not add leading 0's for years prior to 1000. |
| |
* |
| |
* @return int 0 if the dates are equal. 1 if date 1 is later, -1 if |
| |
* date 1 is earlier. |
| |
* |
| |
* @access public |
| |
* @static |
| |
*/ |
| |
function compareDates($day1, $month1, $year1, $day2, $month2, $year2) |
| |
{ |
| |
$ndays1 = Date_Calc::dateToDays($day1, $month1, $year1); |
| |
$ndays2 = Date_Calc::dateToDays($day2, $month2, $year2); |
| |
if ($ndays1 == $ndays2) { |
| |
return 0; |
| |
} |
| |
return ($ndays1 > $ndays2) ? 1 : -1; |
| |
} |
| |
} |
| |
|
| ?> |
?> |
Login
Registration
Slovak
![[BACK]](http://cvsweb.platon.sk/icons/back.gif){kind=icon}
![[TXT]](http://cvsweb.platon.sk/icons/text.gif){kind=icon}
![[DIR]](http://cvsweb.platon.sk/icons/dir.gif){kind=icon}
Up to