Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

DateTime.php @ 1

Last change on this file since 1 was 1, checked in by dungnv, 11 years ago

File size: 54.4 KB

Rev	Line
[1]	1	<?php
	2	/**
	3	* PHPExcel
	4	*
	5	* Copyright (c) 2006 - 2014 PHPExcel
	6	*
	7	* This library is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; either
	10	* version 2.1 of the License, or (at your option) any later version.
	11	*
	12	* This library is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with this library; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	*
	21	* @category PHPExcel
	22	* @package PHPExcel_Calculation
	23	* @copyright Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
	24	* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
	25	* @version 1.8.0, 2014-03-02
	26	*/
	27
	28
	29	/** PHPExcel root directory */
	30	if (!defined('PHPEXCEL_ROOT')) {
	31	/**
	32	* @ignore
	33	*/
	34	define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
	35	require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
	36	}
	37
	38
	39	/**
	40	* PHPExcel_Calculation_DateTime
	41	*
	42	* @category PHPExcel
	43	* @package PHPExcel_Calculation
	44	* @copyright Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
	45	*/
	46	class PHPExcel_Calculation_DateTime {
	47
	48	/**
	49	* Identify if a year is a leap year or not
	50	*
	51	* @param integer $year The year to test
	52	* @return boolean TRUE if the year is a leap year, otherwise FALSE
	53	*/
	54	public static function _isLeapYear($year) {
	55	return ((($year % 4) == 0) && (($year % 100) != 0) \|\| (($year % 400) == 0));
	56	} // function _isLeapYear()
	57
	58
	59	/**
	60	* Return the number of days between two dates based on a 360 day calendar
	61	*
	62	* @param integer $startDay Day of month of the start date
	63	* @param integer $startMonth Month of the start date
	64	* @param integer $startYear Year of the start date
	65	* @param integer $endDay Day of month of the start date
	66	* @param integer $endMonth Month of the start date
	67	* @param integer $endYear Year of the start date
	68	* @param boolean $methodUS Whether to use the US method or the European method of calculation
	69	* @return integer Number of days between the start date and the end date
	70	*/
	71	private static function _dateDiff360($startDay, $startMonth, $startYear, $endDay, $endMonth, $endYear, $methodUS) {
	72	if ($startDay == 31) {
	73	--$startDay;
	74	} elseif ($methodUS && ($startMonth == 2 && ($startDay == 29 \|\| ($startDay == 28 && !self::_isLeapYear($startYear))))) {
	75	$startDay = 30;
	76	}
	77	if ($endDay == 31) {
	78	if ($methodUS && $startDay != 30) {
	79	$endDay = 1;
	80	if ($endMonth == 12) {
	81	++$endYear;
	82	$endMonth = 1;
	83	} else {
	84	++$endMonth;
	85	}
	86	} else {
	87	$endDay = 30;
	88	}
	89	}
	90
	91	return $endDay + $endMonth * 30 + $endYear * 360 - $startDay - $startMonth * 30 - $startYear * 360;
	92	} // function _dateDiff360()
	93
	94
	95	/**
	96	* _getDateValue
	97	*
	98	* @param string $dateValue
	99	* @return mixed Excel date/time serial value, or string if error
	100	*/
	101	public static function _getDateValue($dateValue) {
	102	if (!is_numeric($dateValue)) {
	103	if ((is_string($dateValue)) &&
	104	(PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC)) {
	105	return PHPExcel_Calculation_Functions::VALUE();
	106	}
	107	if ((is_object($dateValue)) && ($dateValue instanceof DateTime)) {
	108	$dateValue = PHPExcel_Shared_Date::PHPToExcel($dateValue);
	109	} else {
	110	$saveReturnDateType = PHPExcel_Calculation_Functions::getReturnDateType();
	111	PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
	112	$dateValue = self::DATEVALUE($dateValue);
	113	PHPExcel_Calculation_Functions::setReturnDateType($saveReturnDateType);
	114	}
	115	}
	116	return $dateValue;
	117	} // function _getDateValue()
	118
	119
	120	/**
	121	* _getTimeValue
	122	*
	123	* @param string $timeValue
	124	* @return mixed Excel date/time serial value, or string if error
	125	*/
	126	private static function _getTimeValue($timeValue) {
	127	$saveReturnDateType = PHPExcel_Calculation_Functions::getReturnDateType();
	128	PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
	129	$timeValue = self::TIMEVALUE($timeValue);
	130	PHPExcel_Calculation_Functions::setReturnDateType($saveReturnDateType);
	131	return $timeValue;
	132	} // function _getTimeValue()
	133
	134
	135	private static function _adjustDateByMonths($dateValue = 0, $adjustmentMonths = 0) {
	136	// Execute function
	137	$PHPDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($dateValue);
	138	$oMonth = (int) $PHPDateObject->format('m');
	139	$oYear = (int) $PHPDateObject->format('Y');
	140
	141	$adjustmentMonthsString = (string) $adjustmentMonths;
	142	if ($adjustmentMonths > 0) {
	143	$adjustmentMonthsString = '+'.$adjustmentMonths;
	144	}
	145	if ($adjustmentMonths != 0) {
	146	$PHPDateObject->modify($adjustmentMonthsString.' months');
	147	}
	148	$nMonth = (int) $PHPDateObject->format('m');
	149	$nYear = (int) $PHPDateObject->format('Y');
	150
	151	$monthDiff = ($nMonth - $oMonth) + (($nYear - $oYear) * 12);
	152	if ($monthDiff != $adjustmentMonths) {
	153	$adjustDays = (int) $PHPDateObject->format('d');
	154	$adjustDaysString = '-'.$adjustDays.' days';
	155	$PHPDateObject->modify($adjustDaysString);
	156	}
	157	return $PHPDateObject;
	158	} // function _adjustDateByMonths()
	159
	160
	161	/**
	162	* DATETIMENOW
	163	*
	164	* Returns the current date and time.
	165	* The NOW function is useful when you need to display the current date and time on a worksheet or
	166	* calculate a value based on the current date and time, and have that value updated each time you
	167	* open the worksheet.
	168	*
	169	* NOTE: When used in a Cell Formula, MS Excel changes the cell format so that it matches the date
	170	* and time format of your regional settings. PHPExcel does not change cell formatting in this way.
	171	*
	172	* Excel Function:
	173	* NOW()
	174	*
	175	* @access public
	176	* @category Date/Time Functions
	177	* @return mixed Excel date/time serial value, PHP date/time serial value or PHP date/time object,
	178	* depending on the value of the ReturnDateType flag
	179	*/
	180	public static function DATETIMENOW() {
	181	$saveTimeZone = date_default_timezone_get();
	182	date_default_timezone_set('UTC');
	183	$retValue = False;
	184	switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
	185	case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL :
	186	$retValue = (float) PHPExcel_Shared_Date::PHPToExcel(time());
	187	break;
	188	case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC :
	189	$retValue = (integer) time();
	190	break;
	191	case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT :
	192	$retValue = new DateTime();
	193	break;
	194	}
	195	date_default_timezone_set($saveTimeZone);
	196
	197	return $retValue;
	198	} // function DATETIMENOW()
	199
	200
	201	/**
	202	* DATENOW
	203	*
	204	* Returns the current date.
	205	* The NOW function is useful when you need to display the current date and time on a worksheet or
	206	* calculate a value based on the current date and time, and have that value updated each time you
	207	* open the worksheet.
	208	*
	209	* NOTE: When used in a Cell Formula, MS Excel changes the cell format so that it matches the date
	210	* and time format of your regional settings. PHPExcel does not change cell formatting in this way.
	211	*
	212	* Excel Function:
	213	* TODAY()
	214	*
	215	* @access public
	216	* @category Date/Time Functions
	217	* @return mixed Excel date/time serial value, PHP date/time serial value or PHP date/time object,
	218	* depending on the value of the ReturnDateType flag
	219	*/
	220	public static function DATENOW() {
	221	$saveTimeZone = date_default_timezone_get();
	222	date_default_timezone_set('UTC');
	223	$retValue = False;
	224	$excelDateTime = floor(PHPExcel_Shared_Date::PHPToExcel(time()));
	225	switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
	226	case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL :
	227	$retValue = (float) $excelDateTime;
	228	break;
	229	case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC :
	230	$retValue = (integer) PHPExcel_Shared_Date::ExcelToPHP($excelDateTime);
	231	break;
	232	case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT :
	233	$retValue = PHPExcel_Shared_Date::ExcelToPHPObject($excelDateTime);
	234	break;
	235	}
	236	date_default_timezone_set($saveTimeZone);
	237
	238	return $retValue;
	239	} // function DATENOW()
	240
	241
	242	/**
	243	* DATE
	244	*
	245	* The DATE function returns a value that represents a particular date.
	246	*
	247	* NOTE: When used in a Cell Formula, MS Excel changes the cell format so that it matches the date
	248	* format of your regional settings. PHPExcel does not change cell formatting in this way.
	249	*
	250	* Excel Function:
	251	* DATE(year,month,day)
	252	*
	253	* PHPExcel is a lot more forgiving than MS Excel when passing non numeric values to this function.
	254	* A Month name or abbreviation (English only at this point) such as 'January' or 'Jan' will still be accepted,
	255	* as will a day value with a suffix (e.g. '21st' rather than simply 21); again only English language.
	256	*
	257	* @access public
	258	* @category Date/Time Functions
	259	* @param integer $year The value of the year argument can include one to four digits.
	260	* Excel interprets the year argument according to the configured
	261	* date system: 1900 or 1904.
	262	* If year is between 0 (zero) and 1899 (inclusive), Excel adds that
	263	* value to 1900 to calculate the year. For example, DATE(108,1,2)
	264	* returns January 2, 2008 (1900+108).
	265	* If year is between 1900 and 9999 (inclusive), Excel uses that
	266	* value as the year. For example, DATE(2008,1,2) returns January 2,
	267	* 2008.
	268	* If year is less than 0 or is 10000 or greater, Excel returns the
	269	* #NUM! error value.
	270	* @param integer $month A positive or negative integer representing the month of the year
	271	* from 1 to 12 (January to December).
	272	* If month is greater than 12, month adds that number of months to
	273	* the first month in the year specified. For example, DATE(2008,14,2)
	274	* returns the serial number representing February 2, 2009.
	275	* If month is less than 1, month subtracts the magnitude of that
	276	* number of months, plus 1, from the first month in the year
	277	* specified. For example, DATE(2008,-3,2) returns the serial number
	278	* representing September 2, 2007.
	279	* @param integer $day A positive or negative integer representing the day of the month
	280	* from 1 to 31.
	281	* If day is greater than the number of days in the month specified,
	282	* day adds that number of days to the first day in the month. For
	283	* example, DATE(2008,1,35) returns the serial number representing
	284	* February 4, 2008.
	285	* If day is less than 1, day subtracts the magnitude that number of
	286	* days, plus one, from the first day of the month specified. For
	287	* example, DATE(2008,1,-15) returns the serial number representing
	288	* December 16, 2007.
	289	* @return mixed Excel date/time serial value, PHP date/time serial value or PHP date/time object,
	290	* depending on the value of the ReturnDateType flag
	291	*/
	292	public static function DATE($year = 0, $month = 1, $day = 1) {
	293	$year = PHPExcel_Calculation_Functions::flattenSingleValue($year);
	294	$month = PHPExcel_Calculation_Functions::flattenSingleValue($month);
	295	$day = PHPExcel_Calculation_Functions::flattenSingleValue($day);
	296
	297	if (($month !== NULL) && (!is_numeric($month))) {
	298	$month = PHPExcel_Shared_Date::monthStringToNumber($month);
	299	}
	300
	301	if (($day !== NULL) && (!is_numeric($day))) {
	302	$day = PHPExcel_Shared_Date::dayStringToNumber($day);
	303	}
	304
	305	$year = ($year !== NULL) ? PHPExcel_Shared_String::testStringAsNumeric($year) : 0;
	306	$month = ($month !== NULL) ? PHPExcel_Shared_String::testStringAsNumeric($month) : 0;
	307	$day = ($day !== NULL) ? PHPExcel_Shared_String::testStringAsNumeric($day) : 0;
	308	if ((!is_numeric($year)) \|\|
	309	(!is_numeric($month)) \|\|
	310	(!is_numeric($day))) {
	311	return PHPExcel_Calculation_Functions::VALUE();
	312	}
	313	$year = (integer) $year;
	314	$month = (integer) $month;
	315	$day = (integer) $day;
	316
	317	$baseYear = PHPExcel_Shared_Date::getExcelCalendar();
	318	// Validate parameters
	319	if ($year < ($baseYear-1900)) {
	320	return PHPExcel_Calculation_Functions::NaN();
	321	}
	322	if ((($baseYear-1900) != 0) && ($year < $baseYear) && ($year >= 1900)) {
	323	return PHPExcel_Calculation_Functions::NaN();
	324	}
	325
	326	if (($year < $baseYear) && ($year >= ($baseYear-1900))) {
	327	$year += 1900;
	328	}
	329
	330	if ($month < 1) {
	331	// Handle year/month adjustment if month < 1
	332	--$month;
	333	$year += ceil($month / 12) - 1;
	334	$month = 13 - abs($month % 12);
	335	} elseif ($month > 12) {
	336	// Handle year/month adjustment if month > 12
	337	$year += floor($month / 12);
	338	$month = ($month % 12);
	339	}
	340
	341	// Re-validate the year parameter after adjustments
	342	if (($year < $baseYear) \|\| ($year >= 10000)) {
	343	return PHPExcel_Calculation_Functions::NaN();
	344	}
	345
	346	// Execute function
	347	$excelDateValue = PHPExcel_Shared_Date::FormattedPHPToExcel($year, $month, $day);
	348	switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
	349	case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL :
	350	return (float) $excelDateValue;
	351	case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC :
	352	return (integer) PHPExcel_Shared_Date::ExcelToPHP($excelDateValue);
	353	case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT :
	354	return PHPExcel_Shared_Date::ExcelToPHPObject($excelDateValue);
	355	}
	356	} // function DATE()
	357
	358
	359	/**
	360	* TIME
	361	*
	362	* The TIME function returns a value that represents a particular time.
	363	*
	364	* NOTE: When used in a Cell Formula, MS Excel changes the cell format so that it matches the time
	365	* format of your regional settings. PHPExcel does not change cell formatting in this way.
	366	*
	367	* Excel Function:
	368	* TIME(hour,minute,second)
	369	*
	370	* @access public
	371	* @category Date/Time Functions
	372	* @param integer $hour A number from 0 (zero) to 32767 representing the hour.
	373	* Any value greater than 23 will be divided by 24 and the remainder
	374	* will be treated as the hour value. For example, TIME(27,0,0) =
	375	* TIME(3,0,0) = .125 or 3:00 AM.
	376	* @param integer $minute A number from 0 to 32767 representing the minute.
	377	* Any value greater than 59 will be converted to hours and minutes.
	378	* For example, TIME(0,750,0) = TIME(12,30,0) = .520833 or 12:30 PM.
	379	* @param integer $second A number from 0 to 32767 representing the second.
	380	* Any value greater than 59 will be converted to hours, minutes,
	381	* and seconds. For example, TIME(0,0,2000) = TIME(0,33,22) = .023148
	382	* or 12:33:20 AM
	383	* @return mixed Excel date/time serial value, PHP date/time serial value or PHP date/time object,
	384	* depending on the value of the ReturnDateType flag
	385	*/
	386	public static function TIME($hour = 0, $minute = 0, $second = 0) {
	387	$hour = PHPExcel_Calculation_Functions::flattenSingleValue($hour);
	388	$minute = PHPExcel_Calculation_Functions::flattenSingleValue($minute);
	389	$second = PHPExcel_Calculation_Functions::flattenSingleValue($second);
	390
	391	if ($hour == '') { $hour = 0; }
	392	if ($minute == '') { $minute = 0; }
	393	if ($second == '') { $second = 0; }
	394
	395	if ((!is_numeric($hour)) \|\| (!is_numeric($minute)) \|\| (!is_numeric($second))) {
	396	return PHPExcel_Calculation_Functions::VALUE();
	397	}
	398	$hour = (integer) $hour;
	399	$minute = (integer) $minute;
	400	$second = (integer) $second;
	401
	402	if ($second < 0) {
	403	$minute += floor($second / 60);
	404	$second = 60 - abs($second % 60);
	405	if ($second == 60) { $second = 0; }
	406	} elseif ($second >= 60) {
	407	$minute += floor($second / 60);
	408	$second = $second % 60;
	409	}
	410	if ($minute < 0) {
	411	$hour += floor($minute / 60);
	412	$minute = 60 - abs($minute % 60);
	413	if ($minute == 60) { $minute = 0; }
	414	} elseif ($minute >= 60) {
	415	$hour += floor($minute / 60);
	416	$minute = $minute % 60;
	417	}
	418
	419	if ($hour > 23) {
	420	$hour = $hour % 24;
	421	} elseif ($hour < 0) {
	422	return PHPExcel_Calculation_Functions::NaN();
	423	}
	424
	425	// Execute function
	426	switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
	427	case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL :
	428	$date = 0;
	429	$calendar = PHPExcel_Shared_Date::getExcelCalendar();
	430	if ($calendar != PHPExcel_Shared_Date::CALENDAR_WINDOWS_1900) {
	431	$date = 1;
	432	}
	433	return (float) PHPExcel_Shared_Date::FormattedPHPToExcel($calendar, 1, $date, $hour, $minute, $second);
	434	case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC :
	435	return (integer) PHPExcel_Shared_Date::ExcelToPHP(PHPExcel_Shared_Date::FormattedPHPToExcel(1970, 1, 1, $hour, $minute, $second)); // -2147468400; // -2147472000 + 3600
	436	case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT :
	437	$dayAdjust = 0;
	438	if ($hour < 0) {
	439	$dayAdjust = floor($hour / 24);
	440	$hour = 24 - abs($hour % 24);
	441	if ($hour == 24) { $hour = 0; }
	442	} elseif ($hour >= 24) {
	443	$dayAdjust = floor($hour / 24);
	444	$hour = $hour % 24;
	445	}
	446	$phpDateObject = new DateTime('1900-01-01 '.$hour.':'.$minute.':'.$second);
	447	if ($dayAdjust != 0) {
	448	$phpDateObject->modify($dayAdjust.' days');
	449	}
	450	return $phpDateObject;
	451	}
	452	} // function TIME()
	453
	454
	455	/**
	456	* DATEVALUE
	457	*
	458	* Returns a value that represents a particular date.
	459	* Use DATEVALUE to convert a date represented by a text string to an Excel or PHP date/time stamp
	460	* value.
	461	*
	462	* NOTE: When used in a Cell Formula, MS Excel changes the cell format so that it matches the date
	463	* format of your regional settings. PHPExcel does not change cell formatting in this way.
	464	*
	465	* Excel Function:
	466	* DATEVALUE(dateValue)
	467	*
	468	* @access public
	469	* @category Date/Time Functions
	470	* @param string $dateValue Text that represents a date in a Microsoft Excel date format.
	471	* For example, "1/30/2008" or "30-Jan-2008" are text strings within
	472	* quotation marks that represent dates. Using the default date
	473	* system in Excel for Windows, date_text must represent a date from
	474	* January 1, 1900, to December 31, 9999. Using the default date
	475	* system in Excel for the Macintosh, date_text must represent a date
	476	* from January 1, 1904, to December 31, 9999. DATEVALUE returns the
	477	* #VALUE! error value if date_text is out of this range.
	478	* @return mixed Excel date/time serial value, PHP date/time serial value or PHP date/time object,
	479	* depending on the value of the ReturnDateType flag
	480	*/
	481	public static function DATEVALUE($dateValue = 1) {
	482	$dateValue = trim(PHPExcel_Calculation_Functions::flattenSingleValue($dateValue),'"');
	483	// Strip any ordinals because they're allowed in Excel (English only)
	484	$dateValue = preg_replace('/(\d)(st\|nd\|rd\|th)([ -\/])/Ui','$1$3',$dateValue);
	485	// Convert separators (/ . or space) to hyphens (should also handle dot used for ordinals in some countries, e.g. Denmark, Germany)
	486	$dateValue = str_replace(array('/','.','-',' '),array(' ',' ',' ',' '),$dateValue);
	487
	488	$yearFound = false;
	489	$t1 = explode(' ',$dateValue);
	490	foreach($t1 as &$t) {
	491	if ((is_numeric($t)) && ($t > 31)) {
	492	if ($yearFound) {
	493	return PHPExcel_Calculation_Functions::VALUE();
	494	} else {
	495	if ($t < 100) { $t += 1900; }
	496	$yearFound = true;
	497	}
	498	}
	499	}
	500	if ((count($t1) == 1) && (strpos($t,':') != false)) {
	501	// We've been fed a time value without any date
	502	return 0.0;
	503	} elseif (count($t1) == 2) {
	504	// We only have two parts of the date: either day/month or month/year
	505	if ($yearFound) {
	506	array_unshift($t1,1);
	507	} else {
	508	array_push($t1,date('Y'));
	509	}
	510	}
	511	unset($t);
	512	$dateValue = implode(' ',$t1);
	513
	514	$PHPDateArray = date_parse($dateValue);
	515	if (($PHPDateArray === False) \|\| ($PHPDateArray['error_count'] > 0)) {
	516	$testVal1 = strtok($dateValue,'- ');
	517	if ($testVal1 !== False) {
	518	$testVal2 = strtok('- ');
	519	if ($testVal2 !== False) {
	520	$testVal3 = strtok('- ');
	521	if ($testVal3 === False) {
	522	$testVal3 = strftime('%Y');
	523	}
	524	} else {
	525	return PHPExcel_Calculation_Functions::VALUE();
	526	}
	527	} else {
	528	return PHPExcel_Calculation_Functions::VALUE();
	529	}
	530	$PHPDateArray = date_parse($testVal1.'-'.$testVal2.'-'.$testVal3);
	531	if (($PHPDateArray === False) \|\| ($PHPDateArray['error_count'] > 0)) {
	532	$PHPDateArray = date_parse($testVal2.'-'.$testVal1.'-'.$testVal3);
	533	if (($PHPDateArray === False) \|\| ($PHPDateArray['error_count'] > 0)) {
	534	return PHPExcel_Calculation_Functions::VALUE();
	535	}
	536	}
	537	}
	538
	539	if (($PHPDateArray !== False) && ($PHPDateArray['error_count'] == 0)) {
	540	// Execute function
	541	if ($PHPDateArray['year'] == '') { $PHPDateArray['year'] = strftime('%Y'); }
	542	if ($PHPDateArray['year'] < 1900)
	543	return PHPExcel_Calculation_Functions::VALUE();
	544	if ($PHPDateArray['month'] == '') { $PHPDateArray['month'] = strftime('%m'); }
	545	if ($PHPDateArray['day'] == '') { $PHPDateArray['day'] = strftime('%d'); }
	546	$excelDateValue = floor(PHPExcel_Shared_Date::FormattedPHPToExcel($PHPDateArray['year'],$PHPDateArray['month'],$PHPDateArray['day'],$PHPDateArray['hour'],$PHPDateArray['minute'],$PHPDateArray['second']));
	547
	548	switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
	549	case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL :
	550	return (float) $excelDateValue;
	551	case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC :
	552	return (integer) PHPExcel_Shared_Date::ExcelToPHP($excelDateValue);
	553	case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT :
	554	return new DateTime($PHPDateArray['year'].'-'.$PHPDateArray['month'].'-'.$PHPDateArray['day'].' 00:00:00');
	555	}
	556	}
	557	return PHPExcel_Calculation_Functions::VALUE();
	558	} // function DATEVALUE()
	559
	560
	561	/**
	562	* TIMEVALUE
	563	*
	564	* Returns a value that represents a particular time.
	565	* Use TIMEVALUE to convert a time represented by a text string to an Excel or PHP date/time stamp
	566	* value.
	567	*
	568	* NOTE: When used in a Cell Formula, MS Excel changes the cell format so that it matches the time
	569	* format of your regional settings. PHPExcel does not change cell formatting in this way.
	570	*
	571	* Excel Function:
	572	* TIMEVALUE(timeValue)
	573	*
	574	* @access public
	575	* @category Date/Time Functions
	576	* @param string $timeValue A text string that represents a time in any one of the Microsoft
	577	* Excel time formats; for example, "6:45 PM" and "18:45" text strings
	578	* within quotation marks that represent time.
	579	* Date information in time_text is ignored.
	580	* @return mixed Excel date/time serial value, PHP date/time serial value or PHP date/time object,
	581	* depending on the value of the ReturnDateType flag
	582	*/
	583	public static function TIMEVALUE($timeValue) {
	584	$timeValue = trim(PHPExcel_Calculation_Functions::flattenSingleValue($timeValue),'"');
	585	$timeValue = str_replace(array('/','.'),array('-','-'),$timeValue);
	586
	587	$PHPDateArray = date_parse($timeValue);
	588	if (($PHPDateArray !== False) && ($PHPDateArray['error_count'] == 0)) {
	589	if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
	590	$excelDateValue = PHPExcel_Shared_Date::FormattedPHPToExcel($PHPDateArray['year'],$PHPDateArray['month'],$PHPDateArray['day'],$PHPDateArray['hour'],$PHPDateArray['minute'],$PHPDateArray['second']);
	591	} else {
	592	$excelDateValue = PHPExcel_Shared_Date::FormattedPHPToExcel(1900,1,1,$PHPDateArray['hour'],$PHPDateArray['minute'],$PHPDateArray['second']) - 1;
	593	}
	594
	595	switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
	596	case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL :
	597	return (float) $excelDateValue;
	598	case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC :
	599	return (integer) $phpDateValue = PHPExcel_Shared_Date::ExcelToPHP($excelDateValue+25569) - 3600;;
	600	case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT :
	601	return new DateTime('1900-01-01 '.$PHPDateArray['hour'].':'.$PHPDateArray['minute'].':'.$PHPDateArray['second']);
	602	}
	603	}
	604	return PHPExcel_Calculation_Functions::VALUE();
	605	} // function TIMEVALUE()
	606
	607
	608	/**
	609	* DATEDIF
	610	*
	611	* @param mixed $startDate Excel date serial value, PHP date/time stamp, PHP DateTime object
	612	* or a standard date string
	613	* @param mixed $endDate Excel date serial value, PHP date/time stamp, PHP DateTime object
	614	* or a standard date string
	615	* @param string $unit
	616	* @return integer Interval between the dates
	617	*/
	618	public static function DATEDIF($startDate = 0, $endDate = 0, $unit = 'D') {
	619	$startDate = PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
	620	$endDate = PHPExcel_Calculation_Functions::flattenSingleValue($endDate);
	621	$unit = strtoupper(PHPExcel_Calculation_Functions::flattenSingleValue($unit));
	622
	623	if (is_string($startDate = self::_getDateValue($startDate))) {
	624	return PHPExcel_Calculation_Functions::VALUE();
	625	}
	626	if (is_string($endDate = self::_getDateValue($endDate))) {
	627	return PHPExcel_Calculation_Functions::VALUE();
	628	}
	629
	630	// Validate parameters
	631	if ($startDate >= $endDate) {
	632	return PHPExcel_Calculation_Functions::NaN();
	633	}
	634
	635	// Execute function
	636	$difference = $endDate - $startDate;
	637
	638	$PHPStartDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($startDate);
	639	$startDays = $PHPStartDateObject->format('j');
	640	$startMonths = $PHPStartDateObject->format('n');
	641	$startYears = $PHPStartDateObject->format('Y');
	642
	643	$PHPEndDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($endDate);
	644	$endDays = $PHPEndDateObject->format('j');
	645	$endMonths = $PHPEndDateObject->format('n');
	646	$endYears = $PHPEndDateObject->format('Y');
	647
	648	$retVal = PHPExcel_Calculation_Functions::NaN();
	649	switch ($unit) {
	650	case 'D':
	651	$retVal = intval($difference);
	652	break;
	653	case 'M':
	654	$retVal = intval($endMonths - $startMonths) + (intval($endYears - $startYears) * 12);
	655	// We're only interested in full months
	656	if ($endDays < $startDays) {
	657	--$retVal;
	658	}
	659	break;
	660	case 'Y':
	661	$retVal = intval($endYears - $startYears);
	662	// We're only interested in full months
	663	if ($endMonths < $startMonths) {
	664	--$retVal;
	665	} elseif (($endMonths == $startMonths) && ($endDays < $startDays)) {
	666	--$retVal;
	667	}
	668	break;
	669	case 'MD':
	670	if ($endDays < $startDays) {
	671	$retVal = $endDays;
	672	$PHPEndDateObject->modify('-'.$endDays.' days');
	673	$adjustDays = $PHPEndDateObject->format('j');
	674	if ($adjustDays > $startDays) {
	675	$retVal += ($adjustDays - $startDays);
	676	}
	677	} else {
	678	$retVal = $endDays - $startDays;
	679	}
	680	break;
	681	case 'YM':
	682	$retVal = intval($endMonths - $startMonths);
	683	if ($retVal < 0) $retVal = 12 + $retVal;
	684	// We're only interested in full months
	685	if ($endDays < $startDays) {
	686	--$retVal;
	687	}
	688	break;
	689	case 'YD':
	690	$retVal = intval($difference);
	691	if ($endYears > $startYears) {
	692	while ($endYears > $startYears) {
	693	$PHPEndDateObject->modify('-1 year');
	694	$endYears = $PHPEndDateObject->format('Y');
	695	}
	696	$retVal = $PHPEndDateObject->format('z') - $PHPStartDateObject->format('z');
	697	if ($retVal < 0) { $retVal += 365; }
	698	}
	699	break;
	700	default:
	701	$retVal = PHPExcel_Calculation_Functions::NaN();
	702	}
	703	return $retVal;
	704	} // function DATEDIF()
	705
	706
	707	/**
	708	* DAYS360
	709	*
	710	* Returns the number of days between two dates based on a 360-day year (twelve 30-day months),
	711	* which is used in some accounting calculations. Use this function to help compute payments if
	712	* your accounting system is based on twelve 30-day months.
	713	*
	714	* Excel Function:
	715	* DAYS360(startDate,endDate[,method])
	716	*
	717	* @access public
	718	* @category Date/Time Functions
	719	* @param mixed $startDate Excel date serial value (float), PHP date timestamp (integer),
	720	* PHP DateTime object, or a standard date string
	721	* @param mixed $endDate Excel date serial value (float), PHP date timestamp (integer),
	722	* PHP DateTime object, or a standard date string
	723	* @param boolean $method US or European Method
	724	* FALSE or omitted: U.S. (NASD) method. If the starting date is
	725	* the last day of a month, it becomes equal to the 30th of the
	726	* same month. If the ending date is the last day of a month and
	727	* the starting date is earlier than the 30th of a month, the
	728	* ending date becomes equal to the 1st of the next month;
	729	* otherwise the ending date becomes equal to the 30th of the
	730	* same month.
	731	* TRUE: European method. Starting dates and ending dates that
	732	* occur on the 31st of a month become equal to the 30th of the
	733	* same month.
	734	* @return integer Number of days between start date and end date
	735	*/
	736	public static function DAYS360($startDate = 0, $endDate = 0, $method = false) {
	737	$startDate = PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
	738	$endDate = PHPExcel_Calculation_Functions::flattenSingleValue($endDate);
	739
	740	if (is_string($startDate = self::_getDateValue($startDate))) {
	741	return PHPExcel_Calculation_Functions::VALUE();
	742	}
	743	if (is_string($endDate = self::_getDateValue($endDate))) {
	744	return PHPExcel_Calculation_Functions::VALUE();
	745	}
	746
	747	if (!is_bool($method)) {
	748	return PHPExcel_Calculation_Functions::VALUE();
	749	}
	750
	751	// Execute function
	752	$PHPStartDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($startDate);
	753	$startDay = $PHPStartDateObject->format('j');
	754	$startMonth = $PHPStartDateObject->format('n');
	755	$startYear = $PHPStartDateObject->format('Y');
	756
	757	$PHPEndDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($endDate);
	758	$endDay = $PHPEndDateObject->format('j');
	759	$endMonth = $PHPEndDateObject->format('n');
	760	$endYear = $PHPEndDateObject->format('Y');
	761
	762	return self::_dateDiff360($startDay, $startMonth, $startYear, $endDay, $endMonth, $endYear, !$method);
	763	} // function DAYS360()
	764
	765
	766	/**
	767	* YEARFRAC
	768	*
	769	* Calculates the fraction of the year represented by the number of whole days between two dates
	770	* (the start_date and the end_date).
	771	* Use the YEARFRAC worksheet function to identify the proportion of a whole year's benefits or
	772	* obligations to assign to a specific term.
	773	*
	774	* Excel Function:
	775	* YEARFRAC(startDate,endDate[,method])
	776	*
	777	* @access public
	778	* @category Date/Time Functions
	779	* @param mixed $startDate Excel date serial value (float), PHP date timestamp (integer),
	780	* PHP DateTime object, or a standard date string
	781	* @param mixed $endDate Excel date serial value (float), PHP date timestamp (integer),
	782	* PHP DateTime object, or a standard date string
	783	* @param integer $method Method used for the calculation
	784	* 0 or omitted US (NASD) 30/360
	785	* 1 Actual/actual
	786	* 2 Actual/360
	787	* 3 Actual/365
	788	* 4 European 30/360
	789	* @return float fraction of the year
	790	*/
	791	public static function YEARFRAC($startDate = 0, $endDate = 0, $method = 0) {
	792	$startDate = PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
	793	$endDate = PHPExcel_Calculation_Functions::flattenSingleValue($endDate);
	794	$method = PHPExcel_Calculation_Functions::flattenSingleValue($method);
	795
	796	if (is_string($startDate = self::_getDateValue($startDate))) {
	797	return PHPExcel_Calculation_Functions::VALUE();
	798	}
	799	if (is_string($endDate = self::_getDateValue($endDate))) {
	800	return PHPExcel_Calculation_Functions::VALUE();
	801	}
	802
	803	if (((is_numeric($method)) && (!is_string($method))) \|\| ($method == '')) {
	804	switch($method) {
	805	case 0 :
	806	return self::DAYS360($startDate,$endDate) / 360;
	807	case 1 :
	808	$days = self::DATEDIF($startDate,$endDate);
	809	$startYear = self::YEAR($startDate);
	810	$endYear = self::YEAR($endDate);
	811	$years = $endYear - $startYear + 1;
	812	$leapDays = 0;
	813	if ($years == 1) {
	814	if (self::_isLeapYear($endYear)) {
	815	$startMonth = self::MONTHOFYEAR($startDate);
	816	$endMonth = self::MONTHOFYEAR($endDate);
	817	$endDay = self::DAYOFMONTH($endDate);
	818	if (($startMonth < 3) \|\|
	819	(($endMonth * 100 + $endDay) >= (2 * 100 + 29))) {
	820	$leapDays += 1;
	821	}
	822	}
	823	} else {
	824	for($year = $startYear; $year <= $endYear; ++$year) {
	825	if ($year == $startYear) {
	826	$startMonth = self::MONTHOFYEAR($startDate);
	827	$startDay = self::DAYOFMONTH($startDate);
	828	if ($startMonth < 3) {
	829	$leapDays += (self::_isLeapYear($year)) ? 1 : 0;
	830	}
	831	} elseif($year == $endYear) {
	832	$endMonth = self::MONTHOFYEAR($endDate);
	833	$endDay = self::DAYOFMONTH($endDate);
	834	if (($endMonth * 100 + $endDay) >= (2 * 100 + 29)) {
	835	$leapDays += (self::_isLeapYear($year)) ? 1 : 0;
	836	}
	837	} else {
	838	$leapDays += (self::_isLeapYear($year)) ? 1 : 0;
	839	}
	840	}
	841	if ($years == 2) {
	842	if (($leapDays == 0) && (self::_isLeapYear($startYear)) && ($days > 365)) {
	843	$leapDays = 1;
	844	} elseif ($days < 366) {
	845	$years = 1;
	846	}
	847	}
	848	$leapDays /= $years;
	849	}
	850	return $days / (365 + $leapDays);
	851	case 2 :
	852	return self::DATEDIF($startDate,$endDate) / 360;
	853	case 3 :
	854	return self::DATEDIF($startDate,$endDate) / 365;
	855	case 4 :
	856	return self::DAYS360($startDate,$endDate,True) / 360;
	857	}
	858	}
	859	return PHPExcel_Calculation_Functions::VALUE();
	860	} // function YEARFRAC()
	861
	862
	863	/**
	864	* NETWORKDAYS
	865	*
	866	* Returns the number of whole working days between start_date and end_date. Working days
	867	* exclude weekends and any dates identified in holidays.
	868	* Use NETWORKDAYS to calculate employee benefits that accrue based on the number of days
	869	* worked during a specific term.
	870	*
	871	* Excel Function:
	872	* NETWORKDAYS(startDate,endDate[,holidays[,holiday[,...]]])
	873	*
	874	* @access public
	875	* @category Date/Time Functions
	876	* @param mixed $startDate Excel date serial value (float), PHP date timestamp (integer),
	877	* PHP DateTime object, or a standard date string
	878	* @param mixed $endDate Excel date serial value (float), PHP date timestamp (integer),
	879	* PHP DateTime object, or a standard date string
	880	* @param mixed $holidays,... Optional series of Excel date serial value (float), PHP date
	881	* timestamp (integer), PHP DateTime object, or a standard date
	882	* strings that will be excluded from the working calendar, such
	883	* as state and federal holidays and floating holidays.
	884	* @return integer Interval between the dates
	885	*/
	886	public static function NETWORKDAYS($startDate,$endDate) {
	887	// Retrieve the mandatory start and end date that are referenced in the function definition
	888	$startDate = PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
	889	$endDate = PHPExcel_Calculation_Functions::flattenSingleValue($endDate);
	890	// Flush the mandatory start and end date that are referenced in the function definition, and get the optional days
	891	$dateArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
	892	array_shift($dateArgs);
	893	array_shift($dateArgs);
	894
	895	// Validate the start and end dates
	896	if (is_string($startDate = $sDate = self::_getDateValue($startDate))) {
	897	return PHPExcel_Calculation_Functions::VALUE();
	898	}
	899	$startDate = (float) floor($startDate);
	900	if (is_string($endDate = $eDate = self::_getDateValue($endDate))) {
	901	return PHPExcel_Calculation_Functions::VALUE();
	902	}
	903	$endDate = (float) floor($endDate);
	904
	905	if ($sDate > $eDate) {
	906	$startDate = $eDate;
	907	$endDate = $sDate;
	908	}
	909
	910	// Execute function
	911	$startDoW = 6 - self::DAYOFWEEK($startDate,2);
	912	if ($startDoW < 0) { $startDoW = 0; }
	913	$endDoW = self::DAYOFWEEK($endDate,2);
	914	if ($endDoW >= 6) { $endDoW = 0; }
	915
	916	$wholeWeekDays = floor(($endDate - $startDate) / 7) * 5;
	917	$partWeekDays = $endDoW + $startDoW;
	918	if ($partWeekDays > 5) {
	919	$partWeekDays -= 5;
	920	}
	921
	922	// Test any extra holiday parameters
	923	$holidayCountedArray = array();
	924	foreach ($dateArgs as $holidayDate) {
	925	if (is_string($holidayDate = self::_getDateValue($holidayDate))) {
	926	return PHPExcel_Calculation_Functions::VALUE();
	927	}
	928	if (($holidayDate >= $startDate) && ($holidayDate <= $endDate)) {
	929	if ((self::DAYOFWEEK($holidayDate,2) < 6) && (!in_array($holidayDate,$holidayCountedArray))) {
	930	--$partWeekDays;
	931	$holidayCountedArray[] = $holidayDate;
	932	}
	933	}
	934	}
	935
	936	if ($sDate > $eDate) {
	937	return 0 - ($wholeWeekDays + $partWeekDays);
	938	}
	939	return $wholeWeekDays + $partWeekDays;
	940	} // function NETWORKDAYS()
	941
	942
	943	/**
	944	* WORKDAY
	945	*
	946	* Returns the date that is the indicated number of working days before or after a date (the
	947	* starting date). Working days exclude weekends and any dates identified as holidays.
	948	* Use WORKDAY to exclude weekends or holidays when you calculate invoice due dates, expected
	949	* delivery times, or the number of days of work performed.
	950	*
	951	* Excel Function:
	952	* WORKDAY(startDate,endDays[,holidays[,holiday[,...]]])
	953	*
	954	* @access public
	955	* @category Date/Time Functions
	956	* @param mixed $startDate Excel date serial value (float), PHP date timestamp (integer),
	957	* PHP DateTime object, or a standard date string
	958	* @param integer $endDays The number of nonweekend and nonholiday days before or after
	959	* startDate. A positive value for days yields a future date; a
	960	* negative value yields a past date.
	961	* @param mixed $holidays,... Optional series of Excel date serial value (float), PHP date
	962	* timestamp (integer), PHP DateTime object, or a standard date
	963	* strings that will be excluded from the working calendar, such
	964	* as state and federal holidays and floating holidays.
	965	* @return mixed Excel date/time serial value, PHP date/time serial value or PHP date/time object,
	966	* depending on the value of the ReturnDateType flag
	967	*/
	968	public static function WORKDAY($startDate,$endDays) {
	969	// Retrieve the mandatory start date and days that are referenced in the function definition
	970	$startDate = PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
	971	$endDays = PHPExcel_Calculation_Functions::flattenSingleValue($endDays);
	972	// Flush the mandatory start date and days that are referenced in the function definition, and get the optional days
	973	$dateArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
	974	array_shift($dateArgs);
	975	array_shift($dateArgs);
	976
	977	if ((is_string($startDate = self::_getDateValue($startDate))) \|\| (!is_numeric($endDays))) {
	978	return PHPExcel_Calculation_Functions::VALUE();
	979	}
	980	$startDate = (float) floor($startDate);
	981	$endDays = (int) floor($endDays);
	982	// If endDays is 0, we always return startDate
	983	if ($endDays == 0) { return $startDate; }
	984
	985	$decrementing = ($endDays < 0) ? True : False;
	986
	987	// Adjust the start date if it falls over a weekend
	988
	989	$startDoW = self::DAYOFWEEK($startDate,3);
	990	if (self::DAYOFWEEK($startDate,3) >= 5) {
	991	$startDate += ($decrementing) ? -$startDoW + 4: 7 - $startDoW;
	992	($decrementing) ? $endDays++ : $endDays--;
	993	}
	994
	995	// Add endDays
	996	$endDate = (float) $startDate + (intval($endDays / 5) * 7) + ($endDays % 5);
	997
	998	// Adjust the calculated end date if it falls over a weekend
	999	$endDoW = self::DAYOFWEEK($endDate,3);
	1000	if ($endDoW >= 5) {
	1001	$endDate += ($decrementing) ? -$endDoW + 4: 7 - $endDoW;
	1002	}
	1003
	1004	// Test any extra holiday parameters
	1005	if (!empty($dateArgs)) {
	1006	$holidayCountedArray = $holidayDates = array();
	1007	foreach ($dateArgs as $holidayDate) {
	1008	if (($holidayDate !== NULL) && (trim($holidayDate) > '')) {
	1009	if (is_string($holidayDate = self::_getDateValue($holidayDate))) {
	1010	return PHPExcel_Calculation_Functions::VALUE();
	1011	}
	1012	if (self::DAYOFWEEK($holidayDate,3) < 5) {
	1013	$holidayDates[] = $holidayDate;
	1014	}
	1015	}
	1016	}
	1017	if ($decrementing) {
	1018	rsort($holidayDates, SORT_NUMERIC);
	1019	} else {
	1020	sort($holidayDates, SORT_NUMERIC);
	1021	}
	1022	foreach ($holidayDates as $holidayDate) {
	1023	if ($decrementing) {
	1024	if (($holidayDate <= $startDate) && ($holidayDate >= $endDate)) {
	1025	if (!in_array($holidayDate,$holidayCountedArray)) {
	1026	--$endDate;
	1027	$holidayCountedArray[] = $holidayDate;
	1028	}
	1029	}
	1030	} else {
	1031	if (($holidayDate >= $startDate) && ($holidayDate <= $endDate)) {
	1032	if (!in_array($holidayDate,$holidayCountedArray)) {
	1033	++$endDate;
	1034	$holidayCountedArray[] = $holidayDate;
	1035	}
	1036	}
	1037	}
	1038	// Adjust the calculated end date if it falls over a weekend
	1039	$endDoW = self::DAYOFWEEK($endDate,3);
	1040	if ($endDoW >= 5) {
	1041	$endDate += ($decrementing) ? -$endDoW + 4: 7 - $endDoW;
	1042	}
	1043
	1044	}
	1045	}
	1046
	1047	switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
	1048	case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL :
	1049	return (float) $endDate;
	1050	case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC :
	1051	return (integer) PHPExcel_Shared_Date::ExcelToPHP($endDate);
	1052	case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT :
	1053	return PHPExcel_Shared_Date::ExcelToPHPObject($endDate);
	1054	}
	1055	} // function WORKDAY()
	1056
	1057
	1058	/**
	1059	* DAYOFMONTH
	1060	*
	1061	* Returns the day of the month, for a specified date. The day is given as an integer
	1062	* ranging from 1 to 31.
	1063	*
	1064	* Excel Function:
	1065	* DAY(dateValue)
	1066	*
	1067	* @param mixed $dateValue Excel date serial value (float), PHP date timestamp (integer),
	1068	* PHP DateTime object, or a standard date string
	1069	* @return int Day of the month
	1070	*/
	1071	public static function DAYOFMONTH($dateValue = 1) {
	1072	$dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
	1073
	1074	if (is_string($dateValue = self::_getDateValue($dateValue))) {
	1075	return PHPExcel_Calculation_Functions::VALUE();
	1076	} elseif ($dateValue == 0.0) {
	1077	return 0;
	1078	} elseif ($dateValue < 0.0) {
	1079	return PHPExcel_Calculation_Functions::NaN();
	1080	}
	1081
	1082	// Execute function
	1083	$PHPDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($dateValue);
	1084
	1085	return (int) $PHPDateObject->format('j');
	1086	} // function DAYOFMONTH()
	1087
	1088
	1089	/**
	1090	* DAYOFWEEK
	1091	*
	1092	* Returns the day of the week for a specified date. The day is given as an integer
	1093	* ranging from 0 to 7 (dependent on the requested style).
	1094	*
	1095	* Excel Function:
	1096	* WEEKDAY(dateValue[,style])
	1097	*
	1098	* @param mixed $dateValue Excel date serial value (float), PHP date timestamp (integer),
	1099	* PHP DateTime object, or a standard date string
	1100	* @param int $style A number that determines the type of return value
	1101	* 1 or omitted Numbers 1 (Sunday) through 7 (Saturday).
	1102	* 2 Numbers 1 (Monday) through 7 (Sunday).
	1103	* 3 Numbers 0 (Monday) through 6 (Sunday).
	1104	* @return int Day of the week value
	1105	*/
	1106	public static function DAYOFWEEK($dateValue = 1, $style = 1) {
	1107	$dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
	1108	$style = PHPExcel_Calculation_Functions::flattenSingleValue($style);
	1109
	1110	if (!is_numeric($style)) {
	1111	return PHPExcel_Calculation_Functions::VALUE();
	1112	} elseif (($style < 1) \|\| ($style > 3)) {
	1113	return PHPExcel_Calculation_Functions::NaN();
	1114	}
	1115	$style = floor($style);
	1116
	1117	if (is_string($dateValue = self::_getDateValue($dateValue))) {
	1118	return PHPExcel_Calculation_Functions::VALUE();
	1119	} elseif ($dateValue < 0.0) {
	1120	return PHPExcel_Calculation_Functions::NaN();
	1121	}
	1122
	1123	// Execute function
	1124	$PHPDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($dateValue);
	1125	$DoW = $PHPDateObject->format('w');
	1126
	1127	$firstDay = 1;
	1128	switch ($style) {
	1129	case 1: ++$DoW;
	1130	break;
	1131	case 2: if ($DoW == 0) { $DoW = 7; }
	1132	break;
	1133	case 3: if ($DoW == 0) { $DoW = 7; }
	1134	$firstDay = 0;
	1135	--$DoW;
	1136	break;
	1137	}
	1138	if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL) {
	1139	// Test for Excel's 1900 leap year, and introduce the error as required
	1140	if (($PHPDateObject->format('Y') == 1900) && ($PHPDateObject->format('n') <= 2)) {
	1141	--$DoW;
	1142	if ($DoW < $firstDay) {
	1143	$DoW += 7;
	1144	}
	1145	}
	1146	}
	1147
	1148	return (int) $DoW;
	1149	} // function DAYOFWEEK()
	1150
	1151
	1152	/**
	1153	* WEEKOFYEAR
	1154	*
	1155	* Returns the week of the year for a specified date.
	1156	* The WEEKNUM function considers the week containing January 1 to be the first week of the year.
	1157	* However, there is a European standard that defines the first week as the one with the majority
	1158	* of days (four or more) falling in the new year. This means that for years in which there are
	1159	* three days or less in the first week of January, the WEEKNUM function returns week numbers
	1160	* that are incorrect according to the European standard.
	1161	*
	1162	* Excel Function:
	1163	* WEEKNUM(dateValue[,style])
	1164	*
	1165	* @param mixed $dateValue Excel date serial value (float), PHP date timestamp (integer),
	1166	* PHP DateTime object, or a standard date string
	1167	* @param boolean $method Week begins on Sunday or Monday
	1168	* 1 or omitted Week begins on Sunday.
	1169	* 2 Week begins on Monday.
	1170	* @return int Week Number
	1171	*/
	1172	public static function WEEKOFYEAR($dateValue = 1, $method = 1) {
	1173	$dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
	1174	$method = PHPExcel_Calculation_Functions::flattenSingleValue($method);
	1175
	1176	if (!is_numeric($method)) {
	1177	return PHPExcel_Calculation_Functions::VALUE();
	1178	} elseif (($method < 1) \|\| ($method > 2)) {
	1179	return PHPExcel_Calculation_Functions::NaN();
	1180	}
	1181	$method = floor($method);
	1182
	1183	if (is_string($dateValue = self::_getDateValue($dateValue))) {
	1184	return PHPExcel_Calculation_Functions::VALUE();
	1185	} elseif ($dateValue < 0.0) {
	1186	return PHPExcel_Calculation_Functions::NaN();
	1187	}
	1188
	1189	// Execute function
	1190	$PHPDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($dateValue);
	1191	$dayOfYear = $PHPDateObject->format('z');
	1192	$dow = $PHPDateObject->format('w');
	1193	$PHPDateObject->modify('-'.$dayOfYear.' days');
	1194	$dow = $PHPDateObject->format('w');
	1195	$daysInFirstWeek = 7 - (($dow + (2 - $method)) % 7);
	1196	$dayOfYear -= $daysInFirstWeek;
	1197	$weekOfYear = ceil($dayOfYear / 7) + 1;
	1198
	1199	return (int) $weekOfYear;
	1200	} // function WEEKOFYEAR()
	1201
	1202
	1203	/**
	1204	* MONTHOFYEAR
	1205	*
	1206	* Returns the month of a date represented by a serial number.
	1207	* The month is given as an integer, ranging from 1 (January) to 12 (December).
	1208	*
	1209	* Excel Function:
	1210	* MONTH(dateValue)
	1211	*
	1212	* @param mixed $dateValue Excel date serial value (float), PHP date timestamp (integer),
	1213	* PHP DateTime object, or a standard date string
	1214	* @return int Month of the year
	1215	*/
	1216	public static function MONTHOFYEAR($dateValue = 1) {
	1217	$dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
	1218
	1219	if (is_string($dateValue = self::_getDateValue($dateValue))) {
	1220	return PHPExcel_Calculation_Functions::VALUE();
	1221	} elseif ($dateValue < 0.0) {
	1222	return PHPExcel_Calculation_Functions::NaN();
	1223	}
	1224
	1225	// Execute function
	1226	$PHPDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($dateValue);
	1227
	1228	return (int) $PHPDateObject->format('n');
	1229	} // function MONTHOFYEAR()
	1230
	1231
	1232	/**
	1233	* YEAR
	1234	*
	1235	* Returns the year corresponding to a date.
	1236	* The year is returned as an integer in the range 1900-9999.
	1237	*
	1238	* Excel Function:
	1239	* YEAR(dateValue)
	1240	*
	1241	* @param mixed $dateValue Excel date serial value (float), PHP date timestamp (integer),
	1242	* PHP DateTime object, or a standard date string
	1243	* @return int Year
	1244	*/
	1245	public static function YEAR($dateValue = 1) {
	1246	$dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
	1247
	1248	if (is_string($dateValue = self::_getDateValue($dateValue))) {
	1249	return PHPExcel_Calculation_Functions::VALUE();
	1250	} elseif ($dateValue < 0.0) {
	1251	return PHPExcel_Calculation_Functions::NaN();
	1252	}
	1253
	1254	// Execute function
	1255	$PHPDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($dateValue);
	1256
	1257	return (int) $PHPDateObject->format('Y');
	1258	} // function YEAR()
	1259
	1260
	1261	/**
	1262	* HOUROFDAY
	1263	*
	1264	* Returns the hour of a time value.
	1265	* The hour is given as an integer, ranging from 0 (12:00 A.M.) to 23 (11:00 P.M.).
	1266	*
	1267	* Excel Function:
	1268	* HOUR(timeValue)
	1269	*
	1270	* @param mixed $timeValue Excel date serial value (float), PHP date timestamp (integer),
	1271	* PHP DateTime object, or a standard time string
	1272	* @return int Hour
	1273	*/
	1274	public static function HOUROFDAY($timeValue = 0) {
	1275	$timeValue = PHPExcel_Calculation_Functions::flattenSingleValue($timeValue);
	1276
	1277	if (!is_numeric($timeValue)) {
	1278	if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
	1279	$testVal = strtok($timeValue,'/-: ');
	1280	if (strlen($testVal) < strlen($timeValue)) {
	1281	return PHPExcel_Calculation_Functions::VALUE();
	1282	}
	1283	}
	1284	$timeValue = self::_getTimeValue($timeValue);
	1285	if (is_string($timeValue)) {
	1286	return PHPExcel_Calculation_Functions::VALUE();
	1287	}
	1288	}
	1289	// Execute function
	1290	if ($timeValue >= 1) {
	1291	$timeValue = fmod($timeValue,1);
	1292	} elseif ($timeValue < 0.0) {
	1293	return PHPExcel_Calculation_Functions::NaN();
	1294	}
	1295	$timeValue = PHPExcel_Shared_Date::ExcelToPHP($timeValue);
	1296
	1297	return (int) gmdate('G',$timeValue);
	1298	} // function HOUROFDAY()
	1299
	1300
	1301	/**
	1302	* MINUTEOFHOUR
	1303	*
	1304	* Returns the minutes of a time value.
	1305	* The minute is given as an integer, ranging from 0 to 59.
	1306	*
	1307	* Excel Function:
	1308	* MINUTE(timeValue)
	1309	*
	1310	* @param mixed $timeValue Excel date serial value (float), PHP date timestamp (integer),
	1311	* PHP DateTime object, or a standard time string
	1312	* @return int Minute
	1313	*/
	1314	public static function MINUTEOFHOUR($timeValue = 0) {
	1315	$timeValue = $timeTester = PHPExcel_Calculation_Functions::flattenSingleValue($timeValue);
	1316
	1317	if (!is_numeric($timeValue)) {
	1318	if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
	1319	$testVal = strtok($timeValue,'/-: ');
	1320	if (strlen($testVal) < strlen($timeValue)) {
	1321	return PHPExcel_Calculation_Functions::VALUE();
	1322	}
	1323	}
	1324	$timeValue = self::_getTimeValue($timeValue);
	1325	if (is_string($timeValue)) {
	1326	return PHPExcel_Calculation_Functions::VALUE();
	1327	}
	1328	}
	1329	// Execute function
	1330	if ($timeValue >= 1) {
	1331	$timeValue = fmod($timeValue,1);
	1332	} elseif ($timeValue < 0.0) {
	1333	return PHPExcel_Calculation_Functions::NaN();
	1334	}
	1335	$timeValue = PHPExcel_Shared_Date::ExcelToPHP($timeValue);
	1336
	1337	return (int) gmdate('i',$timeValue);
	1338	} // function MINUTEOFHOUR()
	1339
	1340
	1341	/**
	1342	* SECONDOFMINUTE
	1343	*
	1344	* Returns the seconds of a time value.
	1345	* The second is given as an integer in the range 0 (zero) to 59.
	1346	*
	1347	* Excel Function:
	1348	* SECOND(timeValue)
	1349	*
	1350	* @param mixed $timeValue Excel date serial value (float), PHP date timestamp (integer),
	1351	* PHP DateTime object, or a standard time string
	1352	* @return int Second
	1353	*/
	1354	public static function SECONDOFMINUTE($timeValue = 0) {
	1355	$timeValue = PHPExcel_Calculation_Functions::flattenSingleValue($timeValue);
	1356
	1357	if (!is_numeric($timeValue)) {
	1358	if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
	1359	$testVal = strtok($timeValue,'/-: ');
	1360	if (strlen($testVal) < strlen($timeValue)) {
	1361	return PHPExcel_Calculation_Functions::VALUE();
	1362	}
	1363	}
	1364	$timeValue = self::_getTimeValue($timeValue);
	1365	if (is_string($timeValue)) {
	1366	return PHPExcel_Calculation_Functions::VALUE();
	1367	}
	1368	}
	1369	// Execute function
	1370	if ($timeValue >= 1) {
	1371	$timeValue = fmod($timeValue,1);
	1372	} elseif ($timeValue < 0.0) {
	1373	return PHPExcel_Calculation_Functions::NaN();
	1374	}
	1375	$timeValue = PHPExcel_Shared_Date::ExcelToPHP($timeValue);
	1376
	1377	return (int) gmdate('s',$timeValue);
	1378	} // function SECONDOFMINUTE()
	1379
	1380
	1381	/**
	1382	* EDATE
	1383	*
	1384	* Returns the serial number that represents the date that is the indicated number of months
	1385	* before or after a specified date (the start_date).
	1386	* Use EDATE to calculate maturity dates or due dates that fall on the same day of the month
	1387	* as the date of issue.
	1388	*
	1389	* Excel Function:
	1390	* EDATE(dateValue,adjustmentMonths)
	1391	*
	1392	* @param mixed $dateValue Excel date serial value (float), PHP date timestamp (integer),
	1393	* PHP DateTime object, or a standard date string
	1394	* @param int $adjustmentMonths The number of months before or after start_date.
	1395	* A positive value for months yields a future date;
	1396	* a negative value yields a past date.
	1397	* @return mixed Excel date/time serial value, PHP date/time serial value or PHP date/time object,
	1398	* depending on the value of the ReturnDateType flag
	1399	*/
	1400	public static function EDATE($dateValue = 1, $adjustmentMonths = 0) {
	1401	$dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
	1402	$adjustmentMonths = PHPExcel_Calculation_Functions::flattenSingleValue($adjustmentMonths);
	1403
	1404	if (!is_numeric($adjustmentMonths)) {
	1405	return PHPExcel_Calculation_Functions::VALUE();
	1406	}
	1407	$adjustmentMonths = floor($adjustmentMonths);
	1408
	1409	if (is_string($dateValue = self::_getDateValue($dateValue))) {
	1410	return PHPExcel_Calculation_Functions::VALUE();
	1411	}
	1412
	1413	// Execute function
	1414	$PHPDateObject = self::_adjustDateByMonths($dateValue,$adjustmentMonths);
	1415
	1416	switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
	1417	case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL :
	1418	return (float) PHPExcel_Shared_Date::PHPToExcel($PHPDateObject);
	1419	case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC :
	1420	return (integer) PHPExcel_Shared_Date::ExcelToPHP(PHPExcel_Shared_Date::PHPToExcel($PHPDateObject));
	1421	case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT :
	1422	return $PHPDateObject;
	1423	}
	1424	} // function EDATE()
	1425
	1426
	1427	/**
	1428	* EOMONTH
	1429	*
	1430	* Returns the date value for the last day of the month that is the indicated number of months
	1431	* before or after start_date.
	1432	* Use EOMONTH to calculate maturity dates or due dates that fall on the last day of the month.
	1433	*
	1434	* Excel Function:
	1435	* EOMONTH(dateValue,adjustmentMonths)
	1436	*
	1437	* @param mixed $dateValue Excel date serial value (float), PHP date timestamp (integer),
	1438	* PHP DateTime object, or a standard date string
	1439	* @param int $adjustmentMonths The number of months before or after start_date.
	1440	* A positive value for months yields a future date;
	1441	* a negative value yields a past date.
	1442	* @return mixed Excel date/time serial value, PHP date/time serial value or PHP date/time object,
	1443	* depending on the value of the ReturnDateType flag
	1444	*/
	1445	public static function EOMONTH($dateValue = 1, $adjustmentMonths = 0) {
	1446	$dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
	1447	$adjustmentMonths = PHPExcel_Calculation_Functions::flattenSingleValue($adjustmentMonths);
	1448
	1449	if (!is_numeric($adjustmentMonths)) {
	1450	return PHPExcel_Calculation_Functions::VALUE();
	1451	}
	1452	$adjustmentMonths = floor($adjustmentMonths);
	1453
	1454	if (is_string($dateValue = self::_getDateValue($dateValue))) {
	1455	return PHPExcel_Calculation_Functions::VALUE();
	1456	}
	1457
	1458	// Execute function
	1459	$PHPDateObject = self::_adjustDateByMonths($dateValue,$adjustmentMonths+1);
	1460	$adjustDays = (int) $PHPDateObject->format('d');
	1461	$adjustDaysString = '-'.$adjustDays.' days';
	1462	$PHPDateObject->modify($adjustDaysString);
	1463
	1464	switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
	1465	case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL :
	1466	return (float) PHPExcel_Shared_Date::PHPToExcel($PHPDateObject);
	1467	case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC :
	1468	return (integer) PHPExcel_Shared_Date::ExcelToPHP(PHPExcel_Shared_Date::PHPToExcel($PHPDateObject));
	1469	case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT :
	1470	return $PHPDateObject;
	1471	}
	1472	} // function EOMONTH()
	1473
	1474	} // class PHPExcel_Calculation_DateTime
	1475

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: sourcecode/application/libraries/PHPExcel/Calculation/DateTime.php @ 1

Download in other formats: