File Source for Functions.php

<?php
/**
* PHPExcel
*
* Copyright (c) 2006 - 2010 PHPExcel
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* @category PHPExcel
* @package PHPExcel_Calculation
* @copyright Copyright (c) 2006 - 2010 PHPExcel (http://www.codeplex.com/PHPExcel)
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
* @version 1.7.2, 2010-01-11
*/
/** EPS */
define('EPS', 2.22e-16);
/** MAX_VALUE */
define('MAX_VALUE', 1.2e308);
/** LOG_GAMMA_X_MAX_VALUE */
define('LOG_GAMMA_X_MAX_VALUE', 2.55e305);
/** SQRT2PI */
define('SQRT2PI', 2.5066282746310005024157652848110452530069867406099);
/** 2 / PI */
define('M_2DIVPI', 0.63661977236758134307553505349006);
/** XMININ */
define('XMININ', 2.23e-308);
/** MAX_ITERATIONS */
define('MAX_ITERATIONS', 256);
/** FINANCIAL_MAX_ITERATIONS */
define('FINANCIAL_MAX_ITERATIONS', 128);
/** PRECISION */
define('PRECISION', 8.88E-016);
/** FINANCIAL_PRECISION */
define('FINANCIAL_PRECISION', 1.0e-08);
/** EULER */
define('EULER', 2.71828182845904523536);
$savedPrecision = ini_get('precision');
if ($savedPrecision < 16) {
ini_set('precision',16);
}
/** PHPExcel root directory */
if (!defined('PHPEXCEL_ROOT')) {
/**
* @ignore
*/
define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
}
/** PHPExcel_Cell */
require_once PHPEXCEL_ROOT . 'PHPExcel/Cell.php';
/** PHPExcel_Calculation */
require_once PHPEXCEL_ROOT . 'PHPExcel/Calculation.php';
/** PHPExcel_Cell_DataType */
require_once PHPEXCEL_ROOT . 'PHPExcel/Cell/DataType.php';
/** PHPExcel_Style_NumberFormat */
require_once PHPEXCEL_ROOT . 'PHPExcel/Style/NumberFormat.php';
/** PHPExcel_Shared_Date */
require_once PHPEXCEL_ROOT . 'PHPExcel/Shared/Date.php';
/** Matrix */
require_once PHPEXCEL_ROOT . 'PHPExcel/Shared/JAMA/Matrix.php';
require_once PHPEXCEL_ROOT . 'PHPExcel/Shared/trend/trendClass.php';
/**
* PHPExcel_Calculation_Functions
*
* @category PHPExcel
* @package PHPExcel_Calculation
* @copyright Copyright (c) 2006 - 2010 PHPExcel (http://www.codeplex.com/PHPExcel)
*/
class PHPExcel_Calculation_Functions {
/** constants */
const COMPATIBILITY_EXCEL = 'Excel';
const COMPATIBILITY_GNUMERIC = 'Gnumeric';
const COMPATIBILITY_OPENOFFICE = 'OpenOfficeCalc';
const RETURNDATE_PHP_NUMERIC = 'P';
const RETURNDATE_PHP_OBJECT = 'O';
const RETURNDATE_EXCEL = 'E';
/**
* Compatibility mode to use for error checking and responses
*
* @access private
* @var string
*/
private static $compatibilityMode = self::COMPATIBILITY_EXCEL;
/**
* Data Type to use when returning date values
*
* @access private
* @var integer
*/
private static $ReturnDateType = self::RETURNDATE_EXCEL;
/**
* List of error codes
*
* @access private
* @var array
*/
private static $_errorCodes = array( 'null' => '#NULL!',
'divisionbyzero' => '#DIV/0!',
'value' => '#VALUE!',
'reference' => '#REF!',
'name' => '#NAME?',
'num' => '#NUM!',
'na' => '#N/A',
'gettingdata' => '#GETTING_DATA'
);
/**
* Set the Compatibility Mode
*
* @access public
* @category Function Configuration
* @param string $compatibilityMode Compatibility Mode
* Permitted values are:
* PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL 'Excel'
* PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC 'Gnumeric'
* PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE 'OpenOfficeCalc'
* @return boolean (Success or Failure)
*/
public static function setCompatibilityMode($compatibilityMode) {
if (($compatibilityMode == self::COMPATIBILITY_EXCEL) ||
($compatibilityMode == self::COMPATIBILITY_GNUMERIC) ||
($compatibilityMode == self::COMPATIBILITY_OPENOFFICE)) {
self::$compatibilityMode = $compatibilityMode;
return True;
}
return False;
} // function setCompatibilityMode()
/**
* Return the current Compatibility Mode
*
* @access public
* @category Function Configuration
* @return string Compatibility Mode
* Possible Return values are:
* PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL 'Excel'
* PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC 'Gnumeric'
* PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE 'OpenOfficeCalc'
*/
public static function getCompatibilityMode() {
return self::$compatibilityMode;
} // function getCompatibilityMode()
/**
* Set the Return Date Format used by functions that return a date/time (Excel, PHP Serialized Numeric or PHP Object)
*
* @access public
* @category Function Configuration
* @param string $returnDateType Return Date Format
* Permitted values are:
* PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC 'P'
* PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT 'O'
* PHPExcel_Calculation_Functions::RETURNDATE_EXCEL 'E'
* @return boolean Success or failure
*/
public static function setReturnDateType($returnDateType) {
if (($returnDateType == self::RETURNDATE_PHP_NUMERIC) ||
($returnDateType == self::RETURNDATE_PHP_OBJECT) ||
($returnDateType == self::RETURNDATE_EXCEL)) {
self::$ReturnDateType = $returnDateType;
return True;
}
return False;
} // function setReturnDateType()
/**
* Return the current Return Date Format for functions that return a date/time (Excel, PHP Serialized Numeric or PHP Object)
*
* @access public
* @category Function Configuration
* @return string Return Date Format
* Possible Return values are:
* PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC 'P'
* PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT 'O'
* PHPExcel_Calculation_Functions::RETURNDATE_EXCEL 'E'
*/
public static function getReturnDateType() {
return self::$ReturnDateType;
} // function getReturnDateType()
/**
* DUMMY
*
* @access public
* @category Error Returns
* @return string #Not Yet Implemented
*/
public static function DUMMY() {
return '#Not Yet Implemented';
} // function DUMMY()
/**
* NA
*
* @access public
* @category Error Returns
* @return string #N/A!
*/
public static function NA() {
return self::$_errorCodes['na'];
} // function NA()
/**
* NAN
*
* @access public
* @category Error Returns
* @return string #NUM!
*/
public static function NaN() {
return self::$_errorCodes['num'];
} // function NAN()
/**
* NAME
*
* @access public
* @category Error Returns
* @return string #NAME!
*/
public static function NAME() {
return self::$_errorCodes['name'];
} // function NAME()
/**
* REF
*
* @access public
* @category Error Returns
* @return string #REF!
*/
public static function REF() {
return self::$_errorCodes['reference'];
} // function REF()
/**
* VALUE
*
* @access public
* @category Error Returns
* @return string #VALUE!
*/
public static function VALUE() {
return self::$_errorCodes['value'];
} // function VALUE()
private static function isMatrixValue($idx) {
return ((substr_count($idx,'.') <= 1) || (preg_match('/\.[A-Z]/',$idx) > 0));
}
private static function isValue($idx) {
return (substr_count($idx,'.') == 0);
}
private static function isCellValue($idx) {
return (substr_count($idx,'.') > 1);
}
/**
* LOGICAL_AND
*
* Returns boolean TRUE if all its arguments are TRUE; returns FALSE if one or more argument is FALSE.
*
* Excel Function:
* =AND(logical1[,logical2[, ...]])
*
* The arguments must evaluate to logical values such as TRUE or FALSE, or the arguments must be arrays
* or references that contain logical values.
*
* Boolean arguments are treated as True or False as appropriate
* Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
* If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string holds
* the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
*
* @access public
* @category Logical Functions
* @param mixed $arg,... Data values
* @return boolean The logical AND of the arguments.
*/
public static function LOGICAL_AND() {
// Return value
$returnValue = True;
// Loop through the arguments
$aArgs = self::flattenArray(func_get_args());
$argCount = 0;
foreach ($aArgs as $arg) {
// Is it a boolean value?
if (is_bool($arg)) {
$returnValue = $returnValue && $arg;
} elseif ((is_numeric($arg)) && (!is_string($arg))) {
$returnValue = $returnValue && ($arg != 0);
} elseif (is_string($arg)) {
$arg = strtoupper($arg);
if ($arg == 'TRUE') {
$arg = 1;
} elseif ($arg == 'FALSE') {
$arg = 0;
} else {
return self::$_errorCodes['value'];
}
$returnValue = $returnValue && ($arg != 0);
}
++$argCount;
}
// Return
if ($argCount == 0) {
return self::$_errorCodes['value'];
}
return $returnValue;
} // function LOGICAL_AND()
/**
* LOGICAL_OR
*
* Returns boolean TRUE if any argument is TRUE; returns FALSE if all arguments are FALSE.
*
* Excel Function:
* =OR(logical1[,logical2[, ...]])
*
* The arguments must evaluate to logical values such as TRUE or FALSE, or the arguments must be arrays
* or references that contain logical values.
*
* Boolean arguments are treated as True or False as appropriate
* Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
* If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string holds
* the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
*
* @access public
* @category Logical Functions
* @param mixed $arg,... Data values
* @return boolean The logical OR of the arguments.
*/
public static function LOGICAL_OR() {
// Return value
$returnValue = False;
// Loop through the arguments
$aArgs = self::flattenArray(func_get_args());
$argCount = 0;
foreach ($aArgs as $arg) {
// Is it a boolean value?
if (is_bool($arg)) {
$returnValue = $returnValue || $arg;
} elseif ((is_numeric($arg)) && (!is_string($arg))) {
$returnValue = $returnValue || ($arg != 0);
} elseif (is_string($arg)) {
$arg = strtoupper($arg);
if ($arg == 'TRUE') {
$arg = 1;
} elseif ($arg == 'FALSE') {
$arg = 0;
} else {
return self::$_errorCodes['value'];
}
$returnValue = $returnValue || ($arg != 0);
}
++$argCount;
}
// Return
if ($argCount == 0) {
return self::$_errorCodes['value'];
}
return $returnValue;
} // function LOGICAL_OR()
/**
* LOGICAL_FALSE
*
* Returns the boolean FALSE.
*
* Excel Function:
* =FALSE()
*
* @access public
* @category Logical Functions
* @return boolean False
*/
public static function LOGICAL_FALSE() {
return False;
} // function LOGICAL_FALSE()
/**
* LOGICAL_TRUE
*
* Returns the boolean TRUE.
*
* Excel Function:
* =TRUE()
*
* @access public
* @category Logical Functions
* @return boolean True
*/
public static function LOGICAL_TRUE() {
return True;
} // function LOGICAL_TRUE()
/**
* LOGICAL_NOT
*
* Returns the boolean inverse of the argument.
*
* Excel Function:
* =NOT(logical)
*
* The argument must evaluate to a logical value such as TRUE or FALSE
*
* Boolean arguments are treated as True or False as appropriate
* Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
* If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string holds
* the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
*
* @access public
* @category Logical Functions
* @param mixed $logical A value or expression that can be evaluated to TRUE or FALSE
* @return boolean The boolean inverse of the argument.
*/
public static function LOGICAL_NOT($logical) {
$logical = self::flattenSingleValue($logical);
if (is_string($logical)) {
$logical = strtoupper($logical);
if ($logical == 'TRUE') {
return False;
} elseif ($logical == 'FALSE') {
return True;
} else {
return self::$_errorCodes['value'];
}
}
return !$logical;
} // function LOGICAL_NOT()
/**
* STATEMENT_IF
*
* Returns one value if a condition you specify evaluates to TRUE and another value if it evaluates to FALSE.
*
* Excel Function:
* =IF(condition[,returnIfTrue[,returnIfFalse]])
*
* Condition is any value or expression that can be evaluated to TRUE or FALSE.
* For example, A10=100 is a logical expression; if the value in cell A10 is equal to 100,
* the expression evaluates to TRUE. Otherwise, the expression evaluates to FALSE.
* This argument can use any comparison calculation operator.
* ReturnIfTrue is the value that is returned if condition evaluates to TRUE.
* For example, if this argument is the text string "Within budget" and the condition argument evaluates to TRUE,
* then the IF function returns the text "Within budget"
* If condition is TRUE and ReturnIfTrue is blank, this argument returns 0 (zero). To display the word TRUE, use
* the logical value TRUE for this argument.
* ReturnIfTrue can be another formula.
* ReturnIfFalse is the value that is returned if condition evaluates to FALSE.
* For example, if this argument is the text string "Over budget" and the condition argument evaluates to FALSE,
* then the IF function returns the text "Over budget".
* If condition is FALSE and ReturnIfFalse is omitted, then the logical value FALSE is returned.
* If condition is FALSE and ReturnIfFalse is blank, then the value 0 (zero) is returned.
* ReturnIfFalse can be another formula.
*
* @access public
* @category Logical Functions
* @param mixed $condition Condition to evaluate
* @param mixed $returnIfTrue Value to return when condition is true
* @param mixed $returnIfFalse Optional value to return when condition is false
* @return mixed The value of returnIfTrue or returnIfFalse determined by condition
*/
public static function STATEMENT_IF($condition = true, $returnIfTrue = 0, $returnIfFalse = False) {
$condition = (is_null($condition)) ? True : (boolean) self::flattenSingleValue($condition);
$returnIfTrue = (is_null($returnIfTrue)) ? 0 : self::flattenSingleValue($returnIfTrue);
$returnIfFalse = (is_null($returnIfFalse)) ? False : self::flattenSingleValue($returnIfFalse);
return ($condition ? $returnIfTrue : $returnIfFalse);
} // function STATEMENT_IF()
/**
* STATEMENT_IFERROR
*
* Excel Function:
* =IFERROR(testValue,errorpart)
*
* @access public
* @category Logical Functions
* @param mixed $testValue Value to check, is also the value returned when no error
* @param mixed $errorpart Value to return when testValue is an error condition
* @return mixed The value of errorpart or testValue determined by error condition
*/
public static function STATEMENT_IFERROR($testValue = '', $errorpart = '') {
$testValue = (is_null($testValue)) ? '' : self::flattenSingleValue($testValue);
$errorpart = (is_null($errorpart)) ? '' : self::flattenSingleValue($errorpart);
return self::STATEMENT_IF(self::IS_ERROR($testValue), $errorpart, $testValue);
} // function STATEMENT_IFERROR()
/**
* ATAN2
*
* This function calculates the arc tangent of the two variables x and y. It is similar to
* calculating the arc tangent of y � x, except that the signs of both arguments are used
* to determine the quadrant of the result.
* The arctangent is the angle from the x-axis to a line containing the origin (0, 0) and a
* point with coordinates (xCoordinate, yCoordinate). The angle is given in radians between
* -pi and pi, excluding -pi.
*
* Note that the Excel ATAN2() function accepts its arguments in the reverse order to the standard
* PHP atan2() function, so we need to reverse them here before calling the PHP atan() function.
*
* Excel Function:
* ATAN2(xCoordinate,yCoordinate)
*
* @access public
* @category Mathematical and Trigonometric Functions
* @param float $xCoordinate The x-coordinate of the point.
* @param float $yCoordinate The y-coordinate of the point.
* @return float The inverse tangent of the specified x- and y-coordinates.
*/
public static function REVERSE_ATAN2($xCoordinate, $yCoordinate) {
$xCoordinate = (float) self::flattenSingleValue($xCoordinate);
$yCoordinate = (float) self::flattenSingleValue($yCoordinate);
if (($xCoordinate == 0) && ($yCoordinate == 0)) {
return self::$_errorCodes['divisionbyzero'];
}
return atan2($yCoordinate, $xCoordinate);
} // function REVERSE_ATAN2()
/**
* LOG_BASE
*
* Returns the logarithm of a number to a specified base. The default base is 10.
*
* Excel Function:
* LOG(number[,base])
*
* @access public
* @category Mathematical and Trigonometric Functions
* @param float $value The positive real number for which you want the logarithm
* @param float $base The base of the logarithm. If base is omitted, it is assumed to be 10.
* @return float
*/
public static function LOG_BASE($number, $base=10) {
$number = self::flattenSingleValue($number);
$base = (is_null($base)) ? 10 : (float) self::flattenSingleValue($base);
return log($number, $base);
} // function LOG_BASE()
/**
* SUM
*
* SUM computes the sum of all the values and cells referenced in the argument list.
*
* Excel Function:
* SUM(value1[,value2[, ...]])
*
* @access public
* @category Mathematical and Trigonometric Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function SUM() {
// Return value
$returnValue = 0;
// Loop through the arguments
$aArgs = self::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$returnValue += $arg;
}
}
// Return
return $returnValue;
} // function SUM()
/**
* SUMSQ
*
* SUMSQ returns the sum of the squares of the arguments
*
* Excel Function:
* SUMSQ(value1[,value2[, ...]])
*
* @access public
* @category Mathematical and Trigonometric Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function SUMSQ() {
// Return value
$returnValue = 0;
// Loop through arguments
$aArgs = self::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$returnValue += ($arg * $arg);
}
}
// Return
return $returnValue;
} // function SUMSQ()
/**
* PRODUCT
*
* PRODUCT returns the product of all the values and cells referenced in the argument list.
*
* Excel Function:
* PRODUCT(value1[,value2[, ...]])
*
* @access public
* @category Mathematical and Trigonometric Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function PRODUCT() {
// Return value
$returnValue = null;
// Loop through arguments
$aArgs = self::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
if (is_null($returnValue)) {
$returnValue = $arg;
} else {
$returnValue *= $arg;
}
}
}
// Return
if (is_null($returnValue)) {
return 0;
}
return $returnValue;
} // function PRODUCT()
/**
* QUOTIENT
*
* QUOTIENT function returns the integer portion of a division. Numerator is the divided number
* and denominator is the divisor.
*
* Excel Function:
* QUOTIENT(value1[,value2[, ...]])
*
* @access public
* @category Mathematical and Trigonometric Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function QUOTIENT() {
// Return value
$returnValue = null;
// Loop through arguments
$aArgs = self::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
if (is_null($returnValue)) {
$returnValue = ($arg == 0) ? 0 : $arg;
} else {
if (($returnValue == 0) || ($arg == 0)) {
$returnValue = 0;
} else {
$returnValue /= $arg;
}
}
}
}
// Return
return intval($returnValue);
} // function QUOTIENT()
/**
* MIN
*
* MIN returns the value of the element of the values passed that has the smallest value,
* with negative numbers considered smaller than positive numbers.
*
* Excel Function:
* MIN(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function MIN() {
// Return value
$returnValue = null;
// Loop through arguments
$aArgs = self::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
if ((is_null($returnValue)) || ($arg < $returnValue)) {
$returnValue = $arg;
}
}
}
// Return
if(is_null($returnValue)) {
return 0;
}
return $returnValue;
} // function MIN()
/**
* MINA
*
* Returns the smallest value in a list of arguments, including numbers, text, and logical values
*
* Excel Function:
* MINA(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function MINA() {
// Return value
$returnValue = null;
// Loop through arguments
$aArgs = self::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {
if (is_bool($arg)) {
$arg = (integer) $arg;
} elseif (is_string($arg)) {
$arg = 0;
}
if ((is_null($returnValue)) || ($arg < $returnValue)) {
$returnValue = $arg;
}
}
}
// Return
if(is_null($returnValue)) {
return 0;
}
return $returnValue;
} // function MINA()
/**
* SMALL
*
* Returns the nth smallest value in a data set. You can use this function to
* select a value based on its relative standing.
*
* Excel Function:
* SMALL(value1[,value2[, ...]],entry)
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @param int $entry Position (ordered from the smallest) in the array or range of data to return
* @return float
*/
public static function SMALL() {
$aArgs = self::flattenArray(func_get_args());
// Calculate
$entry = array_pop($aArgs);
if ((is_numeric($entry)) && (!is_string($entry))) {
$mArgs = array();
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$mArgs[] = $arg;
}
}
$count = self::COUNT($mArgs);
$entry = floor(--$entry);
if (($entry < 0) || ($entry >= $count) || ($count == 0)) {
return self::$_errorCodes['num'];
}
sort($mArgs);
return $mArgs[$entry];
}
return self::$_errorCodes['value'];
} // function SMALL()
/**
* MAX
*
* MAX returns the value of the element of the values passed that has the highest value,
* with negative numbers considered smaller than positive numbers.
*
* Excel Function:
* MAX(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function MAX() {
// Return value
$returnValue = null;
// Loop through arguments
$aArgs = self::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
if ((is_null($returnValue)) || ($arg > $returnValue)) {
$returnValue = $arg;
}
}
}
// Return
if(is_null($returnValue)) {
return 0;
}
return $returnValue;
} // function MAX()
/**
* MAXA
*
* Returns the greatest value in a list of arguments, including numbers, text, and logical values
*
* Excel Function:
* MAXA(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function MAXA() {
// Return value
$returnValue = null;
// Loop through arguments
$aArgs = self::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {
if (is_bool($arg)) {
$arg = (integer) $arg;
} elseif (is_string($arg)) {
$arg = 0;
}
if ((is_null($returnValue)) || ($arg > $returnValue)) {
$returnValue = $arg;
}
}
}
// Return
if(is_null($returnValue)) {
return 0;
}
return $returnValue;
} // function MAXA()
/**
* LARGE
*
* Returns the nth largest value in a data set. You can use this function to
* select a value based on its relative standing.
*
* Excel Function:
* LARGE(value1[,value2[, ...]],entry)
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @param int $entry Position (ordered from the largest) in the array or range of data to return
* @return float
*
*/
public static function LARGE() {
$aArgs = self::flattenArray(func_get_args());
// Calculate
$entry = floor(array_pop($aArgs));
if ((is_numeric($entry)) && (!is_string($entry))) {
$mArgs = array();
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$mArgs[] = $arg;
}
}
$count = self::COUNT($mArgs);
$entry = floor(--$entry);
if (($entry < 0) || ($entry >= $count) || ($count == 0)) {
return self::$_errorCodes['num'];
}
rsort($mArgs);
return $mArgs[$entry];
}
return self::$_errorCodes['value'];
} // function LARGE()
/**
* PERCENTILE
*
* Returns the nth percentile of values in a range..
*
* Excel Function:
* PERCENTILE(value1[,value2[, ...]],entry)
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @param float $entry Percentile value in the range 0..1, inclusive.
* @return float
*/
public static function PERCENTILE() {
$aArgs = self::flattenArray(func_get_args());
// Calculate
$entry = array_pop($aArgs);
if ((is_numeric($entry)) && (!is_string($entry))) {
if (($entry < 0) || ($entry > 1)) {
return self::$_errorCodes['num'];
}
$mArgs = array();
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$mArgs[] = $arg;
}
}
$mValueCount = count($mArgs);
if ($mValueCount > 0) {
sort($mArgs);
$count = self::COUNT($mArgs);
$index = $entry * ($count-1);
$iBase = floor($index);
if ($index == $iBase) {
return $mArgs[$index];
} else {
$iNext = $iBase + 1;
$iProportion = $index - $iBase;
return $mArgs[$iBase] + (($mArgs[$iNext] - $mArgs[$iBase]) * $iProportion) ;
}
}
}
return self::$_errorCodes['value'];
} // function PERCENTILE()
/**
* QUARTILE
*
* Returns the quartile of a data set.
*
* Excel Function:
* QUARTILE(value1[,value2[, ...]],entry)
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @param int $entry Quartile value in the range 1..3, inclusive.
* @return float
*/
public static function QUARTILE() {
$aArgs = self::flattenArray(func_get_args());
// Calculate
$entry = floor(array_pop($aArgs));
if ((is_numeric($entry)) && (!is_string($entry))) {
$entry /= 4;
if (($entry < 0) || ($entry > 1)) {
return self::$_errorCodes['num'];
}
return self::PERCENTILE($aArgs,$entry);
}
return self::$_errorCodes['value'];
} // function QUARTILE()
/**
* COUNT
*
* Counts the number of cells that contain numbers within the list of arguments
*
* Excel Function:
* COUNT(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return int
*/
public static function COUNT() {
// Return value
$returnValue = 0;
// Loop through arguments
$aArgs = self::flattenArrayIndexed(func_get_args());
foreach ($aArgs as $k => $arg) {
if ((is_bool($arg)) &&
((!self::isCellValue($k)) || (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE))) {
$arg = (integer) $arg;
}
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
++$returnValue;
}
}
// Return
return $returnValue;
} // function COUNT()
/**
* COUNTBLANK
*
* Counts the number of empty cells within the list of arguments
*
* Excel Function:
* COUNTBLANK(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return int
*/
public static function COUNTBLANK() {
// Return value
$returnValue = 0;
// Loop through arguments
$aArgs = self::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
// Is it a blank cell?
if ((is_null($arg)) || ((is_string($arg)) && ($arg == ''))) {
++$returnValue;
}
}
// Return
return $returnValue;
} // function COUNTBLANK()
/**
* COUNTA
*
* Counts the number of cells that are not empty within the list of arguments
*
* Excel Function:
* COUNTA(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return int
*/
public static function COUNTA() {
// Return value
$returnValue = 0;
// Loop through arguments
$aArgs = self::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
// Is it a numeric, boolean or string value?
if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {
++$returnValue;
}
}
// Return
return $returnValue;
} // function COUNTA()
/**
* COUNTIF
*
* Counts the number of cells that contain numbers within the list of arguments
*
* Excel Function:
* COUNTIF(value1[,value2[, ...]],condition)
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @param string $condition The criteria that defines which cells will be counted.
* @return int
*/
public static function COUNTIF($aArgs,$condition) {
// Return value
$returnValue = 0;
$aArgs = self::flattenArray($aArgs);
$condition = self::flattenSingleValue($condition);
if (!in_array($condition{0},array('>', '<', '='))) {
if (!is_numeric($condition)) { $condition = PHPExcel_Calculation::_wrapResult(strtoupper($condition)); }
$condition = '='.$condition;
} else {
preg_match('/([<>=]+)(.*)/',$condition,$matches);
list(,$operator,$operand) = $matches;
if (!is_numeric($operand)) { $operand = PHPExcel_Calculation::_wrapResult(strtoupper($operand)); }
$condition = $operator.$operand;
}
// Loop through arguments
foreach ($aArgs as $arg) {
if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
$testCondition = '='.$arg.$condition;
if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
// Is it a value within our criteria
++$returnValue;
}
}
// Return
return $returnValue;
} // function COUNTIF()
/**
* SUMIF
*
* Counts the number of cells that contain numbers within the list of arguments
*
* Excel Function:
* SUMIF(value1[,value2[, ...]],condition)
*
* @access public
* @category Mathematical and Trigonometric Functions
* @param mixed $arg,... Data values
* @param string $condition The criteria that defines which cells will be summed.
* @return float
*/
public static function SUMIF($aArgs,$condition,$sumArgs = array()) {
// Return value
$returnValue = 0;
$aArgs = self::flattenArray($aArgs);
$sumArgs = self::flattenArray($sumArgs);
if (count($sumArgs) == 0) {
$sumArgs = $aArgs;
}
if (!in_array($condition{0},array('>', '<', '='))) {
if (!is_numeric($condition)) { $condition = PHPExcel_Calculation::_wrapResult(strtoupper($condition)); }
$condition = '='.$condition;
} else {
preg_match('/([<>=]+)(.*)/',$condition,$matches);
list(,$operator,$operand) = $matches;
if (!is_numeric($operand)) { $operand = PHPExcel_Calculation::_wrapResult(strtoupper($operand)); }
$condition = $operator.$operand;
}
// Loop through arguments
foreach ($aArgs as $key => $arg) {
if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
$testCondition = '='.$arg.$condition;
if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
// Is it a value within our criteria
$returnValue += $sumArgs[$key];
}
}
// Return
return $returnValue;
} // function SUMIF()
/**
* AVERAGE
*
* Returns the average (arithmetic mean) of the arguments
*
* Excel Function:
* AVERAGE(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function AVERAGE() {
$aArgs = self::flattenArrayIndexed(func_get_args());
$returnValue = $aCount = 0;
// Loop through arguments
foreach ($aArgs as $k => $arg) {
if ((is_bool($arg)) &&
((!self::isCellValue($k)) || (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE))) {
$arg = (integer) $arg;
}
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
if (is_null($returnValue)) {
$returnValue = $arg;
} else {
$returnValue += $arg;
}
++$aCount;
}
}
// Return
if ($aCount > 0) {
return $returnValue / $aCount;
} else {
return self::$_errorCodes['divisionbyzero'];
}
} // function AVERAGE()
/**
* AVERAGEA
*
* Returns the average of its arguments, including numbers, text, and logical values
*
* Excel Function:
* AVERAGEA(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function AVERAGEA() {
// Return value
$returnValue = null;
// Loop through arguments
$aArgs = self::flattenArrayIndexed(func_get_args());
$aCount = 0;
foreach ($aArgs as $k => $arg) {
if ((is_bool($arg)) &&
(!self::isMatrixValue($k))) {
} else {
if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {
if (is_bool($arg)) {
$arg = (integer) $arg;
} elseif (is_string($arg)) {
$arg = 0;
}
if (is_null($returnValue)) {
$returnValue = $arg;
} else {
$returnValue += $arg;
}
++$aCount;
}
}
}
// Return
if ($aCount > 0) {
return $returnValue / $aCount;
} else {
return self::$_errorCodes['divisionbyzero'];
}
} // function AVERAGEA()
/**
* MEDIAN
*
* Returns the median of the given numbers. The median is the number in the middle of a set of numbers.
*
* Excel Function:
* MEDIAN(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function MEDIAN() {
// Return value
$returnValue = self::$_errorCodes['num'];
$mArgs = array();
// Loop through arguments
$aArgs = self::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$mArgs[] = $arg;
}
}
$mValueCount = count($mArgs);
if ($mValueCount > 0) {
sort($mArgs,SORT_NUMERIC);
$mValueCount = $mValueCount / 2;
if ($mValueCount == floor($mValueCount)) {
$returnValue = ($mArgs[$mValueCount--] + $mArgs[$mValueCount]) / 2;
} else {
$mValueCount == floor($mValueCount);
$returnValue = $mArgs[$mValueCount];
}
}
// Return
return $returnValue;
} // function MEDIAN()
//
// Special variant of array_count_values that isn't limited to strings and integers,
// but can work with floating point numbers as values
//
private static function _modeCalc($data) {
$frequencyArray = array();
foreach($data as $datum) {
$found = False;
foreach($frequencyArray as $key => $value) {
if ((string) $value['value'] == (string) $datum) {
++$frequencyArray[$key]['frequency'];
$found = True;
break;
}
}
if (!$found) {
$frequencyArray[] = array('value' => $datum,
'frequency' => 1 );
}
}
foreach($frequencyArray as $key => $value) {
$frequencyList[$key] = $value['frequency'];
$valueList[$key] = $value['value'];
}
array_multisort($frequencyList, SORT_DESC, $valueList, SORT_ASC, SORT_NUMERIC, $frequencyArray);
if ($frequencyArray[0]['frequency'] == 1) {
return self::NA();
}
return $frequencyArray[0]['value'];
} // function _modeCalc()
/**
* MODE
*
* Returns the most frequently occurring, or repetitive, value in an array or range of data
*
* Excel Function:
* MODE(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function MODE() {
// Return value
$returnValue = self::NA();
// Loop through arguments
$aArgs = self::flattenArray(func_get_args());
$mArgs = array();
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$mArgs[] = $arg;
}
}
if (count($mArgs) > 0) {
return self::_modeCalc($mArgs);
}
// Return
return $returnValue;
} // function MODE()
/**
* DEVSQ
*
* Returns the sum of squares of deviations of data points from their sample mean.
*
* Excel Function:
* DEVSQ(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function DEVSQ() {
$aArgs = self::flattenArrayIndexed(func_get_args());
// Return value
$returnValue = null;
$aMean = self::AVERAGE($aArgs);
if ($aMean != self::$_errorCodes['divisionbyzero']) {
$aCount = -1;
foreach ($aArgs as $k => $arg) {
// Is it a numeric value?
if ((is_bool($arg)) &&
((!self::isCellValue($k)) || (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE))) {
$arg = (integer) $arg;
}
if ((is_numeric($arg)) && (!is_string($arg))) {
if (is_null($returnValue)) {
$returnValue = pow(($arg - $aMean),2);
} else {
$returnValue += pow(($arg - $aMean),2);
}
++$aCount;
}
}
// Return
if (is_null($returnValue)) {
return self::$_errorCodes['num'];
} else {
return $returnValue;
}
}
return self::NA();
} // function DEVSQ()
/**
* AVEDEV
*
* Returns the average of the absolute deviations of data points from their mean.
* AVEDEV is a measure of the variability in a data set.
*
* Excel Function:
* AVEDEV(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function AVEDEV() {
$aArgs = self::flattenArrayIndexed(func_get_args());
// Return value
$returnValue = null;
$aMean = self::AVERAGE($aArgs);
if ($aMean != self::$_errorCodes['divisionbyzero']) {
$aCount = 0;
foreach ($aArgs as $k => $arg) {
if ((is_bool($arg)) &&
((!self::isCellValue($k)) || (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE))) {
$arg = (integer) $arg;
}
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
if (is_null($returnValue)) {
$returnValue = abs($arg - $aMean);
} else {
$returnValue += abs($arg - $aMean);
}
++$aCount;
}
}
// Return
if ($aCount == 0) {
return self::$_errorCodes['divisionbyzero'];
}
return $returnValue / $aCount;
}
return self::$_errorCodes['num'];
} // function AVEDEV()
/**
* GEOMEAN
*
* Returns the geometric mean of an array or range of positive data. For example, you
* can use GEOMEAN to calculate average growth rate given compound interest with
* variable rates.
*
* Excel Function:
* GEOMEAN(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function GEOMEAN() {
$aArgs = self::flattenArray(func_get_args());
$aMean = self::PRODUCT($aArgs);
if (is_numeric($aMean) && ($aMean > 0)) {
$aCount = self::COUNT($aArgs) ;
if (self::MIN($aArgs) > 0) {
return pow($aMean, (1 / $aCount));
}
}
return self::$_errorCodes['num'];
} // GEOMEAN()
/**
* HARMEAN
*
* Returns the harmonic mean of a data set. The harmonic mean is the reciprocal of the
* arithmetic mean of reciprocals.
*
* Excel Function:
* HARMEAN(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function HARMEAN() {
// Return value
$returnValue = self::NA();
// Loop through arguments
$aArgs = self::flattenArray(func_get_args());
if (self::MIN($aArgs) < 0) {
return self::$_errorCodes['num'];
}
$aCount = 0;
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
if ($arg <= 0) {
return self::$_errorCodes['num'];
}
if (is_null($returnValue)) {
$returnValue = (1 / $arg);
} else {
$returnValue += (1 / $arg);
}
++$aCount;
}
}
// Return
if ($aCount > 0) {
return 1 / ($returnValue / $aCount);
} else {
return $returnValue;
}
} // function HARMEAN()
/**
* TRIMMEAN
*
* Returns the mean of the interior of a data set. TRIMMEAN calculates the mean
* taken by excluding a percentage of data points from the top and bottom tails
* of a data set.
*
* Excel Function:
* TRIMEAN(value1[,value2[, ...]],$discard)
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @param float $discard Percentage to discard
* @return float
*/
public static function TRIMMEAN() {
$aArgs = self::flattenArray(func_get_args());
// Calculate
$percent = array_pop($aArgs);
if ((is_numeric($percent)) && (!is_string($percent))) {
if (($percent < 0) || ($percent > 1)) {
return self::$_errorCodes['num'];
}
$mArgs = array();
foreach ($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$mArgs[] = $arg;
}
}
$discard = floor(self::COUNT($mArgs) * $percent / 2);
sort($mArgs);
for ($i=0; $i < $discard; ++$i) {
array_pop($mArgs);
array_shift($mArgs);
}
return self::AVERAGE($mArgs);
}
return self::$_errorCodes['value'];
} // function TRIMMEAN()
/**
* STDEV
*
* Estimates standard deviation based on a sample. The standard deviation is a measure of how
* widely values are dispersed from the average value (the mean).
*
* Excel Function:
* STDEV(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function STDEV() {
$aArgs = self::flattenArrayIndexed(func_get_args());
// Return value
$returnValue = null;
$aMean = self::AVERAGE($aArgs);
if (!is_null($aMean)) {
$aCount = -1;
foreach ($aArgs as $k => $arg) {
if ((is_bool($arg)) &&
((!self::isCellValue($k)) || (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE))) {
$arg = (integer) $arg;
}
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
if (is_null($returnValue)) {
$returnValue = pow(($arg - $aMean),2);
} else {
$returnValue += pow(($arg - $aMean),2);
}
++$aCount;
}
}
// Return
if (($aCount > 0) && ($returnValue > 0)) {
return sqrt($returnValue / $aCount);
}
}
return self::$_errorCodes['divisionbyzero'];
} // function STDEV()
/**
* STDEVA
*
* Estimates standard deviation based on a sample, including numbers, text, and logical values
*
* Excel Function:
* STDEVA(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function STDEVA() {
$aArgs = self::flattenArrayIndexed(func_get_args());
// Return value
$returnValue = null;
$aMean = self::AVERAGEA($aArgs);
if (!is_null($aMean)) {
$aCount = -1;
foreach ($aArgs as $k => $arg) {
if ((is_bool($arg)) &&
(!self::isMatrixValue($k))) {
} else {
// Is it a numeric value?
if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {
if (is_bool($arg)) {
$arg = (integer) $arg;
} elseif (is_string($arg)) {
$arg = 0;
}
if (is_null($returnValue)) {
$returnValue = pow(($arg - $aMean),2);
} else {
$returnValue += pow(($arg - $aMean),2);
}
++$aCount;
}
}
}
// Return
if (($aCount > 0) && ($returnValue > 0)) {
return sqrt($returnValue / $aCount);
}
}
return self::$_errorCodes['divisionbyzero'];
} // function STDEVA()
/**
* STDEVP
*
* Calculates standard deviation based on the entire population
*
* Excel Function:
* STDEVP(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function STDEVP() {
$aArgs = self::flattenArrayIndexed(func_get_args());
// Return value
$returnValue = null;
$aMean = self::AVERAGE($aArgs);
if (!is_null($aMean)) {
$aCount = 0;
foreach ($aArgs as $k => $arg) {
if ((is_bool($arg)) &&
((!self::isCellValue($k)) || (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE))) {
$arg = (integer) $arg;
}
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
if (is_null($returnValue)) {
$returnValue = pow(($arg - $aMean),2);
} else {
$returnValue += pow(($arg - $aMean),2);
}
++$aCount;
}
}
// Return
if (($aCount > 0) && ($returnValue > 0)) {
return sqrt($returnValue / $aCount);
}
}
return self::$_errorCodes['divisionbyzero'];
} // function STDEVP()
/**
* STDEVPA
*
* Calculates standard deviation based on the entire population, including numbers, text, and logical values
*
* Excel Function:
* STDEVPA(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function STDEVPA() {
$aArgs = self::flattenArrayIndexed(func_get_args());
// Return value
$returnValue = null;
$aMean = self::AVERAGEA($aArgs);
if (!is_null($aMean)) {
$aCount = 0;
foreach ($aArgs as $k => $arg) {
if ((is_bool($arg)) &&
(!self::isMatrixValue($k))) {
} else {
// Is it a numeric value?
if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {
if (is_bool($arg)) {
$arg = (integer) $arg;
} elseif (is_string($arg)) {
$arg = 0;
}
if (is_null($returnValue)) {
$returnValue = pow(($arg - $aMean),2);
} else {
$returnValue += pow(($arg - $aMean),2);
}
++$aCount;
}
}
}
// Return
if (($aCount > 0) && ($returnValue > 0)) {
return sqrt($returnValue / $aCount);
}
}
return self::$_errorCodes['divisionbyzero'];
} // function STDEVPA()
/**
* VARFunc
*
* Estimates variance based on a sample.
*
* Excel Function:
* VAR(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function VARFunc() {
// Return value
$returnValue = self::$_errorCodes['divisionbyzero'];
$summerA = $summerB = 0;
// Loop through arguments
$aArgs = self::flattenArray(func_get_args());
$aCount = 0;
foreach ($aArgs as $arg) {
if (is_bool($arg)) { $arg = (integer) $arg; }
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$summerA += ($arg * $arg);
$summerB += $arg;
++$aCount;
}
}
// Return
if ($aCount > 1) {
$summerA *= $aCount;
$summerB *= $summerB;
$returnValue = ($summerA - $summerB) / ($aCount * ($aCount - 1));
}
return $returnValue;
} // function VARFunc()
/**
* VARA
*
* Estimates variance based on a sample, including numbers, text, and logical values
*
* Excel Function:
* VARA(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function VARA() {
// Return value
$returnValue = self::$_errorCodes['divisionbyzero'];
$summerA = $summerB = 0;
// Loop through arguments
$aArgs = self::flattenArrayIndexed(func_get_args());
$aCount = 0;
foreach ($aArgs as $k => $arg) {
if ((is_string($arg)) &&
(self::isValue($k))) {
return self::$_errorCodes['value'];
} elseif ((is_string($arg)) &&
(!self::isMatrixValue($k))) {
} else {
// Is it a numeric value?
if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {
if (is_bool($arg)) {
$arg = (integer) $arg;
} elseif (is_string($arg)) {
$arg = 0;
}
$summerA += ($arg * $arg);
$summerB += $arg;
++$aCount;
}
}
}
// Return
if ($aCount > 1) {
$summerA *= $aCount;
$summerB *= $summerB;
$returnValue = ($summerA - $summerB) / ($aCount * ($aCount - 1));
}
return $returnValue;
} // function VARA()
/**
* VARP
*
* Calculates variance based on the entire population
*
* Excel Function:
* VARP(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function VARP() {
// Return value
$returnValue = self::$_errorCodes['divisionbyzero'];
$summerA = $summerB = 0;
// Loop through arguments
$aArgs = self::flattenArray(func_get_args());
$aCount = 0;
foreach ($aArgs as $arg) {
if (is_bool($arg)) { $arg = (integer) $arg; }
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$summerA += ($arg * $arg);
$summerB += $arg;
++$aCount;
}
}
// Return
if ($aCount > 0) {
$summerA *= $aCount;
$summerB *= $summerB;
$returnValue = ($summerA - $summerB) / ($aCount * $aCount);
}
return $returnValue;
} // function VARP()
/**
* VARPA
*
* Calculates variance based on the entire population, including numbers, text, and logical values
*
* Excel Function:
* VARPA(value1[,value2[, ...]])
*
* @access public
* @category Statistical Functions
* @param mixed $arg,... Data values
* @return float
*/
public static function VARPA() {
// Return value
$returnValue = self::$_errorCodes['divisionbyzero'];
$summerA = $summerB = 0;
// Loop through arguments
$aArgs = self::flattenArrayIndexed(func_get_args());
$aCount = 0;
foreach ($aArgs as $k => $arg) {
if ((is_string($arg)) &&
(self::isValue($k))) {
return self::$_errorCodes['value'];
} elseif ((is_string($arg)) &&
(!self::isMatrixValue($k))) {
} else {
// Is it a numeric value?
if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {
if (is_bool($arg)) {
$arg = (integer) $arg;
} elseif (is_string($arg)) {
$arg = 0;
}
$summerA += ($arg * $arg);
$summerB += $arg;
++$aCount;
}
}
}
// Return
if ($aCount > 0) {
$summerA *= $aCount;
$summerB *= $summerB;
$returnValue = ($summerA - $summerB) / ($aCount * $aCount);
}
return $returnValue;
} // function VARPA()
/**
* RANK
*
* Returns the rank of a number in a list of numbers.
*
* @param number The number whose rank you want to find.
* @param array of number An array of, or a reference to, a list of numbers.
* @param mixed Order to sort the values in the value set
* @return float
*/
public static function RANK($value,$valueSet,$order=0) {
$value = self::flattenSingleValue($value);
$valueSet = self::flattenArray($valueSet);
$order = (is_null($order)) ? 0 : (integer) self::flattenSingleValue($order);
foreach($valueSet as $key => $valueEntry) {
if (!is_numeric($valueEntry)) {
unset($valueSet[$key]);
}
}
if ($order == 0) {
rsort($valueSet,SORT_NUMERIC);
} else {
sort($valueSet,SORT_NUMERIC);
}
$pos = array_search($value,$valueSet);
if ($pos === False) {
return self::$_errorCodes['na'];
}
return ++$pos;
} // function RANK()
/**
* PERCENTRANK
*
* Returns the rank of a value in a data set as a percentage of the data set.
*
* @param array of number An array of, or a reference to, a list of numbers.
* @param number The number whose rank you want to find.
* @param number The number of significant digits for the returned percentage value.
* @return float
*/
public static function PERCENTRANK($valueSet,$value,$significance=3) {
$valueSet = self::flattenArray($valueSet);
$value = self::flattenSingleValue($value);
$significance = (is_null($significance)) ? 3 : (integer) self::flattenSingleValue($significance);
foreach($valueSet as $key => $valueEntry) {
if (!is_numeric($valueEntry)) {
unset($valueSet[$key]);
}
}
sort($valueSet,SORT_NUMERIC);
$valueCount = count($valueSet);
if ($valueCount == 0) {
return self::$_errorCodes['num'];
}
$valueAdjustor = $valueCount - 1;
if (($value < $valueSet[0]) || ($value > $valueSet[$valueAdjustor])) {
return self::$_errorCodes['na'];
}
$pos = array_search($value,$valueSet);
if ($pos === False) {
$pos = 0;
$testValue = $valueSet[0];
while ($testValue < $value) {
$testValue = $valueSet[++$pos];
}
--$pos;
$pos += (($value - $valueSet[$pos]) / ($testValue - $valueSet[$pos]));
}
return round($pos / $valueAdjustor,$significance);
} // function PERCENTRANK()
private static function _checkTrendArrays(&$array1,&$array2) {
if (!is_array($array1)) { $array1 = array($array1); }
if (!is_array($array2)) { $array2 = array($array2); }
$array1 = self::flattenArray($array1);
$array2 = self::flattenArray($array2);
foreach($array1 as $key => $value) {
if ((is_bool($value)) || (is_string($value)) || (is_null($value))) {
unset($array1[$key]);
unset($array2[$key]);
}
}
foreach($array2 as $key => $value) {
if ((is_bool($value)) || (is_string($value)) || (is_null($value))) {
unset($array1[$key]);
unset($array2[$key]);
}
}
$array1 = array_merge($array1);
$array2 = array_merge($array2);
return True;
} // function _checkTrendArrays()
/**
* INTERCEPT
*
* Calculates the point at which a line will intersect the y-axis by using existing x-values and y-values.
*
* @param array of mixed Data Series Y
* @param array of mixed Data Series X
* @return float
*/
public static function INTERCEPT($yValues,$xValues) {
if (!self::_checkTrendArrays($yValues,$xValues)) {
return self::$_errorCodes['value'];
}
$yValueCount = count($yValues);
$xValueCount = count($xValues);
if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
return self::$_errorCodes['na'];
} elseif ($yValueCount == 1) {
return self::$_errorCodes['divisionbyzero'];
}
$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
return $bestFitLinear->getIntersect();
} // function INTERCEPT()
/**
* RSQ
*
* Returns the square of the Pearson product moment correlation coefficient through data points in known_y's and known_x's.
*
* @param array of mixed Data Series Y
* @param array of mixed Data Series X
* @return float
*/
public static function RSQ($yValues,$xValues) {
if (!self::_checkTrendArrays($yValues,$xValues)) {
return self::$_errorCodes['value'];
}
$yValueCount = count($yValues);
$xValueCount = count($xValues);
if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
return self::$_errorCodes['na'];
} elseif ($yValueCount == 1) {
return self::$_errorCodes['divisionbyzero'];
}
$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
return $bestFitLinear->getGoodnessOfFit();
} // function RSQ()
/**
* SLOPE
*
* Returns the slope of the linear regression line through data points in known_y's and known_x's.
*
* @param array of mixed Data Series Y
* @param array of mixed Data Series X
* @return float
*/
public static function SLOPE($yValues,$xValues) {
if (!self::_checkTrendArrays($yValues,$xValues)) {
return self::$_errorCodes['value'];
}
$yValueCount = count($yValues);
$xValueCount = count($xValues);
if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
return self::$_errorCodes['na'];
} elseif ($yValueCount == 1) {
return self::$_errorCodes['divisionbyzero'];
}
$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
return $bestFitLinear->getSlope();
} // function SLOPE()
/**
* STEYX
*
* Returns the standard error of the predicted y-value for each x in the regression.
*
* @param array of mixed Data Series Y
* @param array of mixed Data Series X
* @return float
*/
public static function STEYX($yValues,$xValues) {
if (!self::_checkTrendArrays($yValues,$xValues)) {
return self::$_errorCodes['value'];
}
$yValueCount = count($yValues);
$xValueCount = count($xValues);
if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
return self::$_errorCodes['na'];
} elseif ($yValueCount == 1) {
return self::$_errorCodes['divisionbyzero'];
}
$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
return $bestFitLinear->getStdevOfResiduals();
} // function STEYX()
/**
* COVAR
*
* Returns covariance, the average of the products of deviations for each data point pair.
*
* @param array of mixed Data Series Y
* @param array of mixed Data Series X
* @return float
*/
public static function COVAR($yValues,$xValues) {
if (!self::_checkTrendArrays($yValues,$xValues)) {
return self::$_errorCodes['value'];
}
$yValueCount = count($yValues);
$xValueCount = count($xValues);
if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
return self::$_errorCodes['na'];
} elseif ($yValueCount == 1) {
return self::$_errorCodes['divisionbyzero'];
}
$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
return $bestFitLinear->getCovariance();
} // function COVAR()
/**
* CORREL
*
* Returns covariance, the average of the products of deviations for each data point pair.
*
* @param array of mixed Data Series Y
* @param array of mixed Data Series X
* @return float
*/
public static function CORREL($yValues,$xValues=null) {
if ((is_null($xValues)) || (!is_array($yValues)) || (!is_array($xValues))) {
return self::$_errorCodes['value'];
}
if (!self::_checkTrendArrays($yValues,$xValues)) {
return self::$_errorCodes['value'];
}
$yValueCount = count($yValues);
$xValueCount = count($xValues);
if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
return self::$_errorCodes['na'];
} elseif ($yValueCount == 1) {
return self::$_errorCodes['divisionbyzero'];
}
$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
return $bestFitLinear->getCorrelation();
} // function CORREL()
/**
* LINEST
*
* Calculates the statistics for a line by using the "least squares" method to calculate a straight line that best fits your data,
* and then returns an array that describes the line.
*
* @param array of mixed Data Series Y
* @param array of mixed Data Series X
* @param boolean A logical value specifying whether to force the intersect to equal 0.
* @param boolean A logical value specifying whether to return additional regression statistics.
* @return array
*/
public static function LINEST($yValues,$xValues=null,$const=True,$stats=False) {
$const = (is_null($const)) ? True : (boolean) self::flattenSingleValue($const);
$stats = (is_null($stats)) ? False : (boolean) self::flattenSingleValue($stats);
if (is_null($xValues)) $xValues = range(1,count(self::flattenArray($yValues)));
if (!self::_checkTrendArrays($yValues,$xValues)) {
return self::$_errorCodes['value'];
}
$yValueCount = count($yValues);
$xValueCount = count($xValues);
if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
return self::$_errorCodes['na'];
} elseif ($yValueCount == 1) {
return 0;
}
$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues,$const);
if ($stats) {
return array( array( $bestFitLinear->getSlope(),
$bestFitLinear->getSlopeSE(),
$bestFitLinear->getGoodnessOfFit(),
$bestFitLinear->getF(),
$bestFitLinear->getSSRegression(),
),
array( $bestFitLinear->getIntersect(),
$bestFitLinear->getIntersectSE(),
$bestFitLinear->getStdevOfResiduals(),
$bestFitLinear->getDFResiduals(),
$bestFitLinear->getSSResiduals()
)
);
} else {
return array( $bestFitLinear->getSlope(),
$bestFitLinear->getIntersect()
);
}
} // function LINEST()
/**
* LOGEST
*
* Calculates an exponential curve that best fits the X and Y data series,
* and then returns an array that describes the line.
*
* @param array of mixed Data Series Y
* @param array of mixed Data Series X
* @param boolean A logical value specifying whether to force the intersect to equal 0.
* @param boolean A logical value specifying whether to return additional regression statistics.
* @return array
*/
public static function LOGEST($yValues,$xValues=null,$const=True,$stats=False) {
$const = (is_null($const)) ? True : (boolean) self::flattenSingleValue($const);
$stats = (is_null($stats)) ? False : (boolean) self::flattenSingleValue($stats);
if (is_null($xValues)) $xValues = range(1,count(self::flattenArray($yValues)));
if (!self::_checkTrendArrays($yValues,$xValues)) {
return self::$_errorCodes['value'];
}
$yValueCount = count($yValues);
$xValueCount = count($xValues);
foreach($yValues as $value) {
if ($value <= 0.0) {
return self::$_errorCodes['num'];
}
}
if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
return self::$_errorCodes['na'];
} elseif ($yValueCount == 1) {
return 1;
}
$bestFitExponential = trendClass::calculate(trendClass::TREND_EXPONENTIAL,$yValues,$xValues,$const);
if ($stats) {
return array( array( $bestFitExponential->getSlope(),
$bestFitExponential->getSlopeSE(),
$bestFitExponential->getGoodnessOfFit(),
$bestFitExponential->getF(),
$bestFitExponential->getSSRegression(),
),
array( $bestFitExponential->getIntersect(),
$bestFitExponential->getIntersectSE(),
$bestFitExponential->getStdevOfResiduals(),
$bestFitExponential->getDFResiduals(),
$bestFitExponential->getSSResiduals()
)
);
} else {
return array( $bestFitExponential->getSlope(),
$bestFitExponential->getIntersect()
);
}
} // function LOGEST()
/**
* FORECAST
*
* Calculates, or predicts, a future value by using existing values. The predicted value is a y-value for a given x-value.
*
* @param float Value of X for which we want to find Y
* @param array of mixed Data Series Y
* @param array of mixed Data Series X
* @return float
*/
public static function FORECAST($xValue,$yValues,$xValues) {
$xValue = self::flattenSingleValue($xValue);
if (!is_numeric($xValue)) {
return self::$_errorCodes['value'];
}
if (!self::_checkTrendArrays($yValues,$xValues)) {
return self::$_errorCodes['value'];
}
$yValueCount = count($yValues);
$xValueCount = count($xValues);
if (($yValueCount == 0) || ($yValueCount != $xValueCount)) {
return self::$_errorCodes['na'];
} elseif ($yValueCount == 1) {
return self::$_errorCodes['divisionbyzero'];
}
$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
return $bestFitLinear->getValueOfYForX($xValue);
} // function FORECAST()
/**
* TREND
*
* Returns values along a linear trend
*
* @param array of mixed Data Series Y
* @param array of mixed Data Series X
* @param array of mixed Values of X for which we want to find Y
* @param boolean A logical value specifying whether to force the intersect to equal 0.
* @return array of float
*/
public static function TREND($yValues,$xValues=array(),$newValues=array(),$const=True) {
$yValues = self::flattenArray($yValues);
$xValues = self::flattenArray($xValues);
$newValues = self::flattenArray($newValues);
$const = (is_null($const)) ? True : (boolean) self::flattenSingleValue($const);
$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues,$const);
if (count($newValues) == 0) {
$newValues = $bestFitLinear->getXValues();
}
$returnArray = array();
foreach($newValues as $xValue) {
$returnArray[0][] = $bestFitLinear->getValueOfYForX($xValue);
}
return $returnArray;
} // function TREND()
/**
* GROWTH
*
* Returns values along a predicted emponential trend
*
* @param array of mixed Data Series Y
* @param array of mixed Data Series X
* @param array of mixed Values of X for which we want to find Y
* @param boolean A logical value specifying whether to force the intersect to equal 0.
* @return array of float
*/
public static function GROWTH($yValues,$xValues=array(),$newValues=array(),$const=True) {
$yValues = self::flattenArray($yValues);
$xValues = self::flattenArray($xValues);
$newValues = self::flattenArray($newValues);
$const = (is_null($const)) ? True : (boolean) self::flattenSingleValue($const);
$bestFitExponential = trendClass::calculate(trendClass::TREND_EXPONENTIAL,$yValues,$xValues,$const);
if (count($newValues) == 0) {
$newValues = $bestFitExponential->getXValues();
}
$returnArray = array();
foreach($newValues as $xValue) {
$returnArray[0][] = $bestFitExponential->getValueOfYForX($xValue);
}
return $returnArray;
} // function GROWTH()
private static function _romanCut($num, $n) {
return ($num - ($num % $n ) ) / $n;
} // function _romanCut()
public static function ROMAN($aValue, $style=0) {
$aValue = (integer) self::flattenSingleValue($aValue);
$style = (is_null($style)) ? 0 : (integer) self::flattenSingleValue($style);
if ((!is_numeric($aValue)) || ($aValue < 0) || ($aValue >= 4000)) {
return self::$_errorCodes['value'];
}
if ($aValue == 0) {
return '';
}
$mill = Array('', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM');
$cent = Array('', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM');
$tens = Array('', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC');
$ones = Array('', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX');
$roman = '';
while ($aValue > 5999) {
$roman .= 'M';
$aValue -= 1000;
}
$m = self::_romanCut($aValue, 1000); $aValue %= 1000;
$c = self::_romanCut($aValue, 100); $aValue %= 100;
$t = self::_romanCut($aValue, 10); $aValue %= 10;
return $roman.$mill[$m].$cent[$c].$tens[$t].$ones[$aValue];
} // function ROMAN()
/**
* SUBTOTAL
*
* Returns a subtotal in a list or database.
*
* @param int the number 1 to 11 that specifies which function to
* use in calculating subtotals within a list.
* @param array of mixed Data Series
* @return float
*/
public static function SUBTOTAL() {
$aArgs = self::flattenArray(func_get_args());
// Calculate
$subtotal = array_shift($aArgs);
if ((is_numeric($subtotal)) && (!is_string($subtotal))) {
switch($subtotal) {
case 1 :
return self::AVERAGE($aArgs);
break;
case 2 :
return self::COUNT($aArgs);
break;
case 3 :
return self::COUNTA($aArgs);
break;
case 4 :
return self::MAX($aArgs);
break;
case 5 :
return self::MIN($aArgs);
break;
case 6 :
return self::PRODUCT($aArgs);
break;
case 7 :
return self::STDEV($aArgs);
break;
case 8 :
return self::STDEVP($aArgs);
break;
case 9 :
return self::SUM($aArgs);
break;
case 10 :
return self::VARFunc($aArgs);
break;
case 11 :
return self::VARP($aArgs);
break;
}
}
return self::$_errorCodes['value'];
} // function SUBTOTAL()
/**
* SQRTPI
*
* Returns the square root of (number * pi).
*
* @param float $number Number
* @return float Square Root of Number * Pi
*/
public static function SQRTPI($number) {
$number = self::flattenSingleValue($number);
if (is_numeric($number)) {
if ($number < 0) {
return self::$_errorCodes['num'];
}
return sqrt($number * M_PI) ;
}
return self::$_errorCodes['value'];
} // function SQRTPI()
/**
* FACT
*
* Returns the factorial of a number.
*
* @param float $factVal Factorial Value
* @return int Factorial
*/
public static function FACT($factVal) {
$factVal = self::flattenSingleValue($factVal);
if (is_numeric($factVal)) {
if ($factVal < 0) {
return self::$_errorCodes['num'];
}
$factLoop = floor($factVal);
if (self::$compatibilityMode == self::COMPATIBILITY_GNUMERIC) {
if ($factVal > $factLoop) {
return self::$_errorCodes['num'];
}
}
$factorial = 1;
while ($factLoop > 1) {
$factorial *= $factLoop--;
}
return $factorial ;
}
return self::$_errorCodes['value'];
} // function FACT()
/**
* FACTDOUBLE
*
* Returns the double factorial of a number.
*
* @param float $factVal Factorial Value
* @return int Double Factorial
*/
public static function FACTDOUBLE($factVal) {
$factLoop = floor(self::flattenSingleValue($factVal));
if (is_numeric($factLoop)) {
if ($factVal < 0) {
return self::$_errorCodes['num'];
}
$factorial = 1;
while ($factLoop > 1) {
$factorial *= $factLoop--;
--$factLoop;
}
return $factorial ;
}
return self::$_errorCodes['value'];
} // function FACTDOUBLE()
/**
* MULTINOMIAL
*
* Returns the ratio of the factorial of a sum of values to the product of factorials.
*
* @param array of mixed Data Series
* @return float
*/
public static function MULTINOMIAL() {
// Loop through arguments
$aArgs = self::flattenArray(func_get_args());
$summer = 0;
$divisor = 1;
foreach ($aArgs as $arg) {
// Is it a numeric value?
if (is_numeric($arg)) {
if ($arg < 1) {
return self::$_errorCodes['num'];
}
$summer += floor($arg);
$divisor *= self::FACT($arg);
} else {
return self::$_errorCodes['value'];
}
}
// Return
if ($summer > 0) {
$summer = self::FACT($summer);
return $summer / $divisor;
}
return 0;
} // function MULTINOMIAL()
/**
* CEILING
*
* Returns number rounded up, away from zero, to the nearest multiple of significance.
*
* @param float $number Number to round
* @param float $significance Significance
* @return float Rounded Number
*/
public static function CEILING($number,$significance=null) {
$number = self::flattenSingleValue($number);
$significance = self::flattenSingleValue($significance);
if ((is_null($significance)) && (self::$compatibilityMode == self::COMPATIBILITY_GNUMERIC)) {
$significance = $number/abs($number);
}
if ((is_numeric($number)) && (is_numeric($significance))) {
if (self::SIGN($number) == self::SIGN($significance)) {
if ($significance == 0.0) {
return 0;
}
return ceil($number / $significance) * $significance;
} else {
return self::$_errorCodes['num'];
}
}
return self::$_errorCodes['value'];
} // function CEILING()
/**
* EVEN
*
* Returns number rounded up to the nearest even integer.
*
* @param float $number Number to round
* @return int Rounded Number
*/
public static function EVEN($number) {
$number = self::flattenSingleValue($number);
if (is_numeric($number)) {
$significance = 2 * self::SIGN($number);
return self::CEILING($number,$significance);
}
return self::$_errorCodes['value'];
} // function EVEN()
/**
* ODD
*
* Returns number rounded up to the nearest odd integer.
*
* @param float $number Number to round
* @return int Rounded Number
*/
public static function ODD($number) {
$number = self::flattenSingleValue($number);
if (is_numeric($number)) {
$significance = self::SIGN($number);
if ($significance == 0) {
return 1;
}
$result = self::CEILING($number,$significance);
if (self::IS_EVEN($result)) {
$result += $significance;
}
return $result;
}
return self::$_errorCodes['value'];
} // function ODD()
/**
* INTVALUE
*
* Casts a floating point value to an integer
*
* @param float $number Number to cast to an integer
* @return integer Integer value
*/
public static function INTVALUE($number) {
$number = self::flattenSingleValue($number);
if (is_numeric($number)) {
return (int) floor($number);
}
return self::$_errorCodes['value'];
} // function INTVALUE()
/**
* ROUNDUP
*
* Rounds a number up to a specified number of decimal places
*
* @param float $number Number to round
* @param int $digits Number of digits to which you want to round $number
* @return float Rounded Number
*/
public static function ROUNDUP($number,$digits) {
$number = self::flattenSingleValue($number);
$digits = self::flattenSingleValue($digits);
if ((is_numeric($number)) && (is_numeric($digits))) {
$significance = pow(10,$digits);
if ($number < 0.0) {
return floor($number * $significance) / $significance;
} else {
return ceil($number * $significance) / $significance;
}
}
return self::$_errorCodes['value'];
} // function ROUNDUP()
/**
* ROUNDDOWN
*
* Rounds a number down to a specified number of decimal places
*
* @param float $number Number to round
* @param int $digits Number of digits to which you want to round $number
* @return float Rounded Number
*/
public static function ROUNDDOWN($number,$digits) {
$number = self::flattenSingleValue($number);
$digits = self::flattenSingleValue($digits);
if ((is_numeric($number)) && (is_numeric($digits))) {
$significance = pow(10,$digits);
if ($number < 0.0) {
return ceil($number * $significance) / $significance;
} else {
return floor($number * $significance) / $significance;
}
}
return self::$_errorCodes['value'];
} // function ROUNDDOWN()
/**
* MROUND
*
* Rounds a number to the nearest multiple of a specified value
*
* @param float $number Number to round
* @param int $multiple Multiple to which you want to round $number
* @return float Rounded Number
*/
public static function MROUND($number,$multiple) {
$number = self::flattenSingleValue($number);
$multiple = self::flattenSingleValue($multiple);
if ((is_numeric($number)) && (is_numeric($multiple))) {
if ($multiple == 0) {
return 0;
}
if ((self::SIGN($number)) == (self::SIGN($multiple))) {
$multiplier = 1 / $multiple;
return round($number * $multiplier) / $multiplier;
}
return self::$_errorCodes['num'];
}
return self::$_errorCodes['value'];
} // function MROUND()
/**
* SIGN
*
* Determines the sign of a number. Returns 1 if the number is positive, zero (0)
* if the number is 0, and -1 if the number is negative.
*
* @param float $number Number to round
* @return int sign value
*/
public static function SIGN($number) {
$number = self::flattenSingleValue($number);
if (is_numeric($number)) {
if ($number == 0.0) {
return 0;
}
return $number / abs($number);
}
return self::$_errorCodes['value'];
} // function SIGN()
/**
* FLOOR
*
* Rounds number down, toward zero, to the nearest multiple of significance.
*
* @param float $number Number to round
* @param float $significance Significance
* @return float Rounded Number
*/
public static function FLOOR($number,$significance=null) {
$number = self::flattenSingleValue($number);
$significance = self::flattenSingleValue($significance);
if ((is_null($significance)) && (self::$compatibilityMode == self::COMPATIBILITY_GNUMERIC)) {
$significance = $number/abs($number);
}
if ((is_numeric($number)) && (is_numeric($significance))) {
if ((float) $significance == 0.0) {
return self::$_errorCodes['divisionbyzero'];
}
if (self::SIGN($number) == self::SIGN($significance)) {
return floor($number / $significance) * $significance;
} else {
return self::$_errorCodes['num'];
}
}
return self::$_errorCodes['value'];
} // function FLOOR()
/**
* PERMUT
*
* Returns the number of permutations for a given number of objects that can be
* selected from number objects. A permutation is any set or subset of objects or
* events where internal order is significant. Permutations are different from
* combinations, for which the internal order is not significant. Use this function
* for lottery-style probability calculations.
*
* @param int $numObjs Number of different objects
* @param int $numInSet Number of objects in each permutation
* @return int Number of permutations
*/
public static function PERMUT($numObjs,$numInSet) {
$numObjs = self::flattenSingleValue($numObjs);
$numInSet = self::flattenSingleValue($numInSet);
if ((is_numeric($numObjs)) && (is_numeric($numInSet))) {
$numInSet = floor($numInSet);
if ($numObjs < $numInSet) {
return self::$_errorCodes['num'];
}
return round(self::FACT($numObjs) / self::FACT($numObjs - $numInSet));
}
return self::$_errorCodes['value'];
} // function PERMUT()
/**
* COMBIN
*
* Returns the number of combinations for a given number of items. Use COMBIN to
* determine the total possible number of groups for a given number of items.
*
* @param int $numObjs Number of different objects
* @param int $numInSet Number of objects in each combination
* @return int Number of combinations
*/
public static function COMBIN($numObjs,$numInSet) {
$numObjs = self::flattenSingleValue($numObjs);
$numInSet = self::flattenSingleValue($numInSet);
if ((is_numeric($numObjs)) && (is_numeric($numInSet))) {
if ($numObjs < $numInSet) {
return self::$_errorCodes['num'];
} elseif ($numInSet < 0) {
return self::$_errorCodes['num'];
}
return round(self::FACT($numObjs) / self::FACT($numObjs - $numInSet)) / self::FACT($numInSet);
}
return self::$_errorCodes['value'];
} // function COMBIN()
/**
* SERIESSUM
*
* Returns the sum of a power series
*
* @param float $x Input value to the power series
* @param float $n Initial power to which you want to raise $x
* @param float $m Step by which to increase $n for each term in the series
* @param array of mixed Data Series
* @return float
*/
public static function SERIESSUM() {
// Return value
$returnValue = 0;
// Loop through arguments
$aArgs = self::flattenArray(func_get_args());
$x = array_shift($aArgs);
$n = array_shift($aArgs);
$m = array_shift($aArgs);
if ((is_numeric($x)) && (is_numeric($n)) && (is_numeric($m))) {
// Calculate
$i = 0;
foreach($aArgs as $arg) {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$returnValue += $arg * pow($x,$n + ($m * $i++));
} else {
return self::$_errorCodes['value'];
}
}
// Return
return $returnValue;
}
return self::$_errorCodes['value'];
} // function SERIESSUM()
/**
* STANDARDIZE
*
* Returns a normalized value from a distribution characterized by mean and standard_dev.
*
* @param float $value Value to normalize
* @param float $mean Mean Value
* @param float $stdDev Standard Deviation
* @return float Standardized value
*/
public static function STANDARDIZE($value,$mean,$stdDev) {
$value = self::flattenSingleValue($value);
$mean = self::flattenSingleValue($mean);
$stdDev = self::flattenSingleValue($stdDev);
if ((is_numeric($value)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
if ($stdDev <= 0) {
return self::$_errorCodes['num'];
}
return ($value - $mean) / $stdDev ;
}
return self::$_errorCodes['value'];
} // function STANDARDIZE()
//
// Private method to return an array of the factors of the input value
//
private static function _factors($value) {
$startVal = floor(sqrt($value));
$factorArray = array();
for ($i = $startVal; $i > 1; --$i) {
if (($value % $i) == 0) {
$factorArray = array_merge($factorArray,self::_factors($value / $i));
$factorArray = array_merge($factorArray,self::_factors($i));
if ($i <= sqrt($value)) {
break;
}
}
}
if (count($factorArray) > 0) {
rsort($factorArray);
return $factorArray;
} else {
return array((integer) $value);
}
} // function _factors()
/**
* LCM
*
* Returns the lowest common multiplier of a series of numbers
*
* @param $array Values to calculate the Lowest Common Multiplier
* @return int Lowest Common Multiplier
*/
public static function LCM() {
$aArgs = self::flattenArray(func_get_args());
$returnValue = 1;
$allPoweredFactors = array();
foreach($aArgs as $value) {
if (!is_numeric($value)) {
return self::$_errorCodes['value'];
}
if ($value == 0) {
return 0;
} elseif ($value < 0) {
return self::$_errorCodes['num'];
}
$myFactors = self::_factors(floor($value));
$myCountedFactors = array_count_values($myFactors);
$myPoweredFactors = array();
foreach($myCountedFactors as $myCountedFactor => $myCountedPower) {
$myPoweredFactors[$myCountedFactor] = pow($myCountedFactor,$myCountedPower);
}
foreach($myPoweredFactors as $myPoweredValue => $myPoweredFactor) {
if (array_key_exists($myPoweredValue,$allPoweredFactors)) {
if ($allPoweredFactors[$myPoweredValue] < $myPoweredFactor) {
$allPoweredFactors[$myPoweredValue] = $myPoweredFactor;
}
} else {
$allPoweredFactors[$myPoweredValue] = $myPoweredFactor;
}
}
}
foreach($allPoweredFactors as $allPoweredFactor) {
$returnValue *= (integer) $allPoweredFactor;
}
return $returnValue;
} // function LCM()
/**
* GCD
*
* Returns the greatest common divisor of a series of numbers
*
* @param $array Values to calculate the Greatest Common Divisor
* @return int Greatest Common Divisor
*/
public static function GCD() {
$aArgs = self::flattenArray(func_get_args());
$returnValue = 1;
$allPoweredFactors = array();
foreach($aArgs as $value) {
if ($value == 0) {
break;
}
$myFactors = self::_factors($value);
$myCountedFactors = array_count_values($myFactors);
$allValuesFactors[] = $myCountedFactors;
}
$allValuesCount = count($allValuesFactors);
$mergedArray = $allValuesFactors[0];
for ($i=1;$i < $allValuesCount; ++$i) {
$mergedArray = array_intersect_key($mergedArray,$allValuesFactors[$i]);
}
$mergedArrayValues = count($mergedArray);
if ($mergedArrayValues == 0) {
return $returnValue;
} elseif ($mergedArrayValues > 1) {
foreach($mergedArray as $mergedKey => $mergedValue) {
foreach($allValuesFactors as $highestPowerTest) {
foreach($highestPowerTest as $testKey => $testValue) {
if (($testKey == $mergedKey) && ($testValue < $mergedValue)) {
$mergedArray[$mergedKey] = $testValue;
$mergedValue = $testValue;
}
}
}
}
$returnValue = 1;
foreach($mergedArray as $key => $value) {
$returnValue *= pow($key,$value);
}
return $returnValue;
} else {
$keys = array_keys($mergedArray);
$key = $keys[0];
$value = $mergedArray[$key];
foreach($allValuesFactors as $testValue) {
foreach($testValue as $mergedKey => $mergedValue) {
if (($mergedKey == $key) && ($mergedValue < $value)) {
$value = $mergedValue;
}
}
}
return pow($key,$value);
}
} // function GCD()
/**
* BINOMDIST
*
* Returns the individual term binomial distribution probability. Use BINOMDIST in problems with
* a fixed number of tests or trials, when the outcomes of any trial are only success or failure,
* when trials are independent, and when the probability of success is constant throughout the
* experiment. For example, BINOMDIST can calculate the probability that two of the next three
* babies born are male.
*
* @param float $value Number of successes in trials
* @param float $trials Number of trials
* @param float $probability Probability of success on each trial
* @param boolean $cumulative
* @return float
*
* @todo Cumulative distribution function
*
*/
public static function BINOMDIST($value, $trials, $probability, $cumulative) {
$value = floor(self::flattenSingleValue($value));
$trials = floor(self::flattenSingleValue($trials));
$probability = self::flattenSingleValue($probability);
if ((is_numeric($value)) && (is_numeric($trials)) && (is_numeric($probability))) {
if (($value < 0) || ($value > $trials)) {
return self::$_errorCodes['num'];
}
if (($probability < 0) || ($probability > 1)) {
return self::$_errorCodes['num'];
}
if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
if ($cumulative) {
$summer = 0;
for ($i = 0; $i <= $value; ++$i) {
$summer += self::COMBIN($trials,$i) * pow($probability,$i) * pow(1 - $probability,$trials - $i);
}
return $summer;
} else {
return self::COMBIN($trials,$value) * pow($probability,$value) * pow(1 - $probability,$trials - $value) ;
}
}
}
return self::$_errorCodes['value'];
} // function BINOMDIST()
/**
* NEGBINOMDIST
*
* Returns the negative binomial distribution. NEGBINOMDIST returns the probability that
* there will be number_f failures before the number_s-th success, when the constant
* probability of a success is probability_s. This function is similar to the binomial
* distribution, except that the number of successes is fixed, and the number of trials is
* variable. Like the binomial, trials are assumed to be independent.
*
* @param float $failures Number of Failures
* @param float $successes Threshold number of Successes
* @param float $probability Probability of success on each trial
* @return float
*
*/
public static function NEGBINOMDIST($failures, $successes, $probability) {
$failures = floor(self::flattenSingleValue($failures));
$successes = floor(self::flattenSingleValue($successes));
$probability = self::flattenSingleValue($probability);
if ((is_numeric($failures)) && (is_numeric($successes)) && (is_numeric($probability))) {
if (($failures < 0) || ($successes < 1)) {
return self::$_errorCodes['num'];
}
if (($probability < 0) || ($probability > 1)) {
return self::$_errorCodes['num'];
}
if (self::$compatibilityMode == self::COMPATIBILITY_GNUMERIC) {
if (($failures + $successes - 1) <= 0) {
return self::$_errorCodes['num'];
}
}
return (self::COMBIN($failures + $successes - 1,$successes - 1)) * (pow($probability,$successes)) * (pow(1 - $probability,$failures)) ;
}
return self::$_errorCodes['value'];
} // function NEGBINOMDIST()
/**
* CRITBINOM
*
* Returns the smallest value for which the cumulative binomial distribution is greater
* than or equal to a criterion value
*
* See http://support.microsoft.com/kb/828117/ for details of the algorithm used
*
* @param float $trials number of Bernoulli trials
* @param float $probability probability of a success on each trial
* @param float $alpha criterion value
* @return int
*
* @todo Warning. This implementation differs from the algorithm detailed on the MS
* web site in that $CumPGuessMinus1 = $CumPGuess - 1 rather than $CumPGuess - $PGuess
* This eliminates a potential endless loop error, but may have an adverse affect on the
* accuracy of the function (although all my tests have so far returned correct results).
*
*/
public static function CRITBINOM($trials, $probability, $alpha) {
$trials = floor(self::flattenSingleValue($trials));
$probability = self::flattenSingleValue($probability);
$alpha = self::flattenSingleValue($alpha);
if ((is_numeric($trials)) && (is_numeric($probability)) && (is_numeric($alpha))) {
if ($trials < 0) {
return self::$_errorCodes['num'];
}
if (($probability < 0) || ($probability > 1)) {
return self::$_errorCodes['num'];
}
if (($alpha < 0) || ($alpha > 1)) {
return self::$_errorCodes['num'];
}
if ($alpha <= 0.5) {
$t = sqrt(log(1 / ($alpha * $alpha)));
$trialsApprox = 0 - ($t + (2.515517 + 0.802853 * $t + 0.010328 * $t * $t) / (1 + 1.432788 * $t + 0.189269 * $t * $t + 0.001308 * $t * $t * $t));
} else {
$t = sqrt(log(1 / pow(1 - $alpha,2)));
$trialsApprox = $t - (2.515517 + 0.802853 * $t + 0.010328 * $t * $t) / (1 + 1.432788 * $t + 0.189269 * $t * $t + 0.001308 * $t * $t * $t);
}
$Guess = floor($trials * $probability + $trialsApprox * sqrt($trials * $probability * (1 - $probability)));
if ($Guess < 0) {
$Guess = 0;
} elseif ($Guess > $trials) {
$Guess = $trials;
}
$TotalUnscaledProbability = $UnscaledPGuess = $UnscaledCumPGuess = 0.0;
$EssentiallyZero = 10e-12;
$m = floor($trials * $probability);
++$TotalUnscaledProbability;
if ($m == $Guess) { ++$UnscaledPGuess; }
if ($m <= $Guess) { ++$UnscaledCumPGuess; }
$PreviousValue = 1;
$Done = False;
$k = $m + 1;
while ((!$Done) && ($k <= $trials)) {
$CurrentValue = $PreviousValue * ($trials - $k + 1) * $probability / ($k * (1 - $probability));
$TotalUnscaledProbability += $CurrentValue;
if ($k == $Guess) { $UnscaledPGuess += $CurrentValue; }
if ($k <= $Guess) { $UnscaledCumPGuess += $CurrentValue; }
if ($CurrentValue <= $EssentiallyZero) { $Done = True; }
$PreviousValue = $CurrentValue;
++$k;
}
$PreviousValue = 1;
$Done = False;
$k = $m - 1;
while ((!$Done) && ($k >= 0)) {
$CurrentValue = $PreviousValue * $k + 1 * (1 - $probability) / (($trials - $k) * $probability);
$TotalUnscaledProbability += $CurrentValue;
if ($k == $Guess) { $UnscaledPGuess += $CurrentValue; }
if ($k <= $Guess) { $UnscaledCumPGuess += $CurrentValue; }
if ($CurrentValue <= $EssentiallyZero) { $Done = True; }
$PreviousValue = $CurrentValue;
--$k;
}
$PGuess = $UnscaledPGuess / $TotalUnscaledProbability;
$CumPGuess = $UnscaledCumPGuess / $TotalUnscaledProbability;
// $CumPGuessMinus1 = $CumPGuess - $PGuess;
$CumPGuessMinus1 = $CumPGuess - 1;
while (True) {
if (($CumPGuessMinus1 < $alpha) && ($CumPGuess >= $alpha)) {
return $Guess;
} elseif (($CumPGuessMinus1 < $alpha) && ($CumPGuess < $alpha)) {
$PGuessPlus1 = $PGuess * ($trials - $Guess) * $probability / $Guess / (1 - $probability);
$CumPGuessMinus1 = $CumPGuess;
$CumPGuess = $CumPGuess + $PGuessPlus1;
$PGuess = $PGuessPlus1;
++$Guess;
} elseif (($CumPGuessMinus1 >= $alpha) && ($CumPGuess >= $alpha)) {
$PGuessMinus1 = $PGuess * $Guess * (1 - $probability) / ($trials - $Guess + 1) / $probability;
$CumPGuess = $CumPGuessMinus1;
$CumPGuessMinus1 = $CumPGuessMinus1 - $PGuess;
$PGuess = $PGuessMinus1;
--$Guess;
}
}
}
return self::$_errorCodes['value'];
} // function CRITBINOM()
/**
* CHIDIST
*
* Returns the one-tailed probability of the chi-squared distribution.
*
* @param float $value Value for the function
* @param float $degrees degrees of freedom
* @return float
*/
public static function CHIDIST($value, $degrees) {
$value = self::flattenSingleValue($value);
$degrees = floor(self::flattenSingleValue($degrees));
if ((is_numeric($value)) && (is_numeric($degrees))) {
if ($degrees < 1) {
return self::$_errorCodes['num'];
}
if ($value < 0) {
if (self::$compatibilityMode == self::COMPATIBILITY_GNUMERIC) {
return 1;
}
return self::$_errorCodes['num'];
}
return 1 - (self::_incompleteGamma($degrees/2,$value/2) / self::_gamma($degrees/2));
}
return self::$_errorCodes['value'];
} // function CHIDIST()
/**
* CHIINV
*
* Returns the one-tailed probability of the chi-squared distribution.
*
* @param float $probability Probability for the function
* @param float $degrees degrees of freedom
* @return float
*/
public static function CHIINV($probability, $degrees) {
$probability = self::flattenSingleValue($probability);
$degrees = floor(self::flattenSingleValue($degrees));
if ((is_numeric($probability)) && (is_numeric($degrees))) {
$xLo = 100;
$xHi = 0;
$x = $xNew = 1;
$dx = 1;
$i = 0;
while ((abs($dx) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
// Apply Newton-Raphson step
$result = self::CHIDIST($x, $degrees);
$error = $result - $probability;
if ($error == 0.0) {
$dx = 0;
} elseif ($error < 0.0) {
$xLo = $x;
} else {
$xHi = $x;
}
// Avoid division by zero
if ($result != 0.0) {
$dx = $error / $result;
$xNew = $x - $dx;
}
// If the NR fails to converge (which for example may be the
// case if the initial guess is too rough) we apply a bisection
// step to determine a more narrow interval around the root.
if (($xNew < $xLo) || ($xNew > $xHi) || ($result == 0.0)) {
$xNew = ($xLo + $xHi) / 2;
$dx = $xNew - $x;
}
$x = $xNew;
}
if ($i == MAX_ITERATIONS) {
return self::$_errorCodes['na'];
}
return round($x,12);
}
return self::$_errorCodes['value'];
} // function CHIINV()
/**
* EXPONDIST
*
* Returns the exponential distribution. Use EXPONDIST to model the time between events,
* such as how long an automated bank teller takes to deliver cash. For example, you can
* use EXPONDIST to determine the probability that the process takes at most 1 minute.
*
* @param float $value Value of the function
* @param float $lambda The parameter value
* @param boolean $cumulative
* @return float
*/
public static function EXPONDIST($value, $lambda, $cumulative) {
$value = self::flattenSingleValue($value);
$lambda = self::flattenSingleValue($lambda);
$cumulative = self::flattenSingleValue($cumulative);
if ((is_numeric($value)) && (is_numeric($lambda))) {
if (($value < 0) || ($lambda < 0)) {
return self::$_errorCodes['num'];
}
if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
if ($cumulative) {
return 1 - exp(0-$value*$lambda);
} else {
return $lambda * exp(0-$value*$lambda);
}
}
}
return self::$_errorCodes['value'];
} // function EXPONDIST()
/**
* FISHER
*
* Returns the Fisher transformation at x. This transformation produces a function that
* is normally distributed rather than skewed. Use this function to perform hypothesis
* testing on the correlation coefficient.
*
* @param float $value
* @return float
*/
public static function FISHER($value) {
$value = self::flattenSingleValue($value);
if (is_numeric($value)) {
if (($value <= -1) || ($value >= 1)) {
return self::$_errorCodes['num'];
}
return 0.5 * log((1+$value)/(1-$value));
}
return self::$_errorCodes['value'];
} // function FISHER()
/**
* FISHERINV
*
* Returns the inverse of the Fisher transformation. Use this transformation when
* analyzing correlations between ranges or arrays of data. If y = FISHER(x), then
* FISHERINV(y) = x.
*
* @param float $value
* @return float
*/
public static function FISHERINV($value) {
$value = self::flattenSingleValue($value);
if (is_numeric($value)) {
return (exp(2 * $value) - 1) / (exp(2 * $value) + 1);
}
return self::$_errorCodes['value'];
} // function FISHERINV()
// Function cache for _logBeta function
private static $_logBetaCache_p = 0.0;
private static $_logBetaCache_q = 0.0;
private static $_logBetaCache_result = 0.0;
/**
* The natural logarithm of the beta function.
* @param p require p>0
* @param q require q>0
* @return 0 if p<=0, q<=0 or p+q>2.55E305 to avoid errors and over/underflow
* @author Jaco van Kooten
*/
private static function _logBeta($p, $q) {
if ($p != self::$_logBetaCache_p || $q != self::$_logBetaCache_q) {
self::$_logBetaCache_p = $p;
self::$_logBetaCache_q = $q;
if (($p <= 0.0) || ($q <= 0.0) || (($p + $q) > LOG_GAMMA_X_MAX_VALUE)) {
self::$_logBetaCache_result = 0.0;
} else {
self::$_logBetaCache_result = self::_logGamma($p) + self::_logGamma($q) - self::_logGamma($p + $q);
}
}
return self::$_logBetaCache_result;
} // function _logBeta()
/**
* Evaluates of continued fraction part of incomplete beta function.
* Based on an idea from Numerical Recipes (W.H. Press et al, 1992).
* @author Jaco van Kooten
*/
private static function _betaFraction($x, $p, $q) {
$c = 1.0;
$sum_pq = $p + $q;
$p_plus = $p + 1.0;
$p_minus = $p - 1.0;
$h = 1.0 - $sum_pq * $x / $p_plus;
if (abs($h) < XMININ) {
$h = XMININ;
}
$h = 1.0 / $h;
$frac = $h;
$m = 1;
$delta = 0.0;
while ($m <= MAX_ITERATIONS && abs($delta-1.0) > PRECISION ) {
$m2 = 2 * $m;
// even index for d
$d = $m * ($q - $m) * $x / ( ($p_minus + $m2) * ($p + $m2));
$h = 1.0 + $d * $h;
if (abs($h) < XMININ) {
$h = XMININ;
}
$h = 1.0 / $h;
$c = 1.0 + $d / $c;
if (abs($c) < XMININ) {
$c = XMININ;
}
$frac *= $h * $c;
// odd index for d
$d = -($p + $m) * ($sum_pq + $m) * $x / (($p + $m2) * ($p_plus + $m2));
$h = 1.0 + $d * $h;
if (abs($h) < XMININ) {
$h = XMININ;
}
$h = 1.0 / $h;
$c = 1.0 + $d / $c;
if (abs($c) < XMININ) {
$c = XMININ;
}
$delta = $h * $c;
$frac *= $delta;
++$m;
}
return $frac;
} // function _betaFraction()
/**
* logGamma function
*
* @version 1.1
* @author Jaco van Kooten
*
* Original author was Jaco van Kooten. Ported to PHP by Paul Meagher.
*
* The natural logarithm of the gamma function.
* Based on public domain NETLIB (Fortran) code by W. J. Cody and L. Stoltz
* Applied Mathematics Division
* Argonne National Laboratory
* Argonne, IL 60439
*
* References:
* <ol>
* <li>W. J. Cody and K. E. Hillstrom, 'Chebyshev Approximations for the Natural
* Logarithm of the Gamma Function,' Math. Comp. 21, 1967, pp. 198-203.</li>
* <li>K. E. Hillstrom, ANL/AMD Program ANLC366S, DGAMMA/DLGAMA, May, 1969.</li>
* <li>Hart, Et. Al., Computer Approximations, Wiley and sons, New York, 1968.</li>
* </ol>
*
*
* From the original documentation:
*
*
* This routine calculates the LOG(GAMMA) function for a positive real argument X.
* Computation is based on an algorithm outlined in references 1 and 2.
* The program uses rational functions that theoretically approximate LOG(GAMMA)
* to at least 18 significant decimal digits. The approximation for X > 12 is from
* reference 3, while approximations for X < 12.0 are similar to those in reference
* 1, but are unpublished. The accuracy achieved depends on the arithmetic system,
* the compiler, the intrinsic functions, and proper selection of the
* machine-dependent constants.
*
*
* Error returns:
* The program returns the value XINF for X .LE. 0.0 or when overflow would occur.
* The computation is believed to be free of underflow and overflow.
*
* @return MAX_VALUE for x < 0.0 or when overflow would occur, i.e. x > 2.55E305
*/
// Function cache for logGamma
private static $_logGammaCache_result = 0.0;
private static $_logGammaCache_x = 0.0;
private static function _logGamma($x) {
// Log Gamma related constants
static $lg_d1 = -0.5772156649015328605195174;
static $lg_d2 = 0.4227843350984671393993777;
static $lg_d4 = 1.791759469228055000094023;
static $lg_p1 = array( 4.945235359296727046734888,
201.8112620856775083915565,
2290.838373831346393026739,
11319.67205903380828685045,
28557.24635671635335736389,
38484.96228443793359990269,
26377.48787624195437963534,
7225.813979700288197698961 );
static $lg_p2 = array( 4.974607845568932035012064,
542.4138599891070494101986,
15506.93864978364947665077,
184793.2904445632425417223,
1088204.76946882876749847,
3338152.967987029735917223,
5106661.678927352456275255,
3074109.054850539556250927 );
static $lg_p4 = array( 14745.02166059939948905062,
2426813.369486704502836312,
121475557.4045093227939592,
2663432449.630976949898078,
29403789566.34553899906876,
170266573776.5398868392998,
492612579337.743088758812,
560625185622.3951465078242 );
static $lg_q1 = array( 67.48212550303777196073036,
1113.332393857199323513008,
7738.757056935398733233834,
27639.87074403340708898585,
54993.10206226157329794414,
61611.22180066002127833352,
36351.27591501940507276287,
8785.536302431013170870835 );
static $lg_q2 = array( 183.0328399370592604055942,
7765.049321445005871323047,
133190.3827966074194402448,
1136705.821321969608938755,
5267964.117437946917577538,
13467014.54311101692290052,
17827365.30353274213975932,
9533095.591844353613395747 );
static $lg_q4 = array( 2690.530175870899333379843,
639388.5654300092398984238,
41355999.30241388052042842,
1120872109.61614794137657,
14886137286.78813811542398,
101680358627.2438228077304,
341747634550.7377132798597,
446315818741.9713286462081 );
static $lg_c = array( -0.001910444077728,
8.4171387781295e-4,
-5.952379913043012e-4,
7.93650793500350248e-4,
-0.002777777777777681622553,
0.08333333333333333331554247,
0.0057083835261 );
// Rough estimate of the fourth root of logGamma_xBig
static $lg_frtbig = 2.25e76;
static $pnt68 = 0.6796875;
if ($x == self::$_logGammaCache_x) {
return self::$_logGammaCache_result;
}
$y = $x;
if ($y > 0.0 && $y <= LOG_GAMMA_X_MAX_VALUE) {
if ($y <= EPS) {
$res = -log(y);
} elseif ($y <= 1.5) {
// ---------------------
// EPS .LT. X .LE. 1.5
// ---------------------
if ($y < $pnt68) {
$corr = -log($y);
$xm1 = $y;
} else {
$corr = 0.0;
$xm1 = $y - 1.0;
}
if ($y <= 0.5 || $y >= $pnt68) {
$xden = 1.0;
$xnum = 0.0;
for ($i = 0; $i < 8; ++$i) {
$xnum = $xnum * $xm1 + $lg_p1[$i];
$xden = $xden * $xm1 + $lg_q1[$i];
}
$res = $corr + $xm1 * ($lg_d1 + $xm1 * ($xnum / $xden));
} else {
$xm2 = $y - 1.0;
$xden = 1.0;
$xnum = 0.0;
for ($i = 0; $i < 8; ++$i) {
$xnum = $xnum * $xm2 + $lg_p2[$i];
$xden = $xden * $xm2 + $lg_q2[$i];
}
$res = $corr + $xm2 * ($lg_d2 + $xm2 * ($xnum / $xden));
}
} elseif ($y <= 4.0) {
// ---------------------
// 1.5 .LT. X .LE. 4.0
// ---------------------
$xm2 = $y - 2.0;
$xden = 1.0;
$xnum = 0.0;
for ($i = 0; $i < 8; ++$i) {
$xnum = $xnum * $xm2 + $lg_p2[$i];
$xden = $xden * $xm2 + $lg_q2[$i];
}
$res = $xm2 * ($lg_d2 + $xm2 * ($xnum / $xden));
} elseif ($y <= 12.0) {
// ----------------------
// 4.0 .LT. X .LE. 12.0
// ----------------------
$xm4 = $y - 4.0;
$xden = -1.0;
$xnum = 0.0;
for ($i = 0; $i < 8; ++$i) {
$xnum = $xnum * $xm4 + $lg_p4[$i];
$xden = $xden * $xm4 + $lg_q4[$i];
}
$res = $lg_d4 + $xm4 * ($xnum / $xden);
} else {
// ---------------------------------
// Evaluate for argument .GE. 12.0
// ---------------------------------
$res = 0.0;
if ($y <= $lg_frtbig) {
$res = $lg_c[6];
$ysq = $y * $y;
for ($i = 0; $i < 6; ++$i)
$res = $res / $ysq + $lg_c[$i];
}
$res /= $y;
$corr = log($y);
$res = $res + log(SQRT2PI) - 0.5 * $corr;
$res += $y * ($corr - 1.0);
}
} else {
// --------------------------
// Return for bad arguments
// --------------------------
$res = MAX_VALUE;
}
// ------------------------------
// Final adjustments and return
// ------------------------------
self::$_logGammaCache_x = $x;
self::$_logGammaCache_result = $res;
return $res;
} // function _logGamma()
/**
* Beta function.
*
* @author Jaco van Kooten
*
* @param p require p>0
* @param q require q>0
* @return 0 if p<=0, q<=0 or p+q>2.55E305 to avoid errors and over/underflow
*/
private static function _beta($p, $q) {
if ($p <= 0.0 || $q <= 0.0 || ($p + $q) > LOG_GAMMA_X_MAX_VALUE) {
return 0.0;
} else {
return exp(self::_logBeta($p, $q));
}
} // function _beta()
/**
* Incomplete beta function
*
* @author Jaco van Kooten
* @author Paul Meagher
*
* The computation is based on formulas from Numerical Recipes, Chapter 6.4 (W.H. Press et al, 1992).
* @param x require 0<=x<=1
* @param p require p>0
* @param q require q>0
* @return 0 if x<0, p<=0, q<=0 or p+q>2.55E305 and 1 if x>1 to avoid errors and over/underflow
*/
private static function _incompleteBeta($x, $p, $q) {
if ($x <= 0.0) {
return 0.0;
} elseif ($x >= 1.0) {
return 1.0;
} elseif (($p <= 0.0) || ($q <= 0.0) || (($p + $q) > LOG_GAMMA_X_MAX_VALUE)) {
return 0.0;
}
$beta_gam = exp((0 - self::_logBeta($p, $q)) + $p * log($x) + $q * log(1.0 - $x));
if ($x < ($p + 1.0) / ($p + $q + 2.0)) {
return $beta_gam * self::_betaFraction($x, $p, $q) / $p;
} else {
return 1.0 - ($beta_gam * self::_betaFraction(1 - $x, $q, $p) / $q);
}
} // function _incompleteBeta()
/**
* BETADIST
*
* Returns the beta distribution.
*
* @param float $value Value at which you want to evaluate the distribution
* @param float $alpha Parameter to the distribution
* @param float $beta Parameter to the distribution
* @param boolean $cumulative
* @return float
*
*/
public static function BETADIST($value,$alpha,$beta,$rMin=0,$rMax=1) {
$value = self::flattenSingleValue($value);
$alpha = self::flattenSingleValue($alpha);
$beta = self::flattenSingleValue($beta);
$rMin = self::flattenSingleValue($rMin);
$rMax = self::flattenSingleValue($rMax);
if ((is_numeric($value)) && (is_numeric($alpha)) && (is_numeric($beta)) && (is_numeric($rMin)) && (is_numeric($rMax))) {
if (($value < $rMin) || ($value > $rMax) || ($alpha <= 0) || ($beta <= 0) || ($rMin == $rMax)) {
return self::$_errorCodes['num'];
}
if ($rMin > $rMax) {
$tmp = $rMin;
$rMin = $rMax;
$rMax = $tmp;
}
$value -= $rMin;
$value /= ($rMax - $rMin);
return self::_incompleteBeta($value,$alpha,$beta);
}
return self::$_errorCodes['value'];
} // function BETADIST()
/**
* BETAINV
*
* Returns the inverse of the beta distribution.
*
* @param float $probability Probability at which you want to evaluate the distribution
* @param float $alpha Parameter to the distribution
* @param float $beta Parameter to the distribution
* @param boolean $cumulative
* @return float
*
*/
public static function BETAINV($probability,$alpha,$beta,$rMin=0,$rMax=1) {
$probability = self::flattenSingleValue($probability);
$alpha = self::flattenSingleValue($alpha);
$beta = self::flattenSingleValue($beta);
$rMin = self::flattenSingleValue($rMin);
$rMax = self::flattenSingleValue($rMax);
if ((is_numeric($probability)) && (is_numeric($alpha)) && (is_numeric($beta)) && (is_numeric($rMin)) && (is_numeric($rMax))) {
if (($alpha <= 0) || ($beta <= 0) || ($rMin == $rMax) || ($probability <= 0) || ($probability > 1)) {
return self::$_errorCodes['num'];
}
if ($rMin > $rMax) {
$tmp = $rMin;
$rMin = $rMax;
$rMax = $tmp;
}
$a = 0;
$b = 2;
$i = 0;
while ((($b - $a) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
$guess = ($a + $b) / 2;
$result = self::BETADIST($guess, $alpha, $beta);
if (($result == $probability) || ($result == 0)) {
$b = $a;
} elseif ($result > $probability) {
$b = $guess;
} else {
$a = $guess;
}
}
if ($i == MAX_ITERATIONS) {
return self::$_errorCodes['na'];
}
return round($rMin + $guess * ($rMax - $rMin),12);
}
return self::$_errorCodes['value'];
} // function BETAINV()
//
// Private implementation of the incomplete Gamma function
//
private static function _incompleteGamma($a,$x) {
static $max = 32;
$summer = 0;
for ($n=0; $n<=$max; ++$n) {
$divisor = $a;
for ($i=1; $i<=$n; ++$i) {
$divisor *= ($a + $i);
}
$summer += (pow($x,$n) / $divisor);
}
return pow($x,$a) * exp(0-$x) * $summer;
} // function _incompleteGamma()
//
// Private implementation of the Gamma function
//
private static function _gamma($data) {
if ($data == 0.0) return 0;
static $p0 = 1.000000000190015;
static $p = array ( 1 => 76.18009172947146,
2 => -86.50532032941677,
3 => 24.01409824083091,
4 => -1.231739572450155,
5 => 1.208650973866179e-3,
6 => -5.395239384953e-6
);
$y = $x = $data;
$tmp = $x + 5.5;
$tmp -= ($x + 0.5) * log($tmp);
$summer = $p0;
for ($j=1;$j<=6;++$j) {
$summer += ($p[$j] / ++$y);
}
return exp(0 - $tmp + log(SQRT2PI * $summer / $x));
} // function _gamma()
/**
* GAMMADIST
*
* Returns the gamma distribution.
*
* @param float $value Value at which you want to evaluate the distribution
* @param float $a Parameter to the distribution
* @param float $b Parameter to the distribution
* @param boolean $cumulative
* @return float
*
*/
public static function GAMMADIST($value,$a,$b,$cumulative) {
$value = self::flattenSingleValue($value);
$a = self::flattenSingleValue($a);
$b = self::flattenSingleValue($b);
if ((is_numeric($value)) && (is_numeric($a)) && (is_numeric($b))) {
if (($value < 0) || ($a <= 0) || ($b <= 0)) {
return self::$_errorCodes['num'];
}
if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
if ($cumulative) {
return self::_incompleteGamma($a,$value / $b) / self::_gamma($a);
} else {
return (1 / (pow($b,$a) * self::_gamma($a))) * pow($value,$a-1) * exp(0-($value / $b));
}
}
}
return self::$_errorCodes['value'];
} // function GAMMADIST()
/**
* GAMMAINV
*
* Returns the inverse of the beta distribution.
*
* @param float $probability Probability at which you want to evaluate the distribution
* @param float $alpha Parameter to the distribution
* @param float $beta Parameter to the distribution
* @return float
*
*/
public static function GAMMAINV($probability,$alpha,$beta) {
$probability = self::flattenSingleValue($probability);
$alpha = self::flattenSingleValue($alpha);
$beta = self::flattenSingleValue($beta);
if ((is_numeric($probability)) && (is_numeric($alpha)) && (is_numeric($beta))) {
if (($alpha <= 0) || ($beta <= 0) || ($probability < 0) || ($probability > 1)) {
return self::$_errorCodes['num'];
}
$xLo = 0;
$xHi = $alpha * $beta * 5;
$x = $xNew = 1;
$error = $pdf = 0;
$dx = 1024;
$i = 0;
while ((abs($dx) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
// Apply Newton-Raphson step
$error = self::GAMMADIST($x, $alpha, $beta, True) - $probability;
if ($error < 0.0) {
$xLo = $x;
} else {
$xHi = $x;
}
$pdf = self::GAMMADIST($x, $alpha, $beta, False);
// Avoid division by zero
if ($pdf != 0.0) {
$dx = $error / $pdf;
$xNew = $x - $dx;
}
// If the NR fails to converge (which for example may be the
// case if the initial guess is too rough) we apply a bisection
// step to determine a more narrow interval around the root.
if (($xNew < $xLo) || ($xNew > $xHi) || ($pdf == 0.0)) {
$xNew = ($xLo + $xHi) / 2;
$dx = $xNew - $x;
}
$x = $xNew;
}
if ($i == MAX_ITERATIONS) {
return self::$_errorCodes['na'];
}
return $x;
}
return self::$_errorCodes['value'];
} // function GAMMAINV()
/**
* GAMMALN
*
* Returns the natural logarithm of the gamma function.
*
* @param float $value
* @return float
*/
public static function GAMMALN($value) {
$value = self::flattenSingleValue($value);
if (is_numeric($value)) {
if ($value <= 0) {
return self::$_errorCodes['num'];
}
return log(self::_gamma($value));
}
return self::$_errorCodes['value'];
} // function GAMMALN()
/**
* NORMDIST
*
* Returns the normal distribution for the specified mean and standard deviation. This
* function has a very wide range of applications in statistics, including hypothesis
* testing.
*
* @param float $value
* @param float $mean Mean Value
* @param float $stdDev Standard Deviation
* @param boolean $cumulative
* @return float
*
*/
public static function NORMDIST($value, $mean, $stdDev, $cumulative) {
$value = self::flattenSingleValue($value);
$mean = self::flattenSingleValue($mean);
$stdDev = self::flattenSingleValue($stdDev);
if ((is_numeric($value)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
if ($stdDev < 0) {
return self::$_errorCodes['num'];
}
if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
if ($cumulative) {
return 0.5 * (1 + self::_erfVal(($value - $mean) / ($stdDev * sqrt(2))));
} else {
return (1 / (SQRT2PI * $stdDev)) * exp(0 - (pow($value - $mean,2) / (2 * ($stdDev * $stdDev))));
}
}
}
return self::$_errorCodes['value'];
} // function NORMDIST()
/**
* NORMSDIST
*
* Returns the standard normal cumulative distribution function. The distribution has
* a mean of 0 (zero) and a standard deviation of one. Use this function in place of a
* table of standard normal curve areas.
*
* @param float $value
* @return float
*/
public static function NORMSDIST($value) {
$value = self::flattenSingleValue($value);
return self::NORMDIST($value, 0, 1, True);
} // function NORMSDIST()
/**
* LOGNORMDIST
*
* Returns the cumulative lognormal distribution of x, where ln(x) is normally distributed
* with parameters mean and standard_dev.
*
* @param float $value
* @return float
*/
public static function LOGNORMDIST($value, $mean, $stdDev) {
$value = self::flattenSingleValue($value);
$mean = self::flattenSingleValue($mean);
$stdDev = self::flattenSingleValue($stdDev);
if ((is_numeric($value)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
if (($value <= 0) || ($stdDev <= 0)) {
return self::$_errorCodes['num'];
}
return self::NORMSDIST((log($value) - $mean) / $stdDev);
}
return self::$_errorCodes['value'];
} // function LOGNORMDIST()
/***************************************************************************
* inverse_ncdf.php
* -------------------
* begin : Friday, January 16, 2004
* copyright : (C) 2004 Michael Nickerson
* email : nickersonm@yahoo.com
*
***************************************************************************/
private static function _inverse_ncdf($p) {
// Inverse ncdf approximation by Peter J. Acklam, implementation adapted to
// PHP by Michael Nickerson, using Dr. Thomas Ziegler's C implementation as
// a guide. http://home.online.no/~pjacklam/notes/invnorm/index.html
// I have not checked the accuracy of this implementation. Be aware that PHP
// will truncate the coeficcients to 14 digits.
// You have permission to use and distribute this function freely for
// whatever purpose you want, but please show common courtesy and give credit
// where credit is due.
// Input paramater is $p - probability - where 0 < p < 1.
// Coefficients in rational approximations
static $a = array( 1 => -3.969683028665376e+01,
2 => 2.209460984245205e+02,
3 => -2.759285104469687e+02,
4 => 1.383577518672690e+02,
5 => -3.066479806614716e+01,
6 => 2.506628277459239e+00
);
static $b = array( 1 => -5.447609879822406e+01,
2 => 1.615858368580409e+02,
3 => -1.556989798598866e+02,
4 => 6.680131188771972e+01,
5 => -1.328068155288572e+01
);
static $c = array( 1 => -7.784894002430293e-03,
2 => -3.223964580411365e-01,
3 => -2.400758277161838e+00,
4 => -2.549732539343734e+00,
5 => 4.374664141464968e+00,
6 => 2.938163982698783e+00
);
static $d = array( 1 => 7.784695709041462e-03,
2 => 3.224671290700398e-01,
3 => 2.445134137142996e+00,
4 => 3.754408661907416e+00
);
// Define lower and upper region break-points.
$p_low = 0.02425; //Use lower region approx. below this
$p_high = 1 - $p_low; //Use upper region approx. above this
if (0 < $p && $p < $p_low) {
// Rational approximation for lower region.
$q = sqrt(-2 * log($p));
return ((((($c[1] * $q + $c[2]) * $q + $c[3]) * $q + $c[4]) * $q + $c[5]) * $q + $c[6]) /
(((($d[1] * $q + $d[2]) * $q + $d[3]) * $q + $d[4]) * $q + 1);
} elseif ($p_low <= $p && $p <= $p_high) {
// Rational approximation for central region.
$q = $p - 0.5;
$r = $q * $q;
return ((((($a[1] * $r + $a[2]) * $r + $a[3]) * $r + $a[4]) * $r + $a[5]) * $r + $a[6]) * $q /
((((($b[1] * $r + $b[2]) * $r + $b[3]) * $r + $b[4]) * $r + $b[5]) * $r + 1);
} elseif ($p_high < $p && $p < 1) {
// Rational approximation for upper region.
$q = sqrt(-2 * log(1 - $p));
return -((((($c[1] * $q + $c[2]) * $q + $c[3]) * $q + $c[4]) * $q + $c[5]) * $q + $c[6]) /
(((($d[1] * $q + $d[2]) * $q + $d[3]) * $q + $d[4]) * $q + 1);
}
// If 0 < p < 1, return a null value
return self::$_errorCodes['null'];
} // function _inverse_ncdf()
private static function _inverse_ncdf2($prob) {
// Approximation of inverse standard normal CDF developed by
// B. Moro, "The Full Monte," Risk 8(2), Feb 1995, 57-58.
$a1 = 2.50662823884;
$a2 = -18.61500062529;
$a3 = 41.39119773534;
$a4 = -25.44106049637;
$b1 = -8.4735109309;
$b2 = 23.08336743743;
$b3 = -21.06224101826;
$b4 = 3.13082909833;
$c1 = 0.337475482272615;
$c2 = 0.976169019091719;
$c3 = 0.160797971491821;
$c4 = 2.76438810333863E-02;
$c5 = 3.8405729373609E-03;
$c6 = 3.951896511919E-04;
$c7 = 3.21767881768E-05;
$c8 = 2.888167364E-07;
$c9 = 3.960315187E-07;
$y = $prob - 0.5;
if (abs($y) < 0.42) {
$z = ($y * $y);
$z = $y * ((($a4 * $z + $a3) * $z + $a2) * $z + $a1) / (((($b4 * $z + $b3) * $z + $b2) * $z + $b1) * $z + 1);
} else {
if ($y > 0) {
$z = log(-log(1 - $prob));
} else {
$z = log(-log($prob));
}
$z = $c1 + $z * ($c2 + $z * ($c3 + $z * ($c4 + $z * ($c5 + $z * ($c6 + $z * ($c7 + $z * ($c8 + $z * $c9)))))));
if ($y < 0) {
$z = -$z;
}
}
return $z;
} // function _inverse_ncdf2()
private static function _inverse_ncdf3($p) {
// ALGORITHM AS241 APPL. STATIST. (1988) VOL. 37, NO. 3.
// Produces the normal deviate Z corresponding to a given lower
// tail area of P; Z is accurate to about 1 part in 10**16.
//
// This is a PHP version of the original FORTRAN code that can
// be found at http://lib.stat.cmu.edu/apstat/
$split1 = 0.425;
$split2 = 5;
$const1 = 0.180625;
$const2 = 1.6;
// coefficients for p close to 0.5
$a0 = 3.3871328727963666080;
$a1 = 1.3314166789178437745E+2;
$a2 = 1.9715909503065514427E+3;
$a3 = 1.3731693765509461125E+4;
$a4 = 4.5921953931549871457E+4;
$a5 = 6.7265770927008700853E+4;
$a6 = 3.3430575583588128105E+4;
$a7 = 2.5090809287301226727E+3;
$b1 = 4.2313330701600911252E+1;
$b2 = 6.8718700749205790830E+2;
$b3 = 5.3941960214247511077E+3;
$b4 = 2.1213794301586595867E+4;
$b5 = 3.9307895800092710610E+4;
$b6 = 2.8729085735721942674E+4;
$b7 = 5.2264952788528545610E+3;
// coefficients for p not close to 0, 0.5 or 1.
$c0 = 1.42343711074968357734;
$c1 = 4.63033784615654529590;
$c2 = 5.76949722146069140550;
$c3 = 3.64784832476320460504;
$c4 = 1.27045825245236838258;
$c5 = 2.41780725177450611770E-1;
$c6 = 2.27238449892691845833E-2;
$c7 = 7.74545014278341407640E-4;
$d1 = 2.05319162663775882187;
$d2 = 1.67638483018380384940;
$d3 = 6.89767334985100004550E-1;
$d4 = 1.48103976427480074590E-1;
$d5 = 1.51986665636164571966E-2;
$d6 = 5.47593808499534494600E-4;
$d7 = 1.05075007164441684324E-9;
// coefficients for p near 0 or 1.
$e0 = 6.65790464350110377720;
$e1 = 5.46378491116411436990;
$e2 = 1.78482653991729133580;
$e3 = 2.96560571828504891230E-1;
$e4 = 2.65321895265761230930E-2;
$e5 = 1.24266094738807843860E-3;
$e6 = 2.71155556874348757815E-5;
$e7 = 2.01033439929228813265E-7;
$f1 = 5.99832206555887937690E-1;
$f2 = 1.36929880922735805310E-1;
$f3 = 1.48753612908506148525E-2;
$f4 = 7.86869131145613259100E-4;
$f5 = 1.84631831751005468180E-5;
$f6 = 1.42151175831644588870E-7;
$f7 = 2.04426310338993978564E-15;
$q = $p - 0.5;
// computation for p close to 0.5
if (abs($q) <= split1) {
$R = $const1 - $q * $q;
$z = $q * ((((((($a7 * $R + $a6) * $R + $a5) * $R + $a4) * $R + $a3) * $R + $a2) * $R + $a1) * $R + $a0) /
((((((($b7 * $R + $b6) * $R + $b5) * $R + $b4) * $R + $b3) * $R + $b2) * $R + $b1) * $R + 1);
} else {
if ($q < 0) {
$R = $p;
} else {
$R = 1 - $p;
}
$R = pow(-log($R),2);
// computation for p not close to 0, 0.5 or 1.
If ($R <= $split2) {
$R = $R - $const2;
$z = ((((((($c7 * $R + $c6) * $R + $c5) * $R + $c4) * $R + $c3) * $R + $c2) * $R + $c1) * $R + $c0) /
((((((($d7 * $R + $d6) * $R + $d5) * $R + $d4) * $R + $d3) * $R + $d2) * $R + $d1) * $R + 1);
} else {
// computation for p near 0 or 1.
$R = $R - $split2;
$z = ((((((($e7 * $R + $e6) * $R + $e5) * $R + $e4) * $R + $e3) * $R + $e2) * $R + $e1) * $R + $e0) /
((((((($f7 * $R + $f6) * $R + $f5) * $R + $f4) * $R + $f3) * $R + $f2) * $R + $f1) * $R + 1);
}
if ($q < 0) {
$z = -$z;
}
}
return $z;
} // function _inverse_ncdf3()
/**
* NORMINV
*
* Returns the inverse of the normal cumulative distribution for the specified mean and standard deviation.
*
* @param float $value
* @param float $mean Mean Value
* @param float $stdDev Standard Deviation
* @return float
*
*/
public static function NORMINV($probability,$mean,$stdDev) {
$probability = self::flattenSingleValue($probability);
$mean = self::flattenSingleValue($mean);
$stdDev = self::flattenSingleValue($stdDev);
if ((is_numeric($probability)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
if (($probability < 0) || ($probability > 1)) {
return self::$_errorCodes['num'];
}
if ($stdDev < 0) {
return self::$_errorCodes['num'];
}
return (self::_inverse_ncdf($probability) * $stdDev) + $mean;
}
return self::$_errorCodes['value'];
} // function NORMINV()
/**
* NORMSINV
*
* Returns the inverse of the standard normal cumulative distribution
*
* @param float $value
* @return float
*/
public static function NORMSINV($value) {
return self::NORMINV($value, 0, 1);
} // function NORMSINV()
/**
* LOGINV
*
* Returns the inverse of the normal cumulative distribution
*
* @param float $value
* @return float
*
* @todo Try implementing P J Acklam's refinement algorithm for greater
* accuracy if I can get my head round the mathematics
* (as described at) http://home.online.no/~pjacklam/notes/invnorm/
*/
public static function LOGINV($probability, $mean, $stdDev) {
$probability = self::flattenSingleValue($probability);
$mean = self::flattenSingleValue($mean);
$stdDev = self::flattenSingleValue($stdDev);
if ((is_numeric($probability)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
if (($probability < 0) || ($probability > 1) || ($stdDev <= 0)) {
return self::$_errorCodes['num'];
}
return exp($mean + $stdDev * self::NORMSINV($probability));
}
return self::$_errorCodes['value'];
} // function LOGINV()
/**
* HYPGEOMDIST
*
* Returns the hypergeometric distribution. HYPGEOMDIST returns the probability of a given number of
* sample successes, given the sample size, population successes, and population size.
*
* @param float $sampleSuccesses Number of successes in the sample
* @param float $sampleNumber Size of the sample
* @param float $populationSuccesses Number of successes in the population
* @param float $populationNumber Population size
* @return float
*
*/
public static function HYPGEOMDIST($sampleSuccesses, $sampleNumber, $populationSuccesses, $populationNumber) {
$sampleSuccesses = floor(self::flattenSingleValue($sampleSuccesses));
$sampleNumber = floor(self::flattenSingleValue($sampleNumber));
$populationSuccesses = floor(self::flattenSingleValue($populationSuccesses));
$populationNumber = floor(self::flattenSingleValue($populationNumber));
if ((is_numeric($sampleSuccesses)) && (is_numeric($sampleNumber)) && (is_numeric($populationSuccesses)) && (is_numeric($populationNumber))) {
if (($sampleSuccesses < 0) || ($sampleSuccesses > $sampleNumber) || ($sampleSuccesses > $populationSuccesses)) {
return self::$_errorCodes['num'];
}
if (($sampleNumber <= 0) || ($sampleNumber > $populationNumber)) {
return self::$_errorCodes['num'];
}
if (($populationSuccesses <= 0) || ($populationSuccesses > $populationNumber)) {
return self::$_errorCodes['num'];
}
return self::COMBIN($populationSuccesses,$sampleSuccesses) *
self::COMBIN($populationNumber - $populationSuccesses,$sampleNumber - $sampleSuccesses) /
self::COMBIN($populationNumber,$sampleNumber);
}
return self::$_errorCodes['value'];
} // function HYPGEOMDIST()
/**
* TDIST
*
* Returns the probability of Student's T distribution.
*
* @param float $value Value for the function
* @param float $degrees degrees of freedom
* @param float $tails number of tails (1 or 2)
* @return float
*/
public static function TDIST($value, $degrees, $tails) {
$value = self::flattenSingleValue($value);
$degrees = floor(self::flattenSingleValue($degrees));
$tails = floor(self::flattenSingleValue($tails));
if ((is_numeric($value)) && (is_numeric($degrees)) && (is_numeric($tails))) {
if (($value < 0) || ($degrees < 1) || ($tails < 1) || ($tails > 2)) {
return self::$_errorCodes['num'];
}
// tdist, which finds the probability that corresponds to a given value
// of t with k degrees of freedom. This algorithm is translated from a
// pascal function on p81 of "Statistical Computing in Pascal" by D
// Cooke, A H Craven & G M Clark (1985: Edward Arnold (Pubs.) Ltd:
// London). The above Pascal algorithm is itself a translation of the
// fortran algoritm "AS 3" by B E Cooper of the Atlas Computer
// Laboratory as reported in (among other places) "Applied Statistics
// Algorithms", editied by P Griffiths and I D Hill (1985; Ellis
// Horwood Ltd.; W. Sussex, England).
$tterm = $degrees;
$ttheta = atan2($value,sqrt($tterm));
$tc = cos($ttheta);
$ts = sin($ttheta);
$tsum = 0;
if (($degrees % 2) == 1) {
$ti = 3;
$tterm = $tc;
} else {
$ti = 2;
$tterm = 1;
}
$tsum = $tterm;
while ($ti < $degrees) {
$tterm *= $tc * $tc * ($ti - 1) / $ti;
$tsum += $tterm;
$ti += 2;
}
$tsum *= $ts;
if (($degrees % 2) == 1) { $tsum = M_2DIVPI * ($tsum + $ttheta); }
$tValue = 0.5 * (1 + $tsum);
if ($tails == 1) {
return 1 - abs($tValue);
} else {
return 1 - abs((1 - $tValue) - $tValue);
}
}
return self::$_errorCodes['value'];
} // function TDIST()
/**
* TINV
*
* Returns the one-tailed probability of the chi-squared distribution.
*
* @param float $probability Probability for the function
* @param float $degrees degrees of freedom
* @return float
*/
public static function TINV($probability, $degrees) {
$probability = self::flattenSingleValue($probability);
$degrees = floor(self::flattenSingleValue($degrees));
if ((is_numeric($probability)) && (is_numeric($degrees))) {
$xLo = 100;
$xHi = 0;
$x = $xNew = 1;
$dx = 1;
$i = 0;
while ((abs($dx) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
// Apply Newton-Raphson step
$result = self::TDIST($x, $degrees, 2);
$error = $result - $probability;
if ($error == 0.0) {
$dx = 0;
} elseif ($error < 0.0) {
$xLo = $x;
} else {
$xHi = $x;
}
// Avoid division by zero
if ($result != 0.0) {
$dx = $error / $result;
$xNew = $x - $dx;
}
// If the NR fails to converge (which for example may be the
// case if the initial guess is too rough) we apply a bisection
// step to determine a more narrow interval around the root.
if (($xNew < $xLo) || ($xNew > $xHi) || ($result == 0.0)) {
$xNew = ($xLo + $xHi) / 2;
$dx = $xNew - $x;
}
$x = $xNew;
}
if ($i == MAX_ITERATIONS) {
return self::$_errorCodes['na'];
}
return round($x,12);
}
return self::$_errorCodes['value'];
} // function TINV()
/**
* CONFIDENCE
*
* Returns the confidence interval for a population mean
*
* @param float $alpha
* @param float $stdDev Standard Deviation
* @param float $size
* @return float
*
*/
public static function CONFIDENCE($alpha,$stdDev,$size) {
$alpha = self::flattenSingleValue($alpha);
$stdDev = self::flattenSingleValue($stdDev);
$size = floor(self::flattenSingleValue($size));
if ((is_numeric($alpha)) && (is_numeric($stdDev)) && (is_numeric($size))) {
if (($alpha <= 0) || ($alpha >= 1)) {
return self::$_errorCodes['num'];
}
if (($stdDev <= 0) || ($size < 1)) {
return self::$_errorCodes['num'];
}
return self::NORMSINV(1 - $alpha / 2) * $stdDev / sqrt($size);
}
return self::$_errorCodes['value'];
} // function CONFIDENCE()
/**
* POISSON
*
* Returns the Poisson distribution. A common application of the Poisson distribution
* is predicting the number of events over a specific time, such as the number of
* cars arriving at a toll plaza in 1 minute.
*
* @param float $value
* @param float $mean Mean Value
* @param boolean $cumulative
* @return float
*
*/
public static function POISSON($value, $mean, $cumulative) {
$value = self::flattenSingleValue($value);
$mean = self::flattenSingleValue($mean);
if ((is_numeric($value)) && (is_numeric($mean))) {
if (($value <= 0) || ($mean <= 0)) {
return self::$_errorCodes['num'];
}
if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
if ($cumulative) {
$summer = 0;
for ($i = 0; $i <= floor($value); ++$i) {
$summer += pow($mean,$i) / self::FACT($i);
}
return exp(0-$mean) * $summer;
} else {
return (exp(0-$mean) * pow($mean,$value)) / self::FACT($value);
}
}
}
return self::$_errorCodes['value'];
} // function POISSON()
/**
* WEIBULL
*
* Returns the Weibull distribution. Use this distribution in reliability
* analysis, such as calculating a device's mean time to failure.
*
* @param float $value
* @param float $alpha Alpha Parameter
* @param float $beta Beta Parameter
* @param boolean $cumulative
* @return float
*
*/
public static function WEIBULL($value, $alpha, $beta, $cumulative) {
$value = self::flattenSingleValue($value);
$alpha = self::flattenSingleValue($alpha);
$beta = self::flattenSingleValue($beta);
if ((is_numeric($value)) && (is_numeric($alpha)) && (is_numeric($beta))) {
if (($value < 0) || ($alpha <= 0) || ($beta <= 0)) {
return self::$_errorCodes['num'];
}
if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
if ($cumulative) {
return 1 - exp(0 - pow($value / $beta,$alpha));
} else {
return ($alpha / pow($beta,$alpha)) * pow($value,$alpha - 1) * exp(0 - pow($value / $beta,$alpha));
}
}
}
return self::$_errorCodes['value'];
} // function WEIBULL()
/**
* ZTEST
*
* Returns the Weibull distribution. Use this distribution in reliability
* analysis, such as calculating a device's mean time to failure.
*
* @param float $value
* @param float $alpha Alpha Parameter
* @param float $beta Beta Parameter
* @param boolean $cumulative
* @return float
*
*/
public static function ZTEST($dataSet, $m0, $sigma=null) {
$dataSet = self::flattenArrayIndexed($dataSet);
$m0 = self::flattenSingleValue($m0);
$sigma = self::flattenSingleValue($sigma);
if (is_null($sigma)) {
$sigma = self::STDEV($dataSet);
}
$n = count($dataSet);
return 1 - self::NORMSDIST((self::AVERAGE($dataSet) - $m0)/($sigma/SQRT($n)));
} // function ZTEST()
/**
* SKEW
*
* Returns the skewness of a distribution. Skewness characterizes the degree of asymmetry
* of a distribution around its mean. Positive skewness indicates a distribution with an
* asymmetric tail extending toward more positive values. Negative skewness indicates a
* distribution with an asymmetric tail extending toward more negative values.
*
* @param array Data Series
* @return float
*/
public static function SKEW() {
$aArgs = self::flattenArrayIndexed(func_get_args());
$mean = self::AVERAGE($aArgs);
$stdDev = self::STDEV($aArgs);
$count = $summer = 0;
// Loop through arguments
foreach ($aArgs as $k => $arg) {
if ((is_bool($arg)) &&
(!self::isMatrixValue($k))) {
} else {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$summer += pow((($arg - $mean) / $stdDev),3) ;
++$count;
}
}
}
// Return
if ($count > 2) {
return $summer * ($count / (($count-1) * ($count-2)));
}
return self::$_errorCodes['divisionbyzero'];
} // function SKEW()
/**
* KURT
*
* Returns the kurtosis of a data set. Kurtosis characterizes the relative peakedness
* or flatness of a distribution compared with the normal distribution. Positive
* kurtosis indicates a relatively peaked distribution. Negative kurtosis indicates a
* relatively flat distribution.
*
* @param array Data Series
* @return float
*/
public static function KURT() {
$aArgs = self::flattenArrayIndexed(func_get_args());
$mean = self::AVERAGE($aArgs);
$stdDev = self::STDEV($aArgs);
if ($stdDev > 0) {
$count = $summer = 0;
// Loop through arguments
foreach ($aArgs as $k => $arg) {
if ((is_bool($arg)) &&
(!self::isMatrixValue($k))) {
} else {
// Is it a numeric value?
if ((is_numeric($arg)) && (!is_string($arg))) {
$summer += pow((($arg - $mean) / $stdDev),4) ;
++$count;
}
}
}
// Return
if ($count > 3) {
return $summer * ($count * ($count+1) / (($count-1) * ($count-2) * ($count-3))) - (3 * pow($count-1,2) / (($count-2) * ($count-3)));
}
}
return self::$_errorCodes['divisionbyzero'];
} // function KURT()
/**
* RAND
*
* @param int $min Minimal value
* @param int $max Maximal value
* @return int Random number
*/
public static function RAND($min = 0, $max = 0) {
$min = self::flattenSingleValue($min);
$max = self::flattenSingleValue($max);
if ($min == 0 && $max == 0) {
return (rand(0,10000000)) / 10000000;
} else {
return rand($min, $max);
}
} // function RAND()
/**
* MOD
*
* @param int $a Dividend
* @param int $b Divisor
* @return int Remainder
*/
public static function MOD($a = 1, $b = 1) {
$a = self::flattenSingleValue($a);
$b = self::flattenSingleValue($b);
if ($b == 0.0) {
return self::$_errorCodes['divisionbyzero'];
} elseif (($a < 0.0) && ($b > 0.0)) {
return $b - fmod(abs($a),$b);
} elseif (($a > 0.0) && ($b < 0.0)) {
return $b + fmod($a,abs($b));
}
return fmod($a,$b);
} // function MOD()
/**
* CHARACTER
*
* @param string $character Value
* @return int
*/
public static function CHARACTER($character) {
$character = self::flattenSingleValue($character);
if ((!is_numeric($character)) || ($character < 0)) {
return self::$_errorCodes['value'];
}
if (function_exists('mb_convert_encoding')) {
return mb_convert_encoding('&#'.intval($character).';', 'UTF-8', 'HTML-ENTITIES');
} else {
return chr(intval($character));
}
}
private static function _uniord($c) {
if (ord($c{0}) >=0 && ord($c{0}) <= 127)
return ord($c{0});
if (ord($c{0}) >= 192 && ord($c{0}) <= 223)
return (ord($c{0})-192)*64 + (ord($c{1})-128);
if (ord($c{0}) >= 224 && ord($c{0}) <= 239)
return (ord($c{0})-224)*4096 + (ord($c{1})-128)*64 + (ord($c{2})-128);
if (ord($c{0}) >= 240 && ord($c{0}) <= 247)
return (ord($c{0})-240)*262144 + (ord($c{1})-128)*4096 + (ord($c{2})-128)*64 + (ord($c{3})-128);
if (ord($c{0}) >= 248 && ord($c{0}) <= 251)
return (ord($c{0})-248)*16777216 + (ord($c{1})-128)*262144 + (ord($c{2})-128)*4096 + (ord($c{3})-128)*64 + (ord($c{4})-128);
if (ord($c{0}) >= 252 && ord($c{0}) <= 253)
return (ord($c{0})-252)*1073741824 + (ord($c{1})-128)*16777216 + (ord($c{2})-128)*262144 + (ord($c{3})-128)*4096 + (ord($c{4})-128)*64 + (ord($c{5})-128);
if (ord($c{0}) >= 254 && ord($c{0}) <= 255) //error
return self::$_errorCodes['value'];
return 0;
} // function _uniord()
/**
* ASCIICODE
*
* @param string $character Value
* @return int
*/
public static function ASCIICODE($characters) {
$characters = self::flattenSingleValue($characters);
if (is_bool($characters)) {
if (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE) {
$characters = (int) $characters;
} else {
if ($characters) {
$characters = 'True';
} else {
$characters = 'False';
}
}
}
$character = $characters;
if ((function_exists('mb_strlen')) && (function_exists('mb_substr'))) {
if (mb_strlen($characters, 'UTF-8') > 1) { $character = mb_substr($characters, 0, 1, 'UTF-8'); }
return self::_uniord($character);
} else {
if (strlen($characters) > 0) { $character = substr($characters, 0, 1); }
return ord($character);
}
} // function ASCIICODE()
/**
* CONCATENATE
*
* @return string
*/
public static function CONCATENATE() {
// Return value
$returnValue = '';
// Loop through arguments
$aArgs = self::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
if (is_bool($arg)) {
if (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE) {
$arg = (int) $arg;
} else {
if ($arg) {
$arg = 'TRUE';
} else {
$arg = 'FALSE';
}
}
}
$returnValue .= $arg;
}
// Return
return $returnValue;
} // function CONCATENATE()
/**
* STRINGLENGTH
*
* @param string $value Value
* @param int $chars Number of characters
* @return string
*/
public static function STRINGLENGTH($value = '') {
$value = self::flattenSingleValue($value);
if (is_bool($value)) {
$value = ($value) ? 'TRUE' : 'FALSE';
}
if (function_exists('mb_strlen')) {
return mb_strlen($value, 'UTF-8');
} else {
return strlen($value);
}
} // function STRINGLENGTH()
/**
* SEARCHSENSITIVE
*
* @param string $needle The string to look for
* @param string $haystack The string in which to look
* @param int $offset Offset within $haystack
* @return string
*/
public static function SEARCHSENSITIVE($needle,$haystack,$offset=1) {
$needle = self::flattenSingleValue($needle);
$haystack = self::flattenSingleValue($haystack);
$offset = self::flattenSingleValue($offset);
if (!is_bool($needle)) {
if (is_bool($haystack)) {
$haystack = ($haystack) ? 'TRUE' : 'FALSE';
}
if (($offset > 0) && (strlen($haystack) > $offset)) {
if (function_exists('mb_strpos')) {
$pos = mb_strpos($haystack, $needle, --$offset,'UTF-8');
} else {
$pos = strpos($haystack, $needle, --$offset);
}
if ($pos !== false) {
return ++$pos;
}
}
}
return self::$_errorCodes['value'];
} // function SEARCHSENSITIVE()
/**
* SEARCHINSENSITIVE
*
* @param string $needle The string to look for
* @param string $haystack The string in which to look
* @param int $offset Offset within $haystack
* @return string
*/
public static function SEARCHINSENSITIVE($needle,$haystack,$offset=1) {
$needle = self::flattenSingleValue($needle);
$haystack = self::flattenSingleValue($haystack);
$offset = self::flattenSingleValue($offset);
if (!is_bool($needle)) {
if (is_bool($haystack)) {
$haystack = ($haystack) ? 'TRUE' : 'FALSE';
}
if (($offset > 0) && (strlen($haystack) > $offset)) {
if (function_exists('mb_stripos')) {
$pos = mb_stripos($haystack, $needle, --$offset,'UTF-8');
} else {
$pos = stripos($haystack, $needle, --$offset);
}
if ($pos !== false) {
return ++$pos;
}
}
}
return self::$_errorCodes['value'];
} // function SEARCHINSENSITIVE()
/**
* LEFT
*
* @param string $value Value
* @param int $chars Number of characters
* @return string
*/
public static function LEFT($value = '', $chars = 1) {
$value = self::flattenSingleValue($value);
$chars = self::flattenSingleValue($chars);
if ($chars < 0) {
return self::$_errorCodes['value'];
}
if (is_bool($value)) {
$value = ($value) ? 'TRUE' : 'FALSE';
}
if (function_exists('mb_substr')) {
return mb_substr($value, 0, $chars, 'UTF-8');
} else {
return substr($value, 0, $chars);
}
} // function LEFT()
/**
* RIGHT
*
* @param string $value Value
* @param int $chars Number of characters
* @return string
*/
public static function RIGHT($value = '', $chars = 1) {
$value = self::flattenSingleValue($value);
$chars = self::flattenSingleValue($chars);
if ($chars < 0) {
return self::$_errorCodes['value'];
}
if (is_bool($value)) {
$value = ($value) ? 'TRUE' : 'FALSE';
}
if ((function_exists('mb_substr')) && (function_exists('mb_strlen'))) {
return mb_substr($value, mb_strlen($value, 'UTF-8') - $chars, $chars, 'UTF-8');
} else {
return substr($value, strlen($value) - $chars);
}
} // function RIGHT()
/**
* MID
*
* @param string $value Value
* @param int $start Start character
* @param int $chars Number of characters
* @return string
*/
public static function MID($value = '', $start = 1, $chars = null) {
$value = self::flattenSingleValue($value);
$start = self::flattenSingleValue($start);
$chars = self::flattenSingleValue($chars);
if (($start < 1) || ($chars < 0)) {
return self::$_errorCodes['value'];
}
if (is_bool($value)) {
$value = ($value) ? 'TRUE' : 'FALSE';
}
if (function_exists('mb_substr')) {
return mb_substr($value, --$start, $chars, 'UTF-8');
} else {
return substr($value, --$start, $chars);
}
} // function MID()
/**
* REPLACE
*
* @param string $value Value
* @param int $start Start character
* @param int $chars Number of characters
* @return string
*/
public static function REPLACE($oldText = '', $start = 1, $chars = null, $newText) {
$oldText = self::flattenSingleValue($oldText);
$start = self::flattenSingleValue($start);
$chars = self::flattenSingleValue($chars);
$newText = self::flattenSingleValue($newText);
$left = self::LEFT($oldText,$start-1);
$right = self::RIGHT($oldText,self::STRINGLENGTH($oldText)-($start+$chars)+1);
return $left.$newText.$right;
} // function REPLACE()
/**
* SUBSTITUTE
*
* @param string $text Value
* @param string $fromText From Value
* @param string $toText To Value
* @param integer $instance Instance Number
* @return string
*/
public static function SUBSTITUTE($text = '', $fromText = '', $toText = '', $instance = 0) {
$text = self::flattenSingleValue($text);
$fromText = self::flattenSingleValue($fromText);
$toText = self::flattenSingleValue($toText);
$instance = floor(self::flattenSingleValue($instance));
if ($instance == 0) {
if(function_exists('mb_str_replace')) {
return mb_str_replace($fromText,$toText,$text);
} else {
return str_replace($fromText,$toText,$text);
}
} else {
$pos = -1;
while($instance > 0) {
if (function_exists('mb_strpos')) {
$pos = mb_strpos($text, $fromText, $pos+1, 'UTF-8');
} else {
$pos = strpos($text, $fromText, $pos+1);
}
if ($pos === false) {
break;
}
--$instance;
}
if ($pos !== false) {
if (function_exists('mb_strlen')) {
return self::REPLACE($text,++$pos,mb_strlen($fromText, 'UTF-8'),$toText);
} else {
return self::REPLACE($text,++$pos,strlen($fromText),$toText);
}
}
}
return $left.$newText.$right;
} // function SUBSTITUTE()
/**
* RETURNSTRING
*
* @param mixed $value Value to check
* @return boolean
*/
public static function RETURNSTRING($testValue = '') {
$testValue = self::flattenSingleValue($testValue);
if (is_string($testValue)) {
return $testValue;
}
return Null;
} // function RETURNSTRING()
/**
* FIXEDFORMAT
*
* @param mixed $value Value to check
* @return boolean
*/
public static function FIXEDFORMAT($value,$decimals=2,$no_commas=false) {
$value = self::flattenSingleValue($value);
$decimals = self::flattenSingleValue($decimals);
$no_commas = self::flattenSingleValue($no_commas);
$valueResult = round($value,$decimals);
if ($decimals < 0) { $decimals = 0; }
if (!$no_commas) {
$valueResult = number_format($valueResult,$decimals);
}
return (string) $valueResult;
} // function FIXEDFORMAT()
/**
* TEXTFORMAT
*
* @param mixed $value Value to check
* @return boolean
*/
public static function TEXTFORMAT($value,$format) {
$value = self::flattenSingleValue($value);
$format = self::flattenSingleValue($format);
if ((is_string($value)) && (!is_numeric($value)) && PHPExcel_Shared_Date::isDateTimeFormatCode($format)) {
$value = self::DATEVALUE($value);
}
return (string) PHPExcel_Style_NumberFormat::toFormattedString($value,$format);
} // function TEXTFORMAT()
/**
* TRIMSPACES
*
* @param mixed $value Value to check
* @return string
*/
public static function TRIMSPACES($stringValue = '') {
$stringValue = self::flattenSingleValue($stringValue);
if (is_string($stringValue) || is_numeric($stringValue)) {
return trim(preg_replace('/ +/',' ',$stringValue));
}
return Null;
} // function TRIMSPACES()
private static $_invalidChars = Null;
/**
* TRIMNONPRINTABLE
*
* @param mixed $value Value to check
* @return string
*/
public static function TRIMNONPRINTABLE($stringValue = '') {
$stringValue = self::flattenSingleValue($stringValue);
if (is_bool($stringValue)) {
$stringValue = ($stringValue) ? 'TRUE' : 'FALSE';
}
if (self::$_invalidChars == Null) {
self::$_invalidChars = range(chr(0),chr(31));
}
if (is_string($stringValue) || is_numeric($stringValue)) {
return str_replace(self::$_invalidChars,'',trim($stringValue,"\x00..\x1F"));
}
return Null;
} // function TRIMNONPRINTABLE()
/**
* ERROR_TYPE
*
* @param mixed $value Value to check
* @return boolean
*/
public static function ERROR_TYPE($value = '') {
$value = self::flattenSingleValue($value);
$i = 1;
foreach(self::$_errorCodes as $errorCode) {
if ($value == $errorCode) {
return $i;
}
++$i;
}
return self::$_errorCodes['na'];
} // function ERROR_TYPE()
/**
* IS_BLANK
*
* @param mixed $value Value to check
* @return boolean
*/
public static function IS_BLANK($value=null) {
if (!is_null($value)) {
$value = self::flattenSingleValue($value);
}
return is_null($value);
} // function IS_BLANK()
/**
* IS_ERR
*
* @param mixed $value Value to check
* @return boolean
*/
public static function IS_ERR($value = '') {
$value = self::flattenSingleValue($value);
return self::IS_ERROR($value) && (!self::IS_NA($value));
} // function IS_ERR()
/**
* IS_ERROR
*
* @param mixed $value Value to check
* @return boolean
*/
public static function IS_ERROR($value = '') {
$value = self::flattenSingleValue($value);
return in_array($value, array_values(self::$_errorCodes));
} // function IS_ERROR()
/**
* IS_NA
*
* @param mixed $value Value to check
* @return boolean
*/
public static function IS_NA($value = '') {
$value = self::flattenSingleValue($value);
return ($value === self::$_errorCodes['na']);
} // function IS_NA()
/**
* IS_EVEN
*
* @param mixed $value Value to check
* @return boolean
*/
public static function IS_EVEN($value = 0) {
$value = self::flattenSingleValue($value);
if ((is_bool($value)) || ((is_string($value)) && (!is_numeric($value)))) {
return self::$_errorCodes['value'];
}
return ($value % 2 == 0);
} // function IS_EVEN()
/**
* IS_ODD
*
* @param mixed $value Value to check
* @return boolean
*/
public static function IS_ODD($value = null) {
$value = self::flattenSingleValue($value);
if ((is_bool($value)) || ((is_string($value)) && (!is_numeric($value)))) {
return self::$_errorCodes['value'];
}
return (abs($value) % 2 == 1);
} // function IS_ODD()
/**
* IS_NUMBER
*
* @param mixed $value Value to check
* @return boolean
*/
public static function IS_NUMBER($value = 0) {
$value = self::flattenSingleValue($value);
if (is_string($value)) {
return False;
}
return is_numeric($value);
} // function IS_NUMBER()
/**
* IS_LOGICAL
*
* @param mixed $value Value to check
* @return boolean
*/
public static function IS_LOGICAL($value = true) {
$value = self::flattenSingleValue($value);
return is_bool($value);
} // function IS_LOGICAL()
/**
* IS_TEXT
*
* @param mixed $value Value to check
* @return boolean
*/
public static function IS_TEXT($value = '') {
$value = self::flattenSingleValue($value);
return is_string($value);
} // function IS_TEXT()
/**
* IS_NONTEXT
*
* @param mixed $value Value to check
* @return boolean
*/
public static function IS_NONTEXT($value = '') {
return !self::IS_TEXT($value);
} // function IS_NONTEXT()
/**
* VERSION
*
* @return string Version information
*/
public static function VERSION() {
return 'PHPExcel 1.7.2, 2010-01-11';
} // function VERSION()
/**
* DATE
*
* @param long $year
* @param long $month
* @param long $day
* @return mixed Excel date/time serial value, PHP date/time serial value or PHP date/time object,
* depending on the value of the ReturnDateType flag
*/
public static function DATE($year = 0, $month = 1, $day = 1) {
$year = (integer) self::flattenSingleValue($year);
$month = (integer) self::flattenSingleValue($month);
$day = (integer) self::flattenSingleValue($day);
$baseYear = PHPExcel_Shared_Date::getExcelCalendar();
// Validate parameters
if ($year < ($baseYear-1900)) {
return self::$_errorCodes['num'];
}
if ((($baseYear-1900) != 0) && ($year < $baseYear) && ($year >= 1900)) {
return self::$_errorCodes['num'];
}
if (($year < $baseYear) && ($year >= ($baseYear-1900))) {
$year += 1900;
}
if ($month < 1) {
// Handle year/month adjustment if month < 1
--$month;
$year += ceil($month / 12) - 1;
$month = 13 - abs($month % 12);
} elseif ($month > 12) {
// Handle year/month adjustment if month > 12
$year += floor($month / 12);
$month = ($month % 12);
}
// Re-validate the year parameter after adjustments
if (($year < $baseYear) || ($year >= 10000)) {
return self::$_errorCodes['num'];
}
// Execute function
$excelDateValue = PHPExcel_Shared_Date::FormattedPHPToExcel($year, $month, $day);
switch (self::getReturnDateType()) {
case self::RETURNDATE_EXCEL : return (float) $excelDateValue;
break;
case self::RETURNDATE_PHP_NUMERIC : return (integer) PHPExcel_Shared_Date::ExcelToPHP($excelDateValue);
break;
case self::RETURNDATE_PHP_OBJECT : return PHPExcel_Shared_Date::ExcelToPHPObject($excelDateValue);
break;
}
} // function DATE()
/**
* TIME
*
* @param long $hour
* @param long $minute
* @param long $second
* @return mixed Excel date/time serial value, PHP date/time serial value or PHP date/time object,
* depending on the value of the ReturnDateType flag
*/
public static function TIME($hour = 0, $minute = 0, $second = 0) {
$hour = self::flattenSingleValue($hour);
$minute = self::flattenSingleValue($minute);
$second = self::flattenSingleValue($second);
if ($hour == '') { $hour = 0; }
if ($minute == '') { $minute = 0; }
if ($second == '') { $second = 0; }
if ((!is_numeric($hour)) || (!is_numeric($minute)) || (!is_numeric($second))) {
return self::$_errorCodes['value'];
}
$hour = (integer) $hour;
$minute = (integer) $minute;
$second = (integer) $second;
if ($second < 0) {
$minute += floor($second / 60);
$second = 60 - abs($second % 60);
if ($second == 60) { $second = 0; }
} elseif ($second >= 60) {
$minute += floor($second / 60);
$second = $second % 60;
}
if ($minute < 0) {
$hour += floor($minute / 60);
$minute = 60 - abs($minute % 60);
if ($minute == 60) { $minute = 0; }
} elseif ($minute >= 60) {
$hour += floor($minute / 60);
$minute = $minute % 60;
}
if ($hour > 23) {
$hour = $hour % 24;
} elseif ($hour < 0) {
return self::$_errorCodes['num'];
}
// Execute function
switch (self::getReturnDateType()) {
case self::RETURNDATE_EXCEL : $date = 0;
$calendar = PHPExcel_Shared_Date::getExcelCalendar();
if ($calendar != PHPExcel_Shared_Date::CALENDAR_WINDOWS_1900) {
$date = 1;
}
return (float) PHPExcel_Shared_Date::FormattedPHPToExcel($calendar, 1, $date, $hour, $minute, $second);
break;
case self::RETURNDATE_PHP_NUMERIC : return (integer) PHPExcel_Shared_Date::ExcelToPHP(PHPExcel_Shared_Date::FormattedPHPToExcel(1970, 1, 1, $hour-1, $minute, $second)); // -2147468400; // -2147472000 + 3600
break;
case self::RETURNDATE_PHP_OBJECT : $dayAdjust = 0;
if ($hour < 0) {
$dayAdjust = floor($hour / 24);
$hour = 24 - abs($hour % 24);
if ($hour == 24) { $hour = 0; }
} elseif ($hour >= 24) {
$dayAdjust = floor($hour / 24);
$hour = $hour % 24;
}
$phpDateObject = new DateTime('1900-01-01 '.$hour.':'.$minute.':'.$second);
if ($dayAdjust != 0) {
$phpDateObject->modify($dayAdjust.' days');
}
return $phpDateObject;
break;
}
} // function TIME()
/**
* DATEVALUE
*
* @param string $dateValue
* @return mixed Excel date/time serial value, PHP date/time serial value or PHP date/time object,
* depending on the value of the ReturnDateType flag
*/
public static function DATEVALUE($dateValue = 1) {
$dateValue = str_replace(array('/','.',' '),array('-','-','-'),trim(self::flattenSingleValue($dateValue),'"'));
$yearFound = false;
$t1 = explode('-',$dateValue);
foreach($t1 as &$t) {
if ((is_numeric($t)) && (($t > 31) && ($t < 100))) {
if ($yearFound) {
return self::$_errorCodes['value'];
} else {
$t += 1900;
$yearFound = true;
}
}
}
unset($t);
$dateValue = implode('-',$t1);
$PHPDateArray = date_parse($dateValue);
if (($PHPDateArray === False) || ($PHPDateArray['error_count'] > 0)) {
$testVal1 = strtok($dateValue,'- ');
if ($testVal1 !== False) {
$testVal2 = strtok('- ');
if ($testVal2 !== False) {
$testVal3 = strtok('- ');
if ($testVal3 === False) {
$testVal3 = strftime('%Y');
}
} else {
return self::$_errorCodes['value'];
}
} else {
return self::$_errorCodes['value'];
}
$PHPDateArray = date_parse($testVal1.'-'.$testVal2.'-'.$testVal3);
if (($PHPDateArray === False) || ($PHPDateArray['error_count'] > 0)) {
$PHPDateArray = date_parse($testVal2.'-'.$testVal1.'-'.$testVal3);
if (($PHPDateArray === False) || ($PHPDateArray['error_count'] > 0)) {
return self::$_errorCodes['value'];
}
}
}
if (($PHPDateArray !== False) && ($PHPDateArray['error_count'] == 0)) {
// Execute function
if ($PHPDateArray['year'] == '') { $PHPDateArray['year'] = strftime('%Y'); }
if ($PHPDateArray['month'] == '') { $PHPDateArray['month'] = strftime('%m'); }
if ($PHPDateArray['day'] == '') { $PHPDateArray['day'] = strftime('%d'); }
$excelDateValue = floor(PHPExcel_Shared_Date::FormattedPHPToExcel($PHPDateArray['year'],$PHPDateArray['month'],$PHPDateArray['day'],$PHPDateArray['hour'],$PHPDateArray['minute'],$PHPDateArray['second']));
switch (self::getReturnDateType()) {
case self::RETURNDATE_EXCEL : return (float) $excelDateValue;
break;
case self::RETURNDATE_PHP_NUMERIC : return (integer) PHPExcel_Shared_Date::ExcelToPHP($excelDateValue);
break;
case self::RETURNDATE_PHP_OBJECT : return new DateTime($PHPDateArray['year'].'-'.$PHPDateArray['month'].'-'.$PHPDateArray['day'].' 00:00:00');
break;
}
}
return self::$_errorCodes['value'];
} // function DATEVALUE()
/**
* _getDateValue
*
* @param string $dateValue
* @return mixed Excel date/time serial value, or string if error
*/
private static function _getDateValue($dateValue) {
if (!is_numeric($dateValue)) {
if ((is_string($dateValue)) && (self::$compatibilityMode == self::COMPATIBILITY_GNUMERIC)) {
return self::$_errorCodes['value'];
}
if ((is_object($dateValue)) && ($dateValue instanceof PHPExcel_Shared_Date::$dateTimeObjectType)) {
$dateValue = PHPExcel_Shared_Date::PHPToExcel($dateValue);
} else {
$saveReturnDateType = self::getReturnDateType();
self::setReturnDateType(self::RETURNDATE_EXCEL);
$dateValue = self::DATEVALUE($dateValue);
self::setReturnDateType($saveReturnDateType);
}
}
return $dateValue;
} // function _getDateValue()
/**
* TIMEVALUE
*
* @param string $timeValue
* @return mixed Excel date/time serial value, PHP date/time serial value or PHP date/time object,
* depending on the value of the ReturnDateType flag
*/
public static function TIMEVALUE($timeValue) {
$timeValue = self::flattenSingleValue($timeValue);
if ((($PHPDateArray = date_parse($timeValue)) !== False) && ($PHPDateArray['error_count'] == 0)) {
if (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE) {
$excelDateValue = PHPExcel_Shared_Date::FormattedPHPToExcel($PHPDateArray['year'],$PHPDateArray['month'],$PHPDateArray['day'],$PHPDateArray['hour'],$PHPDateArray['minute'],$PHPDateArray['second']);
} else {
$excelDateValue = PHPExcel_Shared_Date::FormattedPHPToExcel(1900,1,1,$PHPDateArray['hour'],$PHPDateArray['minute'],$PHPDateArray['second']) - 1;
}
switch (self::getReturnDateType()) {
case self::RETURNDATE_EXCEL : return (float) $excelDateValue;
break;
case self::RETURNDATE_PHP_NUMERIC : return (integer) $phpDateValue = PHPExcel_Shared_Date::ExcelToPHP($excelDateValue+25569) - 3600;;
break;
case self::RETURNDATE_PHP_OBJECT : return new DateTime('1900-01-01 '.$PHPDateArray['hour'].':'.$PHPDateArray['minute'].':'.$PHPDateArray['second']);
break;
}
}
return self::$_errorCodes['value'];
} // function TIMEVALUE()
/**
* _getTimeValue
*
* @param string $timeValue
* @return mixed Excel date/time serial value, or string if error
*/
private static function _getTimeValue($timeValue) {
$saveReturnDateType = self::getReturnDateType();
self::setReturnDateType(self::RETURNDATE_EXCEL);
$timeValue = self::TIMEVALUE($timeValue);
self::setReturnDateType($saveReturnDateType);
return $timeValue;
} // function _getTimeValue()
/**
* DATETIMENOW
*
* @return mixed Excel date/time serial value, PHP date/time serial value or PHP date/time object,
* depending on the value of the ReturnDateType flag
*/
public static function DATETIMENOW() {
$saveTimeZone = date_default_timezone_get();
date_default_timezone_set('UTC');
$retValue = False;
switch (self::getReturnDateType()) {
case self::RETURNDATE_EXCEL : $retValue = (float) PHPExcel_Shared_Date::PHPToExcel(time());
break;
case self::RETURNDATE_PHP_NUMERIC : $retValue = (integer) time();
break;
case self::RETURNDATE_PHP_OBJECT : $retValue = new DateTime();
break;
}
date_default_timezone_set($saveTimeZone);
return $retValue;
} // function DATETIMENOW()
/**
* DATENOW
*
* @return mixed Excel date/time serial value, PHP date/time serial value or PHP date/time object,
* depending on the value of the ReturnDateType flag
*/
public static function DATENOW() {
$saveTimeZone = date_default_timezone_get();
date_default_timezone_set('UTC');
$retValue = False;
$excelDateTime = floor(PHPExcel_Shared_Date::PHPToExcel(time()));
switch (self::getReturnDateType()) {
case self::RETURNDATE_EXCEL : $retValue = (float) $excelDateTime;
break;
case self::RETURNDATE_PHP_NUMERIC : $retValue = (integer) PHPExcel_Shared_Date::ExcelToPHP($excelDateTime) - 3600;
break;
case self::RETURNDATE_PHP_OBJECT : $retValue = PHPExcel_Shared_Date::ExcelToPHPObject($excelDateTime);
break;
}
date_default_timezone_set($saveTimeZone);
return $retValue;
} // function DATENOW()
private static function _isLeapYear($year) {
return ((($year % 4) == 0) && (($year % 100) != 0) || (($year % 400) == 0));
} // function _isLeapYear()
private static function _dateDiff360($startDay, $startMonth, $startYear, $endDay, $endMonth, $endYear, $methodUS) {
if ($startDay == 31) {
--$startDay;
} elseif ($methodUS && ($startMonth == 2 && ($startDay == 29 || ($startDay == 28 && !self::_isLeapYear($startYear))))) {
$startDay = 30;
}
if ($endDay == 31) {
if ($methodUS && $startDay != 30) {
$endDay = 1;
if ($endMonth == 12) {
++$endYear;
$endMonth = 1;
} else {
++$endMonth;
}
} else {
$endDay = 30;
}
}
return $endDay + $endMonth * 30 + $endYear * 360 - $startDay - $startMonth * 30 - $startYear * 360;
} // function _dateDiff360()
/**
* DAYS360
*
* @param long $startDate Excel date serial value or a standard date string
* @param long $endDate Excel date serial value or a standard date string
* @param boolean $method US or European Method
* @return long PHP date/time serial
*/
public static function DAYS360($startDate = 0, $endDate = 0, $method = false) {
$startDate = self::flattenSingleValue($startDate);
$endDate = self::flattenSingleValue($endDate);
if (is_string($startDate = self::_getDateValue($startDate))) {
return self::$_errorCodes['value'];
}
if (is_string($endDate = self::_getDateValue($endDate))) {
return self::$_errorCodes['value'];
}
// Execute function
$PHPStartDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($startDate);
$startDay = $PHPStartDateObject->format('j');
$startMonth = $PHPStartDateObject->format('n');
$startYear = $PHPStartDateObject->format('Y');
$PHPEndDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($endDate);
$endDay = $PHPEndDateObject->format('j');
$endMonth = $PHPEndDateObject->format('n');
$endYear = $PHPEndDateObject->format('Y');
return self::_dateDiff360($startDay, $startMonth, $startYear, $endDay, $endMonth, $endYear, !$method);
} // function DAYS360()
/**
* DATEDIF
*
* @param long $startDate Excel date serial value or a standard date string
* @param long $endDate Excel date serial value or a standard date string
* @param string $unit
* @return long Interval between the dates
*/
public static function DATEDIF($startDate = 0, $endDate = 0, $unit = 'D') {
$startDate = self::flattenSingleValue($startDate);
$endDate = self::flattenSingleValue($endDate);
$unit = strtoupper(self::flattenSingleValue($unit));
if (is_string($startDate = self::_getDateValue($startDate))) {
return self::$_errorCodes['value'];
}
if (is_string($endDate = self::_getDateValue($endDate))) {
return self::$_errorCodes['value'];
}
// Validate parameters
if ($startDate >= $endDate) {
return self::$_errorCodes['num'];
}
// Execute function
$difference = $endDate - $startDate;
$PHPStartDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($startDate);
$startDays = $PHPStartDateObject->format('j');
$startMonths = $PHPStartDateObject->format('n');
$startYears = $PHPStartDateObject->format('Y');
$PHPEndDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($endDate);
$endDays = $PHPEndDateObject->format('j');
$endMonths = $PHPEndDateObject->format('n');
$endYears = $PHPEndDateObject->format('Y');
$retVal = self::$_errorCodes['num'];
switch ($unit) {
case 'D':
$retVal = intval($difference);
break;
case 'M':
$retVal = intval($endMonths - $startMonths) + (intval($endYears - $startYears) * 12);
// We're only interested in full months
if ($endDays < $startDays) {
--$retVal;
}
break;
case 'Y':
$retVal = intval($endYears - $startYears);
// We're only interested in full months
if ($endMonths < $startMonths) {
--$retVal;
} elseif (($endMonths == $startMonths) && ($endDays < $startDays)) {
--$retVal;
}
break;
case 'MD':
if ($endDays < $startDays) {
$retVal = $endDays;
$PHPEndDateObject->modify('-'.$endDays.' days');
$adjustDays = $PHPEndDateObject->format('j');
if ($adjustDays > $startDays) {
$retVal += ($adjustDays - $startDays);
}
} else {
$retVal = $endDays - $startDays;
}
break;
case 'YM':
$retVal = intval($endMonths - $startMonths);
if ($retVal < 0) $retVal = 12 + $retVal;
// We're only interested in full months
if ($endDays < $startDays) {
--$retVal;
}
break;
case 'YD':
$retVal = intval($difference);
if ($endYears > $startYears) {
while ($endYears > $startYears) {
$PHPEndDateObject->modify('-1 year');
$endYears = $PHPEndDateObject->format('Y');
}
$retVal = $PHPEndDateObject->format('z') - $PHPStartDateObject->format('z');
if ($retVal < 0) { $retVal += 365; }
}
break;
}
return $retVal;
} // function DATEDIF()
/**
* YEARFRAC
*
* Calculates the fraction of the year represented by the number of whole days between two dates (the start_date and the
* end_date). Use the YEARFRAC worksheet function to identify the proportion of a whole year's benefits or obligations
* to assign to a specific term.
*
* @param mixed $startDate Excel date serial value (float), PHP date timestamp (integer) or date object, or a standard date string
* @param mixed $endDate Excel date serial value (float), PHP date timestamp (integer) or date object, or a standard date string
* @param integer $method Method used for the calculation
* 0 or omitted US (NASD) 30/360
* 1 Actual/actual
* 2 Actual/360
* 3 Actual/365
* 4 European 30/360
* @return float fraction of the year
*/
public static function YEARFRAC($startDate = 0, $endDate = 0, $method = 0) {
$startDate = self::flattenSingleValue($startDate);
$endDate = self::flattenSingleValue($endDate);
$method = self::flattenSingleValue($method);
if (is_string($startDate = self::_getDateValue($startDate))) {
return self::$_errorCodes['value'];
}
if (is_string($endDate = self::_getDateValue($endDate))) {
return self::$_errorCodes['value'];
}
if ((is_numeric($method)) && (!is_string($method))) {
switch($method) {
case 0 :
return self::DAYS360($startDate,$endDate) / 360;
break;
case 1 :
$startYear = self::YEAR($startDate);
$endYear = self::YEAR($endDate);
$leapDay = 0;
if (self::_isLeapYear($startYear) || self::_isLeapYear($endYear)) {
$leapDay = 1;
}
return self::DATEDIF($startDate,$endDate) / (365 + $leapDay);
break;
case 2 :
return self::DATEDIF($startDate,$endDate) / 360;
break;
case 3 :
return self::DATEDIF($startDate,$endDate) / 365;
break;
case 4 :
return self::DAYS360($startDate,$endDate,True) / 360;
break;
}
}
return self::$_errorCodes['value'];
} // function YEARFRAC()
/**
* NETWORKDAYS
*
* @param mixed Start date
* @param mixed End date
* @param array of mixed Optional Date Series
* @return long Interval between the dates
*/
public static function NETWORKDAYS($startDate,$endDate) {
// Flush the mandatory start and end date that are referenced in the function definition
$dateArgs = self::flattenArray(func_get_args());
array_shift($dateArgs);
array_shift($dateArgs);
// Validate the start and end dates
if (is_string($startDate = $sDate = self::_getDateValue($startDate))) {
return self::$_errorCodes['value'];
}
if (is_string($endDate = $eDate = self::_getDateValue($endDate))) {
return self::$_errorCodes['value'];
}
if ($sDate > $eDate) {
$startDate = $eDate;
$endDate = $sDate;
}
// Execute function
$startDoW = 6 - self::DAYOFWEEK($startDate,2);
if ($startDoW < 0) { $startDoW = 0; }
$endDoW = self::DAYOFWEEK($endDate,2);
if ($endDoW >= 6) { $endDoW = 0; }
$wholeWeekDays = floor(($endDate - $startDate) / 7) * 5;
$partWeekDays = $endDoW + $startDoW;
if ($partWeekDays > 5) {
$partWeekDays -= 5;
}
// Test any extra holiday parameters
$holidayCountedArray = array();
foreach ($dateArgs as $holidayDate) {
if (is_string($holidayDate = self::_getDateValue($holidayDate))) {
return self::$_errorCodes['value'];
}
if (($holidayDate >= $startDate) && ($holidayDate <= $endDate)) {
if ((self::DAYOFWEEK($holidayDate,2) < 6) && (!in_array($holidayDate,$holidayCountedArray))) {
--$partWeekDays;
$holidayCountedArray[] = $holidayDate;
}
}
}
if ($sDate > $eDate) {
return 0 - ($wholeWeekDays + $partWeekDays);
}
return $wholeWeekDays + $partWeekDays;
} // function NETWORKDAYS()
/**
* WORKDAY
*
* @param mixed Start date
* @param mixed number of days for adjustment
* @param array of mixed Optional Date Series
* @return long Interval between the dates
*/
public static function WORKDAY($startDate,$endDays) {
$dateArgs = self::flattenArray(func_get_args());
array_shift($dateArgs);
array_shift($dateArgs);
if (is_string($startDate = self::_getDateValue($startDate))) {
return self::$_errorCodes['value'];
}
if (!is_numeric($endDays)) {
return self::$_errorCodes['value'];
}
$endDate = (float) $startDate + (floor($endDays / 5) * 7) + ($endDays % 5);
if ($endDays < 0) {
$endDate += 7;
}
$endDoW = self::DAYOFWEEK($endDate,3);
if ($endDoW >= 5) {
if ($endDays >= 0) {
$endDate += (7 - $endDoW);
} else {
$endDate -= ($endDoW - 5);
}
}
// Test any extra holiday parameters
if (count($dateArgs) > 0) {
$holidayCountedArray = $holidayDates = array();
foreach ($dateArgs as $holidayDate) {
if (is_string($holidayDate = self::_getDateValue($holidayDate))) {
return self::$_errorCodes['value'];
}
$holidayDates[] = $holidayDate;
}
if ($endDays >= 0) {
sort($holidayDates, SORT_NUMERIC);
} else {
rsort($holidayDates, SORT_NUMERIC);
}
foreach ($holidayDates as $holidayDate) {
if ($endDays >= 0) {
if (($holidayDate >= $startDate) && ($holidayDate <= $endDate)) {
if ((self::DAYOFWEEK($holidayDate,2) < 6) && (!in_array($holidayDate,$holidayCountedArray))) {
++$endDate;
$holidayCountedArray[] = $holidayDate;
}
}
} else {
if (($holidayDate <= $startDate) && ($holidayDate >= $endDate)) {
if ((self::DAYOFWEEK($holidayDate,2) < 6) && (!in_array($holidayDate,$holidayCountedArray))) {
--$endDate;
$holidayCountedArray[] = $holidayDate;
}
}
}
$endDoW = self::DAYOFWEEK($endDate,3);
if ($endDoW >= 5) {
if ($endDays >= 0) {
$endDate += (7 - $endDoW);
} else {
$endDate -= ($endDoW - 5);
}
}
}
}
switch (self::getReturnDateType()) {
case self::RETURNDATE_EXCEL : return (float) $endDate;
break;
case self::RETURNDATE_PHP_NUMERIC : return (integer) PHPExcel_Shared_Date::ExcelToPHP($endDate);
break;
case self::RETURNDATE_PHP_OBJECT : return PHPExcel_Shared_Date::ExcelToPHPObject($endDate);
break;
}
} // function WORKDAY()
/**
* DAYOFMONTH
*
* @param long $dateValue Excel date serial value or a standard date string
* @return int Day
*/
public static function DAYOFMONTH($dateValue = 1) {
$dateValue = self::flattenSingleValue($dateValue);
if (is_string($dateValue = self::_getDateValue($dateValue))) {
return self::$_errorCodes['value'];
} elseif ($dateValue == 0.0) {
return 0;
} elseif ($dateValue < 0.0) {
return self::$_errorCodes['num'];
}
// Execute function
$PHPDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($dateValue);
return (int) $PHPDateObject->format('j');
} // function DAYOFMONTH()
/**
* DAYOFWEEK
*
* @param long $dateValue Excel date serial value or a standard date string
* @return int Day
*/
public static function DAYOFWEEK($dateValue = 1, $style = 1) {
$dateValue = self::flattenSingleValue($dateValue);
$style = floor(self::flattenSingleValue($style));
if (is_string($dateValue = self::_getDateValue($dateValue))) {
return self::$_errorCodes['value'];
} elseif ($dateValue < 0.0) {
return self::$_errorCodes['num'];
}
// Execute function
$PHPDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($dateValue);
$DoW = $PHPDateObject->format('w');
$firstDay = 1;
switch ($style) {
case 1: ++$DoW;
break;
case 2: if ($DoW == 0) { $DoW = 7; }
break;
case 3: if ($DoW == 0) { $DoW = 7; }
$firstDay = 0;
--$DoW;
break;
default:
}
if (self::$compatibilityMode == self::COMPATIBILITY_EXCEL) {
// Test for Excel's 1900 leap year, and introduce the error as required
if (($PHPDateObject->format('Y') == 1900) && ($PHPDateObject->format('n') <= 2)) {
--$DoW;
if ($DoW < $firstDay) {
$DoW += 7;
}
}
}
return (int) $DoW;
} // function DAYOFWEEK()
/**
* WEEKOFYEAR
*
* @param long $dateValue Excel date serial value or a standard date string
* @param boolean $method Week begins on Sunday or Monday
* @return int Week Number
*/
public static function WEEKOFYEAR($dateValue = 1, $method = 1) {
$dateValue = self::flattenSingleValue($dateValue);
$method = floor(self::flattenSingleValue($method));
if (!is_numeric($method)) {
return self::$_errorCodes['value'];
} elseif (($method < 1) || ($method > 2)) {
return self::$_errorCodes['num'];
}
if (is_string($dateValue = self::_getDateValue($dateValue))) {
return self::$_errorCodes['value'];
} elseif ($dateValue < 0.0) {
return self::$_errorCodes['num'];
}
// Execute function
$PHPDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($dateValue);
$dayOfYear = $PHPDateObject->format('z');
$dow = $PHPDateObject->format('w');
$PHPDateObject->modify('-'.$dayOfYear.' days');
$dow = $PHPDateObject->format('w');
$daysInFirstWeek = 7 - (($dow + (2 - $method)) % 7);
$dayOfYear -= $daysInFirstWeek;
$weekOfYear = ceil($dayOfYear / 7) + 1;
return (int) $weekOfYear;
} // function WEEKOFYEAR()
/**
* MONTHOFYEAR
*
* @param long $dateValue Excel date serial value or a standard date string
* @return int Month
*/
public static function MONTHOFYEAR($dateValue = 1) {
$dateValue = self::flattenSingleValue($dateValue);
if (is_string($dateValue = self::_getDateValue($dateValue))) {
return self::$_errorCodes['value'];
} elseif ($dateValue < 0.0) {
return self::$_errorCodes['num'];
}
// Execute function
$PHPDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($dateValue);
return (int) $PHPDateObject->format('n');
} // function MONTHOFYEAR()
/**
* YEAR
*
* @param long $dateValue Excel date serial value or a standard date string
* @return int Year
*/
public static function YEAR($dateValue = 1) {
$dateValue = self::flattenSingleValue($dateValue);
if (is_string($dateValue = self::_getDateValue($dateValue))) {
return self::$_errorCodes['value'];
} elseif ($dateValue < 0.0) {
return self::$_errorCodes['num'];
}
// Execute function
$PHPDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($dateValue);
return (int) $PHPDateObject->format('Y');
} // function YEAR()
/**
* HOUROFDAY
*
* @param mixed $timeValue Excel time serial value or a standard time string
* @return int Hour
*/
public static function HOUROFDAY($timeValue = 0) {
$timeValue = self::flattenSingleValue($timeValue);
if (!is_numeric($timeValue)) {
if (self::$compatibilityMode == self::COMPATIBILITY_GNUMERIC) {
$testVal = strtok($timeValue,'/-: ');
if (strlen($testVal) < strlen($timeValue)) {
return self::$_errorCodes['value'];
}
}
$timeValue = self::_getTimeValue($timeValue);
if (is_string($timeValue)) {
return self::$_errorCodes['value'];
}
}
// Execute function
if ($timeValue >= 1) {
$timeValue = fmod($timeValue,1);
} elseif ($timeValue < 0.0) {
return self::$_errorCodes['num'];
}
$timeValue = PHPExcel_Shared_Date::ExcelToPHP($timeValue);
return (int) gmdate('G',$timeValue);
} // function HOUROFDAY()
/**
* MINUTEOFHOUR
*
* @param long $timeValue Excel time serial value or a standard time string
* @return int Minute
*/
public static function MINUTEOFHOUR($timeValue = 0) {
$timeValue = $timeTester = self::flattenSingleValue($timeValue);
if (!is_numeric($timeValue)) {
if (self::$compatibilityMode == self::COMPATIBILITY_GNUMERIC) {
$testVal = strtok($timeValue,'/-: ');
if (strlen($testVal) < strlen($timeValue)) {
return self::$_errorCodes['value'];
}
}
$timeValue = self::_getTimeValue($timeValue);
if (is_string($timeValue)) {
return self::$_errorCodes['value'];
}
}
// Execute function
if ($timeValue >= 1) {
$timeValue = fmod($timeValue,1);
} elseif ($timeValue < 0.0) {
return self::$_errorCodes['num'];
}
$timeValue = PHPExcel_Shared_Date::ExcelToPHP($timeValue);
return (int) gmdate('i',$timeValue);
} // function MINUTEOFHOUR()
/**
* SECONDOFMINUTE
*
* @param long $timeValue Excel time serial value or a standard time string
* @return int Second
*/
public static function SECONDOFMINUTE($timeValue = 0) {
$timeValue = self::flattenSingleValue($timeValue);
if (!is_numeric($timeValue)) {
if (self::$compatibilityMode == self::COMPATIBILITY_GNUMERIC) {
$testVal = strtok($timeValue,'/-: ');
if (strlen($testVal) < strlen($timeValue)) {
return self::$_errorCodes['value'];
}
}
$timeValue = self::_getTimeValue($timeValue);
if (is_string($timeValue)) {
return self::$_errorCodes['value'];
}
}
// Execute function
if ($timeValue >= 1) {
$timeValue = fmod($timeValue,1);
} elseif ($timeValue < 0.0) {
return self::$_errorCodes['num'];
}
$timeValue = PHPExcel_Shared_Date::ExcelToPHP($timeValue);
return (int) gmdate('s',$timeValue);
} // function SECONDOFMINUTE()
private static function _adjustDateByMonths($dateValue = 0, $adjustmentMonths = 0) {
// Execute function
$PHPDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($dateValue);
$oMonth = (int) $PHPDateObject->format('m');
$oYear = (int) $PHPDateObject->format('Y');
$adjustmentMonthsString = (string) $adjustmentMonths;
if ($adjustmentMonths > 0) {
$adjustmentMonthsString = '+'.$adjustmentMonths;
}
if ($adjustmentMonths != 0) {
$PHPDateObject->modify($adjustmentMonthsString.' months');
}
$nMonth = (int) $PHPDateObject->format('m');
$nYear = (int) $PHPDateObject->format('Y');
$monthDiff = ($nMonth - $oMonth) + (($nYear - $oYear) * 12);
if ($monthDiff != $adjustmentMonths) {
$adjustDays = (int) $PHPDateObject->format('d');
$adjustDaysString = '-'.$adjustDays.' days';
$PHPDateObject->modify($adjustDaysString);
}
return $PHPDateObject;
} // function _adjustDateByMonths()
/**
* EDATE
*
* Returns the serial number that represents the date that is the indicated number of months before or after a specified date
* (the start_date). Use EDATE to calculate maturity dates or due dates that fall on the same day of the month as the date of issue.
*
* @param long $dateValue Excel date serial value or a standard date string
* @param int $adjustmentMonths Number of months to adjust by
* @return long Excel date serial value
*/
public static function EDATE($dateValue = 1, $adjustmentMonths = 0) {
$dateValue = self::flattenSingleValue($dateValue);
$adjustmentMonths = floor(self::flattenSingleValue($adjustmentMonths));
if (!is_numeric($adjustmentMonths)) {
return self::$_errorCodes['value'];
}
if (is_string($dateValue = self::_getDateValue($dateValue))) {
return self::$_errorCodes['value'];
}
// Execute function
$PHPDateObject = self::_adjustDateByMonths($dateValue,$adjustmentMonths);
switch (self::getReturnDateType()) {
case self::RETURNDATE_EXCEL : return (float) PHPExcel_Shared_Date::PHPToExcel($PHPDateObject);
break;
case self::RETURNDATE_PHP_NUMERIC : return (integer) PHPExcel_Shared_Date::ExcelToPHP(PHPExcel_Shared_Date::PHPToExcel($PHPDateObject));
break;
case self::RETURNDATE_PHP_OBJECT : return $PHPDateObject;
break;
}
} // function EDATE()
/**
* EOMONTH
*
* Returns the serial number for the last day of the month that is the indicated number of months before or after start_date.
* Use EOMONTH to calculate maturity dates or due dates that fall on the last day of the month.
*
* @param long $dateValue Excel date serial value or a standard date string
* @param int $adjustmentMonths Number of months to adjust by
* @return long Excel date serial value
*/
public static function EOMONTH($dateValue = 1, $adjustmentMonths = 0) {
$dateValue = self::flattenSingleValue($dateValue);
$adjustmentMonths = floor(self::flattenSingleValue($adjustmentMonths));
if (!is_numeric($adjustmentMonths)) {
return self::$_errorCodes['value'];
}
if (is_string($dateValue = self::_getDateValue($dateValue))) {
return self::$_errorCodes['value'];
}
// Execute function
$PHPDateObject = self::_adjustDateByMonths($dateValue,$adjustmentMonths+1);
$adjustDays = (int) $PHPDateObject->format('d');
$adjustDaysString = '-'.$adjustDays.' days';
$PHPDateObject->modify($adjustDaysString);
switch (self::getReturnDateType()) {
case self::RETURNDATE_EXCEL : return (float) PHPExcel_Shared_Date::PHPToExcel($PHPDateObject);
break;
case self::RETURNDATE_PHP_NUMERIC : return (integer) PHPExcel_Shared_Date::ExcelToPHP(PHPExcel_Shared_Date::PHPToExcel($PHPDateObject));
break;
case self::RETURNDATE_PHP_OBJECT : return $PHPDateObject;
break;
}
} // function EOMONTH()
/**
* TRUNC
*
* Truncates value to the number of fractional digits by number_digits.
*
* @param float $value
* @param int $number_digits
* @return float Truncated value
*/
public static function TRUNC($value = 0, $number_digits = 0) {
$value = self::flattenSingleValue($value);
$number_digits = self::flattenSingleValue($number_digits);
// Validate parameters
if ($number_digits < 0) {
return self::$_errorCodes['value'];
}
// Truncate
if ($number_digits > 0) {
$value = $value * pow(10, $number_digits);
}
$value = intval($value);
if ($number_digits > 0) {
$value = $value / pow(10, $number_digits);
}
// Return
return $value;
} // function TRUNC()
/**
* POWER
*
* Computes x raised to the power y.
*
* @param float $x
* @param float $y
* @return float
*/
public static function POWER($x = 0, $y = 2) {
$x = self::flattenSingleValue($x);
$y = self::flattenSingleValue($y);
// Validate parameters
if ($x == 0 && $y <= 0) {
return self::$_errorCodes['divisionbyzero'];
}
// Return
return pow($x, $y);
} // function POWER()
private static function _nbrConversionFormat($xVal,$places) {
if (!is_null($places)) {
if (strlen($xVal) <= $places) {
return substr(str_pad($xVal,$places,'0',STR_PAD_LEFT),-10);
} else {
return self::$_errorCodes['num'];
}
}
return substr($xVal,-10);
} // function _nbrConversionFormat()
/**
* BINTODEC
*
* Return a binary value as Decimal.
*
* @param string $x
* @return string
*/
public static function BINTODEC($x) {
$x = self::flattenSingleValue($x);
if (is_bool($x)) {
if (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE) {
$x = (int) $x;
} else {
return self::$_errorCodes['value'];
}
}
if (self::$compatibilityMode == self::COMPATIBILITY_GNUMERIC) {
$x = floor($x);
}
$x = (string) $x;
if (strlen($x) > preg_match_all('/[01]/',$x,$out)) {
return self::$_errorCodes['num'];
}
if (strlen($x) > 10) {
return self::$_errorCodes['num'];
} elseif (strlen($x) == 10) {
// Two's Complement
$x = substr($x,-9);
return '-'.(512-bindec($x));
}
return bindec($x);
} // function BINTODEC()
/**
* BINTOHEX
*
* Return a binary value as Hex.
*
* @param string $x
* @return string
*/
public static function BINTOHEX($x, $places=null) {
$x = floor(self::flattenSingleValue($x));
$places = self::flattenSingleValue($places);
if (is_bool($x)) {
if (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE) {
$x = (int) $x;
} else {
return self::$_errorCodes['value'];
}
}
if (self::$compatibilityMode == self::COMPATIBILITY_GNUMERIC) {
$x = floor($x);
}
$x = (string) $x;
if (strlen($x) > preg_match_all('/[01]/',$x,$out)) {
return self::$_errorCodes['num'];
}
if (strlen($x) > 10) {
return self::$_errorCodes['num'];
} elseif (strlen($x) == 10) {
// Two's Complement
return str_repeat('F',8).substr(strtoupper(dechex(bindec(substr($x,-9)))),-2);
}
$hexVal = (string) strtoupper(dechex(bindec($x)));
return self::_nbrConversionFormat($hexVal,$places);
} // function BINTOHEX()
/**
* BINTOOCT
*
* Return a binary value as Octal.
*
* @param string $x
* @return string
*/
public static function BINTOOCT($x, $places=null) {
$x = floor(self::flattenSingleValue($x));
$places = self::flattenSingleValue($places);
if (is_bool($x)) {
if (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE) {
$x = (int) $x;
} else {
return self::$_errorCodes['value'];
}
}
if (self::$compatibilityMode == self::COMPATIBILITY_GNUMERIC) {
$x = floor($x);
}
$x = (string) $x;
if (strlen($x) > preg_match_all('/[01]/',$x,$out)) {
return self::$_errorCodes['num'];
}
if (strlen($x) > 10) {
return self::$_errorCodes['num'];
} elseif (strlen($x) == 10) {
// Two's Complement
return str_repeat('7',7).substr(strtoupper(decoct(bindec(substr($x,-9)))),-3);
}
$octVal = (string) decoct(bindec($x));
return self::_nbrConversionFormat($octVal,$places);
} // function BINTOOCT()
/**
* DECTOBIN
*
* Return an octal value as binary.
*
* @param string $x
* @return string
*/
public static function DECTOBIN($x, $places=null) {
$x = self::flattenSingleValue($x);
$places = self::flattenSingleValue($places);
if (is_bool($x)) {
if (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE) {
$x = (int) $x;
} else {
return self::$_errorCodes['value'];
}
}
$x = (string) $x;
if (strlen($x) > preg_match_all('/[-0123456789.]/',$x,$out)) {
return self::$_errorCodes['value'];
}
$x = (string) floor($x);
$r = decbin($x);
if (strlen($r) == 32) {
// Two's Complement
$r = substr($r,-10);
} elseif (strlen($r) > 11) {
return self::$_errorCodes['num'];
}
return self::_nbrConversionFormat($r,$places);
} // function DECTOBIN()
/**
* DECTOOCT
*
* Return an octal value as binary.
*
* @param string $x
* @return string
*/
public static function DECTOOCT($x, $places=null) {
$x = self::flattenSingleValue($x);
$places = self::flattenSingleValue($places);
if (is_bool($x)) {
if (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE) {
$x = (int) $x;
} else {
return self::$_errorCodes['value'];
}
}
$x = (string) $x;
if (strlen($x) > preg_match_all('/[-0123456789.]/',$x,$out)) {
return self::$_errorCodes['value'];
}
$x = (string) floor($x);
$r = decoct($x);
if (strlen($r) == 11) {
// Two's Complement
$r = substr($r,-10);
}
return self::_nbrConversionFormat($r,$places);
} // function DECTOOCT()
/**
* DECTOHEX
*
* Return an octal value as binary.
*
* @param string $x
* @return string
*/
public static function DECTOHEX($x, $places=null) {
$x = self::flattenSingleValue($x);
$places = self::flattenSingleValue($places);
if (is_bool($x)) {
if (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE) {
$x = (int) $x;
} else {
return self::$_errorCodes['value'];
}
}
$x = (string) $x;
if (strlen($x) > preg_match_all('/[-0123456789.]/',$x,$out)) {
return self::$_errorCodes['value'];
}
$x = (string) floor($x);
$r = strtoupper(dechex($x));
if (strlen($r) == 8) {
// Two's Complement
$r = 'FF'.$r;
}
return self::_nbrConversionFormat($r,$places);
} // function DECTOHEX()
/**
* HEXTOBIN
*
* Return a hex value as binary.
*
* @param string $x
* @return string
*/
public static function HEXTOBIN($x, $places=null) {
$x = self::flattenSingleValue($x);
$places = self::flattenSingleValue($places);
if (is_bool($x)) {
return self::$_errorCodes['value'];
}
$x = (string) $x;
if (strlen($x) > preg_match_all('/[0123456789ABCDEF]/',strtoupper($x),$out)) {
return self::$_errorCodes['num'];
}
$binVal = decbin(hexdec($x));
return substr(self::_nbrConversionFormat($binVal,$places),-10);
} // function HEXTOBIN()
/**
* HEXTOOCT
*
* Return a hex value as octal.
*
* @param string $x
* @return string
*/
public static function HEXTOOCT($x, $places=null) {
$x = self::flattenSingleValue($x);
$places = self::flattenSingleValue($places);
if (is_bool($x)) {
return self::$_errorCodes['value'];
}
$x = (string) $x;
if (strlen($x) > preg_match_all('/[0123456789ABCDEF]/',strtoupper($x),$out)) {
return self::$_errorCodes['num'];
}
$octVal = decoct(hexdec($x));
return self::_nbrConversionFormat($octVal,$places);
} // function HEXTOOCT()
/**
* HEXTODEC
*
* Return a hex value as octal.
*
* @param string $x
* @return string
*/
public static function HEXTODEC($x) {
$x = self::flattenSingleValue($x);
if (is_bool($x)) {
return self::$_errorCodes['value'];
}
$x = (string) $x;
if (strlen($x) > preg_match_all('/[0123456789ABCDEF]/',strtoupper($x),$out)) {
return self::$_errorCodes['num'];
}
return hexdec($x);
} // function HEXTODEC()
/**
* OCTTOBIN
*
* Return an octal value as binary.
*
* @param string $x
* @return string
*/
public static function OCTTOBIN($x, $places=null) {
$x = self::flattenSingleValue($x);
$places = self::flattenSingleValue($places);
if (is_bool($x)) {
return self::$_errorCodes['value'];
}
$x = (string) $x;
if (preg_match_all('/[01234567]/',$x,$out) != strlen($x)) {
return self::$_errorCodes['num'];
}
$r = decbin(octdec($x));
return self::_nbrConversionFormat($r,$places);
} // function OCTTOBIN()
/**
* OCTTODEC
*
* Return an octal value as binary.
*
* @param string $x
* @return string
*/
public static function OCTTODEC($x) {
$x = self::flattenSingleValue($x);
if (is_bool($x)) {
return self::$_errorCodes['value'];
}
$x = (string) $x;
if (preg_match_all('/[01234567]/',$x,$out) != strlen($x)) {
return self::$_errorCodes['num'];
}
return octdec($x);
} // function OCTTODEC()
/**
* OCTTOHEX
*
* Return an octal value as hex.
*
* @param string $x
* @return string
*/
public static function OCTTOHEX($x, $places=null) {
$x = self::flattenSingleValue($x);
$places = self::flattenSingleValue($places);
if (is_bool($x)) {
return self::$_errorCodes['value'];
}
$x = (string) $x;
if (preg_match_all('/[01234567]/',$x,$out) != strlen($x)) {
return self::$_errorCodes['num'];
}
$hexVal = strtoupper(dechex(octdec($x)));
return self::_nbrConversionFormat($hexVal,$places);
} // function OCTTOHEX()
public static function _parseComplex($complexNumber) {
$workString = (string) $complexNumber;
$realNumber = $imaginary = 0;
// Extract the suffix, if there is one
$suffix = substr($workString,-1);
if (!is_numeric($suffix)) {
$workString = substr($workString,0,-1);
} else {
$suffix = '';
}
// Split the input into its Real and Imaginary components
$leadingSign = 0;
if (strlen($workString) > 0) {
$leadingSign = (($workString{0} == '+') || ($workString{0} == '-')) ? 1 : 0;
}
$power = '';
$realNumber = strtok($workString, '+-');
if (strtoupper(substr($realNumber,-1)) == 'E') {
$power = strtok('+-');
++$leadingSign;
}
$realNumber = substr($workString,0,strlen($realNumber)+strlen($power)+$leadingSign);
if ($suffix != '') {
$imaginary = substr($workString,strlen($realNumber));
if (($imaginary == '') && (($realNumber == '') || ($realNumber == '+') || ($realNumber == '-'))) {
$imaginary = $realNumber.'1';
$realNumber = '0';
} else if ($imaginary == '') {
$imaginary = $realNumber;
$realNumber = '0';
} elseif (($imaginary == '+') || ($imaginary == '-')) {
$imaginary .= '1';
}
}
$complexArray = array( 'real' => $realNumber,
'imaginary' => $imaginary,
'suffix' => $suffix
);
return $complexArray;
} // function _parseComplex()
private static function _cleanComplex($complexNumber) {
if ($complexNumber{0} == '+') $complexNumber = substr($complexNumber,1);
if ($complexNumber{0} == '0') $complexNumber = substr($complexNumber,1);
if ($complexNumber{0} == '.') $complexNumber = '0'.$complexNumber;
if ($complexNumber{0} == '+') $complexNumber = substr($complexNumber,1);
return $complexNumber;
}
/**
* COMPLEX
*
* returns a complex number of the form x + yi or x + yj.
*
* @param float $realNumber
* @param float $imaginary
* @param string $suffix
* @return string
*/
public static function COMPLEX($realNumber=0.0, $imaginary=0.0, $suffix='i') {
$realNumber = self::flattenSingleValue($realNumber);
$imaginary = self::flattenSingleValue($imaginary);
$suffix = self::flattenSingleValue($suffix);
if (((is_numeric($realNumber)) && (is_numeric($imaginary))) &&
(($suffix == 'i') || ($suffix == 'j') || ($suffix == ''))) {
if ($realNumber == 0.0) {
if ($imaginary == 0.0) {
return (string) '0';
} elseif ($imaginary == 1.0) {
return (string) $suffix;
} elseif ($imaginary == -1.0) {
return (string) '-'.$suffix;
}
return (string) $imaginary.$suffix;
} elseif ($imaginary == 0.0) {
return (string) $realNumber;
} elseif ($imaginary == 1.0) {
return (string) $realNumber.'+'.$suffix;
} elseif ($imaginary == -1.0) {
return (string) $realNumber.'-'.$suffix;
}
if ($imaginary > 0) { $imaginary = (string) '+'.$imaginary; }
return (string) $realNumber.$imaginary.$suffix;
}
return self::$_errorCodes['value'];
} // function COMPLEX()
/**
* IMAGINARY
*
* Returns the imaginary coefficient of a complex number in x + yi or x + yj text format.
*
* @param string $complexNumber
* @return real
*/
public static function IMAGINARY($complexNumber) {
$complexNumber = self::flattenSingleValue($complexNumber);
$parsedComplex = self::_parseComplex($complexNumber);
if (!is_array($parsedComplex)) {
return $parsedComplex;
}
return $parsedComplex['imaginary'];
} // function IMAGINARY()
/**
* IMREAL
*
* Returns the real coefficient of a complex number in x + yi or x + yj text format.
*
* @param string $complexNumber
* @return real
*/
public static function IMREAL($complexNumber) {
$complexNumber = self::flattenSingleValue($complexNumber);
$parsedComplex = self::_parseComplex($complexNumber);
if (!is_array($parsedComplex)) {
return $parsedComplex;
}
return $parsedComplex['real'];
} // function IMREAL()
/**
* IMABS
*
* Returns the absolute value (modulus) of a complex number in x + yi or x + yj text format.
*
* @param string $complexNumber
* @return real
*/
public static function IMABS($complexNumber) {
$complexNumber = self::flattenSingleValue($complexNumber);
$parsedComplex = self::_parseComplex($complexNumber);
if (!is_array($parsedComplex)) {
return $parsedComplex;
}
return sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary']));
} // function IMABS()
/**
* IMARGUMENT
*
* Returns the argument theta of a complex number, i.e. the angle in radians from the real axis to the representation of the number in polar coordinates.
*
* @param string $complexNumber
* @return string
*/
public static function IMARGUMENT($complexNumber) {
$complexNumber = self::flattenSingleValue($complexNumber);
$parsedComplex = self::_parseComplex($complexNumber);
if (!is_array($parsedComplex)) {
return $parsedComplex;
}
if ($parsedComplex['real'] == 0.0) {
if ($parsedComplex['imaginary'] == 0.0) {
return 0.0;
} elseif($parsedComplex['imaginary'] < 0.0) {
return M_PI / -2;
} else {
return M_PI / 2;
}
} elseif ($parsedComplex['real'] > 0.0) {
return atan($parsedComplex['imaginary'] / $parsedComplex['real']);
} elseif ($parsedComplex['imaginary'] < 0.0) {
return 0 - (M_PI - atan(abs($parsedComplex['imaginary']) / abs($parsedComplex['real'])));
} else {
return M_PI - atan($parsedComplex['imaginary'] / abs($parsedComplex['real']));
}
} // function IMARGUMENT()
/**
* IMCONJUGATE
*
* Returns the complex conjugate of a complex number in x + yi or x + yj text format.
*
* @param string $complexNumber
* @return string
*/
public static function IMCONJUGATE($complexNumber) {
$complexNumber = self::flattenSingleValue($complexNumber);
$parsedComplex = self::_parseComplex($complexNumber);
if (!is_array($parsedComplex)) {
return $parsedComplex;
}
if ($parsedComplex['imaginary'] == 0.0) {
return $parsedComplex['real'];
} else {
return self::_cleanComplex(self::COMPLEX($parsedComplex['real'], 0 - $parsedComplex['imaginary'], $parsedComplex['suffix']));
}
} // function IMCONJUGATE()
/**
* IMCOS
*
* Returns the cosine of a complex number in x + yi or x + yj text format.
*
* @param string $complexNumber
* @return string
*/
public static function IMCOS($complexNumber) {
$complexNumber = self::flattenSingleValue($complexNumber);
$parsedComplex = self::_parseComplex($complexNumber);
if (!is_array($parsedComplex)) {
return $parsedComplex;
}
if ($parsedComplex['imaginary'] == 0.0) {
return cos($parsedComplex['real']);
} else {
return self::IMCONJUGATE(self::COMPLEX(cos($parsedComplex['real']) * cosh($parsedComplex['imaginary']),sin($parsedComplex['real']) * sinh($parsedComplex['imaginary']),$parsedComplex['suffix']));
}
} // function IMCOS()
/**
* IMSIN
*
* Returns the sine of a complex number in x + yi or x + yj text format.
*
* @param string $complexNumber
* @return string
*/
public static function IMSIN($complexNumber) {
$complexNumber = self::flattenSingleValue($complexNumber);
$parsedComplex = self::_parseComplex($complexNumber);
if (!is_array($parsedComplex)) {
return $parsedComplex;
}
if ($parsedComplex['imaginary'] == 0.0) {
return sin($parsedComplex['real']);
} else {
return self::COMPLEX(sin($parsedComplex['real']) * cosh($parsedComplex['imaginary']),cos($parsedComplex['real']) * sinh($parsedComplex['imaginary']),$parsedComplex['suffix']);
}
} // function IMSIN()
/**
* IMSQRT
*
* Returns the square root of a complex number in x + yi or x + yj text format.
*
* @param string $complexNumber
* @return string
*/
public static function IMSQRT($complexNumber) {
$complexNumber = self::flattenSingleValue($complexNumber);
$parsedComplex = self::_parseComplex($complexNumber);
if (!is_array($parsedComplex)) {
return $parsedComplex;
}
$theta = self::IMARGUMENT($complexNumber);
$d1 = cos($theta / 2);
$d2 = sin($theta / 2);
$r = sqrt(sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary'])));
if ($parsedComplex['suffix'] == '') {
return self::COMPLEX($d1 * $r,$d2 * $r);
} else {
return self::COMPLEX($d1 * $r,$d2 * $r,$parsedComplex['suffix']);
}
} // function IMSQRT()
/**
* IMLN
*
* Returns the natural logarithm of a complex number in x + yi or x + yj text format.
*
* @param string $complexNumber
* @return string
*/
public static function IMLN($complexNumber) {
$complexNumber = self::flattenSingleValue($complexNumber);
$parsedComplex = self::_parseComplex($complexNumber);
if (!is_array($parsedComplex)) {
return $parsedComplex;
}
if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
return self::$_errorCodes['num'];
}
$logR = log(sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary'])));
$t = self::IMARGUMENT($complexNumber);
if ($parsedComplex['suffix'] == '') {
return self::COMPLEX($logR,$t);
} else {
return self::COMPLEX($logR,$t,$parsedComplex['suffix']);
}
} // function IMLN()
/**
* IMLOG10
*
* Returns the common logarithm (base 10) of a complex number in x + yi or x + yj text format.
*
* @param string $complexNumber
* @return string
*/
public static function IMLOG10($complexNumber) {
$complexNumber = self::flattenSingleValue($complexNumber);
$parsedComplex = self::_parseComplex($complexNumber);
if (!is_array($parsedComplex)) {
return $parsedComplex;
}
if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
return self::$_errorCodes['num'];
} elseif (($parsedComplex['real'] > 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
return log10($parsedComplex['real']);
}
return self::IMPRODUCT(log10(EULER),self::IMLN($complexNumber));
} // function IMLOG10()
/**
* IMLOG2
*
* Returns the common logarithm (base 10) of a complex number in x + yi or x + yj text format.
*
* @param string $complexNumber
* @return string
*/
public static function IMLOG2($complexNumber) {
$complexNumber = self::flattenSingleValue($complexNumber);
$parsedComplex = self::_parseComplex($complexNumber);
if (!is_array($parsedComplex)) {
return $parsedComplex;
}
if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
return self::$_errorCodes['num'];
} elseif (($parsedComplex['real'] > 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
return log($parsedComplex['real'],2);
}
return self::IMPRODUCT(log(EULER,2),self::IMLN($complexNumber));
} // function IMLOG2()
/**
* IMEXP
*
* Returns the exponential of a complex number in x + yi or x + yj text format.
*
* @param string $complexNumber
* @return string
*/
public static function IMEXP($complexNumber) {
$complexNumber = self::flattenSingleValue($complexNumber);
$parsedComplex = self::_parseComplex($complexNumber);
if (!is_array($parsedComplex)) {
return $parsedComplex;
}
if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
return '1';
}
$e = exp($parsedComplex['real']);
$eX = $e * cos($parsedComplex['imaginary']);
$eY = $e * sin($parsedComplex['imaginary']);
if ($parsedComplex['suffix'] == '') {
return self::COMPLEX($eX,$eY);
} else {
return self::COMPLEX($eX,$eY,$parsedComplex['suffix']);
}
} // function IMEXP()
/**
* IMPOWER
*
* Returns a complex number in x + yi or x + yj text format raised to a power.
*
* @param string $complexNumber
* @return string
*/
public static function IMPOWER($complexNumber,$realNumber) {
$complexNumber = self::flattenSingleValue($complexNumber);
$realNumber = self::flattenSingleValue($realNumber);
if (!is_numeric($realNumber)) {
return self::$_errorCodes['value'];
}
$parsedComplex = self::_parseComplex($complexNumber);
if (!is_array($parsedComplex)) {
return $parsedComplex;
}
$r = sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary']));
$rPower = pow($r,$realNumber);
$theta = self::IMARGUMENT($complexNumber) * $realNumber;
if ($theta == 0) {
return 1;
} elseif ($parsedComplex['imaginary'] == 0.0) {
return self::COMPLEX($rPower * cos($theta),$rPower * sin($theta),$parsedComplex['suffix']);
} else {
return self::COMPLEX($rPower * cos($theta),$rPower * sin($theta),$parsedComplex['suffix']);
}
} // function IMPOWER()
/**
* IMDIV
*
* Returns the quotient of two complex numbers in x + yi or x + yj text format.
*
* @param string $complexDividend
* @param string $complexDivisor
* @return real
*/
public static function IMDIV($complexDividend,$complexDivisor) {
$complexDividend = self::flattenSingleValue($complexDividend);
$complexDivisor = self::flattenSingleValue($complexDivisor);
$parsedComplexDividend = self::_parseComplex($complexDividend);
if (!is_array($parsedComplexDividend)) {
return $parsedComplexDividend;
}
$parsedComplexDivisor = self::_parseComplex($complexDivisor);
if (!is_array($parsedComplexDivisor)) {
return $parsedComplexDividend;
}
if (($parsedComplexDividend['suffix'] != '') && ($parsedComplexDivisor['suffix'] != '') &&
($parsedComplexDividend['suffix'] != $parsedComplexDivisor['suffix'])) {
return self::$_errorCodes['num'];
}
if (($parsedComplexDividend['suffix'] != '') && ($parsedComplexDivisor['suffix'] == '')) {
$parsedComplexDivisor['suffix'] = $parsedComplexDividend['suffix'];
}
$d1 = ($parsedComplexDividend['real'] * $parsedComplexDivisor['real']) + ($parsedComplexDividend['imaginary'] * $parsedComplexDivisor['imaginary']);
$d2 = ($parsedComplexDividend['imaginary'] * $parsedComplexDivisor['real']) - ($parsedComplexDividend['real'] * $parsedComplexDivisor['imaginary']);
$d3 = ($parsedComplexDivisor['real'] * $parsedComplexDivisor['real']) + ($parsedComplexDivisor['imaginary'] * $parsedComplexDivisor['imaginary']);
$r = $d1/$d3;
$i = $d2/$d3;
if ($i > 0.0) {
return self::_cleanComplex($r.'+'.$i.$parsedComplexDivisor['suffix']);
} elseif ($i < 0.0) {
return self::_cleanComplex($r.$i.$parsedComplexDivisor['suffix']);
} else {
return $r;
}
} // function IMDIV()
/**
* IMSUB
*
* Returns the difference of two complex numbers in x + yi or x + yj text format.
*
* @param string $complexNumber1
* @param string $complexNumber2
* @return real
*/
public static function IMSUB($complexNumber1,$complexNumber2) {
$complexNumber1 = self::flattenSingleValue($complexNumber1);
$complexNumber2 = self::flattenSingleValue($complexNumber2);
$parsedComplex1 = self::_parseComplex($complexNumber1);
if (!is_array($parsedComplex1)) {
return $parsedComplex1;
}
$parsedComplex2 = self::_parseComplex($complexNumber2);
if (!is_array($parsedComplex2)) {
return $parsedComplex2;
}
if ((($parsedComplex1['suffix'] != '') && ($parsedComplex2['suffix'] != '')) &&
($parsedComplex1['suffix'] != $parsedComplex2['suffix'])) {
return self::$_errorCodes['num'];
} elseif (($parsedComplex1['suffix'] == '') && ($parsedComplex2['suffix'] != '')) {
$parsedComplex1['suffix'] = $parsedComplex2['suffix'];
}
$d1 = $parsedComplex1['real'] - $parsedComplex2['real'];
$d2 = $parsedComplex1['imaginary'] - $parsedComplex2['imaginary'];
return self::COMPLEX($d1,$d2,$parsedComplex1['suffix']);
} // function IMSUB()
/**
* IMSUM
*
* Returns the sum of two or more complex numbers in x + yi or x + yj text format.
*
* @param array of mixed Data Series
* @return real
*/
public static function IMSUM() {
// Return value
$returnValue = self::_parseComplex('0');
$activeSuffix = '';
// Loop through the arguments
$aArgs = self::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
$parsedComplex = self::_parseComplex($arg);
if (!is_array($parsedComplex)) {
return $parsedComplex;
}
if ($activeSuffix == '') {
$activeSuffix = $parsedComplex['suffix'];
} elseif (($parsedComplex['suffix'] != '') && ($activeSuffix != $parsedComplex['suffix'])) {
return self::$_errorCodes['value'];
}
$returnValue['real'] += $parsedComplex['real'];
$returnValue['imaginary'] += $parsedComplex['imaginary'];
}
if ($returnValue['imaginary'] == 0.0) { $activeSuffix = ''; }
return self::COMPLEX($returnValue['real'],$returnValue['imaginary'],$activeSuffix);
} // function IMSUM()
/**
* IMPRODUCT
*
* Returns the product of two or more complex numbers in x + yi or x + yj text format.
*
* @param array of mixed Data Series
* @return real
*/
public static function IMPRODUCT() {
// Return value
$returnValue = self::_parseComplex('1');
$activeSuffix = '';
// Loop through the arguments
$aArgs = self::flattenArray(func_get_args());
foreach ($aArgs as $arg) {
$parsedComplex = self::_parseComplex($arg);
if (!is_array($parsedComplex)) {
return $parsedComplex;
}
$workValue = $returnValue;
if (($parsedComplex['suffix'] != '') && ($activeSuffix == '')) {
$activeSuffix = $parsedComplex['suffix'];
} elseif (($parsedComplex['suffix'] != '') && ($activeSuffix != $parsedComplex['suffix'])) {
return self::$_errorCodes['num'];
}
$returnValue['real'] = ($workValue['real'] * $parsedComplex['real']) - ($workValue['imaginary'] * $parsedComplex['imaginary']);
$returnValue['imaginary'] = ($workValue['real'] * $parsedComplex['imaginary']) + ($workValue['imaginary'] * $parsedComplex['real']);
}
if ($returnValue['imaginary'] == 0.0) { $activeSuffix = ''; }
return self::COMPLEX($returnValue['real'],$returnValue['imaginary'],$activeSuffix);
} // function IMPRODUCT()
private static $_conversionUnits = array( 'g' => array( 'Group' => 'Mass', 'Unit Name' => 'Gram', 'AllowPrefix' => True ),
'sg' => array( 'Group' => 'Mass', 'Unit Name' => 'Slug', 'AllowPrefix' => False ),
'lbm' => array( 'Group' => 'Mass', 'Unit Name' => 'Pound mass (avoirdupois)', 'AllowPrefix' => False ),
'u' => array( 'Group' => 'Mass', 'Unit Name' => 'U (atomic mass unit)', 'AllowPrefix' => True ),
'ozm' => array( 'Group' => 'Mass', 'Unit Name' => 'Ounce mass (avoirdupois)', 'AllowPrefix' => False ),
'm' => array( 'Group' => 'Distance', 'Unit Name' => 'Meter', 'AllowPrefix' => True ),
'mi' => array( 'Group' => 'Distance', 'Unit Name' => 'Statute mile', 'AllowPrefix' => False ),
'Nmi' => array( 'Group' => 'Distance', 'Unit Name' => 'Nautical mile', 'AllowPrefix' => False ),
'in' => array( 'Group' => 'Distance', 'Unit Name' => 'Inch', 'AllowPrefix' => False ),
'ft' => array( 'Group' => 'Distance', 'Unit Name' => 'Foot', 'AllowPrefix' => False ),
'yd' => array( 'Group' => 'Distance', 'Unit Name' => 'Yard', 'AllowPrefix' => False ),
'ang' => array( 'Group' => 'Distance', 'Unit Name' => 'Angstrom', 'AllowPrefix' => True ),
'Pica' => array( 'Group' => 'Distance', 'Unit Name' => 'Pica (1/72 in)', 'AllowPrefix' => False ),
'yr' => array( 'Group' => 'Time', 'Unit Name' => 'Year', 'AllowPrefix' => False ),
'day' => array( 'Group' => 'Time', 'Unit Name' => 'Day', 'AllowPrefix' => False ),
'hr' => array( 'Group' => 'Time', 'Unit Name' => 'Hour', 'AllowPrefix' => False ),
'mn' => array( 'Group' => 'Time', 'Unit Name' => 'Minute', 'AllowPrefix' => False ),
'sec' => array( 'Group' => 'Time', 'Unit Name' => 'Second', 'AllowPrefix' => True ),
'Pa' => array( 'Group' => 'Pressure', 'Unit Name' => 'Pascal', 'AllowPrefix' => True ),
'p' => array( 'Group' => 'Pressure', 'Unit Name' => 'Pascal', 'AllowPrefix' => True ),
'atm' => array( 'Group' => 'Pressure', 'Unit Name' => 'Atmosphere', 'AllowPrefix' => True ),
'at' => array( 'Group' => 'Pressure', 'Unit Name' => 'Atmosphere', 'AllowPrefix' => True ),
'mmHg' => array( 'Group' => 'Pressure', 'Unit Name' => 'mm of Mercury', 'AllowPrefix' => True ),
'N' => array( 'Group' => 'Force', 'Unit Name' => 'Newton', 'AllowPrefix' => True ),
'dyn' => array( 'Group' => 'Force', 'Unit Name' => 'Dyne', 'AllowPrefix' => True ),
'dy' => array( 'Group' => 'Force', 'Unit Name' => 'Dyne', 'AllowPrefix' => True ),
'lbf' => array( 'Group' => 'Force', 'Unit Name' => 'Pound force', 'AllowPrefix' => False ),
'J' => array( 'Group' => 'Energy', 'Unit Name' => 'Joule', 'AllowPrefix' => True ),
'e' => array( 'Group' => 'Energy', 'Unit Name' => 'Erg', 'AllowPrefix' => True ),
'c' => array( 'Group' => 'Energy', 'Unit Name' => 'Thermodynamic calorie', 'AllowPrefix' => True ),
'cal' => array( 'Group' => 'Energy', 'Unit Name' => 'IT calorie', 'AllowPrefix' => True ),
'eV' => array( 'Group' => 'Energy', 'Unit Name' => 'Electron volt', 'AllowPrefix' => True ),
'ev' => array( 'Group' => 'Energy', 'Unit Name' => 'Electron volt', 'AllowPrefix' => True ),
'HPh' => array( 'Group' => 'Energy', 'Unit Name' => 'Horsepower-hour', 'AllowPrefix' => False ),
'hh' => array( 'Group' => 'Energy', 'Unit Name' => 'Horsepower-hour', 'AllowPrefix' => False ),
'Wh' => array( 'Group' => 'Energy', 'Unit Name' => 'Watt-hour', 'AllowPrefix' => True ),
'wh' => array( 'Group' => 'Energy', 'Unit Name' => 'Watt-hour', 'AllowPrefix' => True ),
'flb' => array( 'Group' => 'Energy', 'Unit Name' => 'Foot-pound', 'AllowPrefix' => False ),
'BTU' => array( 'Group' => 'Energy', 'Unit Name' => 'BTU', 'AllowPrefix' => False ),
'btu' => array( 'Group' => 'Energy', 'Unit Name' => 'BTU', 'AllowPrefix' => False ),
'HP' => array( 'Group' => 'Power', 'Unit Name' => 'Horsepower', 'AllowPrefix' => False ),
'h' => array( 'Group' => 'Power', 'Unit Name' => 'Horsepower', 'AllowPrefix' => False ),
'W' => array( 'Group' => 'Power', 'Unit Name' => 'Watt', 'AllowPrefix' => True ),
'w' => array( 'Group' => 'Power', 'Unit Name' => 'Watt', 'AllowPrefix' => True ),
'T' => array( 'Group' => 'Magnetism', 'Unit Name' => 'Tesla', 'AllowPrefix' => True ),
'ga' => array( 'Group' => 'Magnetism', 'Unit Name' => 'Gauss', 'AllowPrefix' => True ),
'C' => array( 'Group' => 'Temperature', 'Unit Name' => 'Celsius', 'AllowPrefix' => False ),
'cel' => array( 'Group' => 'Temperature', 'Unit Name' => 'Celsius', 'AllowPrefix' => False ),
'F' => array( 'Group' => 'Temperature', 'Unit Name' => 'Fahrenheit', 'AllowPrefix' => False ),
'fah' => array( 'Group' => 'Temperature', 'Unit Name' => 'Fahrenheit', 'AllowPrefix' => False ),
'K' => array( 'Group' => 'Temperature', 'Unit Name' => 'Kelvin', 'AllowPrefix' => False ),
'kel' => array( 'Group' => 'Temperature', 'Unit Name' => 'Kelvin', 'AllowPrefix' => False ),
'tsp' => array( 'Group' => 'Liquid', 'Unit Name' => 'Teaspoon', 'AllowPrefix' => False ),
'tbs' => array( 'Group' => 'Liquid', 'Unit Name' => 'Tablespoon', 'AllowPrefix' => False ),
'oz' => array( 'Group' => 'Liquid', 'Unit Name' => 'Fluid Ounce', 'AllowPrefix' => False ),
'cup' => array( 'Group' => 'Liquid', 'Unit Name' => 'Cup', 'AllowPrefix' => False ),
'pt' => array( 'Group' => 'Liquid', 'Unit Name' => 'U.S. Pint', 'AllowPrefix' => False ),
'us_pt' => array( 'Group' => 'Liquid', 'Unit Name' => 'U.S. Pint', 'AllowPrefix' => False ),
'uk_pt' => array( 'Group' => 'Liquid', 'Unit Name' => 'U.K. Pint', 'AllowPrefix' => False ),
'qt' => array( 'Group' => 'Liquid', 'Unit Name' => 'Quart', 'AllowPrefix' => False ),
'gal' => array( 'Group' => 'Liquid', 'Unit Name' => 'Gallon', 'AllowPrefix' => False ),
'l' => array( 'Group' => 'Liquid', 'Unit Name' => 'Litre', 'AllowPrefix' => True ),
'lt' => array( 'Group' => 'Liquid', 'Unit Name' => 'Litre', 'AllowPrefix' => True )
);
private static $_conversionMultipliers = array( 'Y' => array( 'multiplier' => 1E24, 'name' => 'yotta' ),
'Z' => array( 'multiplier' => 1E21, 'name' => 'zetta' ),
'E' => array( 'multiplier' => 1E18, 'name' => 'exa' ),
'P' => array( 'multiplier' => 1E15, 'name' => 'peta' ),
'T' => array( 'multiplier' => 1E12, 'name' => 'tera' ),
'G' => array( 'multiplier' => 1E9, 'name' => 'giga' ),
'M' => array( 'multiplier' => 1E6, 'name' => 'mega' ),
'k' => array( 'multiplier' => 1E3, 'name' => 'kilo' ),
'h' => array( 'multiplier' => 1E2, 'name' => 'hecto' ),
'e' => array( 'multiplier' => 1E1, 'name' => 'deka' ),
'd' => array( 'multiplier' => 1E-1, 'name' => 'deci' ),
'c' => array( 'multiplier' => 1E-2, 'name' => 'centi' ),
'm' => array( 'multiplier' => 1E-3, 'name' => 'milli' ),
'u' => array( 'multiplier' => 1E-6, 'name' => 'micro' ),
'n' => array( 'multiplier' => 1E-9, 'name' => 'nano' ),
'p' => array( 'multiplier' => 1E-12, 'name' => 'pico' ),
'f' => array( 'multiplier' => 1E-15, 'name' => 'femto' ),
'a' => array( 'multiplier' => 1E-18, 'name' => 'atto' ),
'z' => array( 'multiplier' => 1E-21, 'name' => 'zepto' ),
'y' => array( 'multiplier' => 1E-24, 'name' => 'yocto' )
);
private static $_unitConversions = array( 'Mass' => array( 'g' => array( 'g' => 1.0,
'sg' => 6.85220500053478E-05,
'lbm' => 2.20462291469134E-03,
'u' => 6.02217000000000E+23,
'ozm' => 3.52739718003627E-02
),
'sg' => array( 'g' => 1.45938424189287E+04,
'sg' => 1.0,
'lbm' => 3.21739194101647E+01,
'u' => 8.78866000000000E+27,
'ozm' => 5.14782785944229E+02
),
'lbm' => array( 'g' => 4.5359230974881148E+02,
'sg' => 3.10810749306493E-02,
'lbm' => 1.0,
'u' => 2.73161000000000E+26,
'ozm' => 1.60000023429410E+01
),
'u' => array( 'g' => 1.66053100460465E-24,
'sg' => 1.13782988532950E-28,
'lbm' => 3.66084470330684E-27,
'u' => 1.0,
'ozm' => 5.85735238300524E-26
),
'ozm' => array( 'g' => 2.83495152079732E+01,
'sg' => 1.94256689870811E-03,
'lbm' => 6.24999908478882E-02,
'u' => 1.70725600000000E+25,
'ozm' => 1.0
)
),
'Distance' => array( 'm' => array( 'm' => 1.0,
'mi' => 6.21371192237334E-04,
'Nmi' => 5.39956803455724E-04,
'in' => 3.93700787401575E+01,
'ft' => 3.28083989501312E+00,
'yd' => 1.09361329797891E+00,
'ang' => 1.00000000000000E+10,
'Pica' => 2.83464566929116E+03
),
'mi' => array( 'm' => 1.60934400000000E+03,
'mi' => 1.0,
'Nmi' => 8.68976241900648E-01,
'in' => 6.33600000000000E+04,
'ft' => 5.28000000000000E+03,
'yd' => 1.76000000000000E+03,
'ang' => 1.60934400000000E+13,
'Pica' => 4.56191999999971E+06
),
'Nmi' => array( 'm' => 1.85200000000000E+03,
'mi' => 1.15077944802354E+00,
'Nmi' => 1.0,
'in' => 7.29133858267717E+04,
'ft' => 6.07611548556430E+03,
'yd' => 2.02537182785694E+03,
'ang' => 1.85200000000000E+13,
'Pica' => 5.24976377952723E+06
),
'in' => array( 'm' => 2.54000000000000E-02,
'mi' => 1.57828282828283E-05,
'Nmi' => 1.37149028077754E-05,
'in' => 1.0,
'ft' => 8.33333333333333E-02,
'yd' => 2.77777777686643E-02,
'ang' => 2.54000000000000E+08,
'Pica' => 7.19999999999955E+01
),
'ft' => array( 'm' => 3.04800000000000E-01,
'mi' => 1.89393939393939E-04,
'Nmi' => 1.64578833693305E-04,
'in' => 1.20000000000000E+01,
'ft' => 1.0,
'yd' => 3.33333333223972E-01,
'ang' => 3.04800000000000E+09,
'Pica' => 8.63999999999946E+02
),
'yd' => array( 'm' => 9.14400000300000E-01,
'mi' => 5.68181818368230E-04,
'Nmi' => 4.93736501241901E-04,
'in' => 3.60000000118110E+01,
'ft' => 3.00000000000000E+00,
'yd' => 1.0,
'ang' => 9.14400000300000E+09,
'Pica' => 2.59200000085023E+03
),
'ang' => array( 'm' => 1.00000000000000E-10,
'mi' => 6.21371192237334E-14,
'Nmi' => 5.39956803455724E-14,
'in' => 3.93700787401575E-09,
'ft' => 3.28083989501312E-10,
'yd' => 1.09361329797891E-10,
'ang' => 1.0,
'Pica' => 2.83464566929116E-07
),
'Pica' => array( 'm' => 3.52777777777800E-04,
'mi' => 2.19205948372629E-07,
'Nmi' => 1.90484761219114E-07,
'in' => 1.38888888888898E-02,
'ft' => 1.15740740740748E-03,
'yd' => 3.85802469009251E-04,
'ang' => 3.52777777777800E+06,
'Pica' => 1.0
)
),
'Time' => array( 'yr' => array( 'yr' => 1.0,
'day' => 365.25,
'hr' => 8766.0,
'mn' => 525960.0,
'sec' => 31557600.0
),
'day' => array( 'yr' => 2.73785078713210E-03,
'day' => 1.0,
'hr' => 24.0,
'mn' => 1440.0,
'sec' => 86400.0
),
'hr' => array( 'yr' => 1.14077116130504E-04,
'day' => 4.16666666666667E-02,
'hr' => 1.0,
'mn' => 60.0,
'sec' => 3600.0
),
'mn' => array( 'yr' => 1.90128526884174E-06,
'day' => 6.94444444444444E-04,
'hr' => 1.66666666666667E-02,
'mn' => 1.0,
'sec' => 60.0
),
'sec' => array( 'yr' => 3.16880878140289E-08,
'day' => 1.15740740740741E-05,
'hr' => 2.77777777777778E-04,
'mn' => 1.66666666666667E-02,
'sec' => 1.0
)
),
'Pressure' => array( 'Pa' => array( 'Pa' => 1.0,
'p' => 1.0,
'atm' => 9.86923299998193E-06,
'at' => 9.86923299998193E-06,
'mmHg' => 7.50061707998627E-03
),
'p' => array( 'Pa' => 1.0,
'p' => 1.0,
'atm' => 9.86923299998193E-06,
'at' => 9.86923299998193E-06,
'mmHg' => 7.50061707998627E-03
),
'atm' => array( 'Pa' => 1.01324996583000E+05,
'p' => 1.01324996583000E+05,
'atm' => 1.0,
'at' => 1.0,
'mmHg' => 760.0
),
'at' => array( 'Pa' => 1.01324996583000E+05,
'p' => 1.01324996583000E+05,
'atm' => 1.0,
'at' => 1.0,
'mmHg' => 760.0
),
'mmHg' => array( 'Pa' => 1.33322363925000E+02,
'p' => 1.33322363925000E+02,
'atm' => 1.31578947368421E-03,
'at' => 1.31578947368421E-03,
'mmHg' => 1.0
)
),
'Force' => array( 'N' => array( 'N' => 1.0,
'dyn' => 1.0E+5,
'dy' => 1.0E+5,
'lbf' => 2.24808923655339E-01
),
'dyn' => array( 'N' => 1.0E-5,
'dyn' => 1.0,
'dy' => 1.0,
'lbf' => 2.24808923655339E-06
),
'dy' => array( 'N' => 1.0E-5,
'dyn' => 1.0,
'dy' => 1.0,
'lbf' => 2.24808923655339E-06
),
'lbf' => array( 'N' => 4.448222,
'dyn' => 4.448222E+5,
'dy' => 4.448222E+5,
'lbf' => 1.0
)
),
'Energy' => array( 'J' => array( 'J' => 1.0,
'e' => 9.99999519343231E+06,
'c' => 2.39006249473467E-01,
'cal' => 2.38846190642017E-01,
'eV' => 6.24145700000000E+18,
'ev' => 6.24145700000000E+18,
'HPh' => 3.72506430801000E-07,
'hh' => 3.72506430801000E-07,
'Wh' => 2.77777916238711E-04,
'wh' => 2.77777916238711E-04,
'flb' => 2.37304222192651E+01,
'BTU' => 9.47815067349015E-04,
'btu' => 9.47815067349015E-04
),
'e' => array( 'J' => 1.00000048065700E-07,
'e' => 1.0,
'c' => 2.39006364353494E-08,
'cal' => 2.38846305445111E-08,
'eV' => 6.24146000000000E+11,
'ev' => 6.24146000000000E+11,
'HPh' => 3.72506609848824E-14,
'hh' => 3.72506609848824E-14,
'Wh' => 2.77778049754611E-11,
'wh' => 2.77778049754611E-11,
'flb' => 2.37304336254586E-06,
'BTU' => 9.47815522922962E-11,
'btu' => 9.47815522922962E-11
),
'c' => array( 'J' => 4.18399101363672E+00,
'e' => 4.18398900257312E+07,
'c' => 1.0,
'cal' => 9.99330315287563E-01,
'eV' => 2.61142000000000E+19,
'ev' => 2.61142000000000E+19,
'HPh' => 1.55856355899327E-06,
'hh' => 1.55856355899327E-06,
'Wh' => 1.16222030532950E-03,
'wh' => 1.16222030532950E-03,
'flb' => 9.92878733152102E+01,
'BTU' => 3.96564972437776E-03,
'btu' => 3.96564972437776E-03
),
'cal' => array( 'J' => 4.18679484613929E+00,
'e' => 4.18679283372801E+07,
'c' => 1.00067013349059E+00,
'cal' => 1.0,
'eV' => 2.61317000000000E+19,
'ev' => 2.61317000000000E+19,
'HPh' => 1.55960800463137E-06,
'hh' => 1.55960800463137E-06,
'Wh' => 1.16299914807955E-03,
'wh' => 1.16299914807955E-03,
'flb' => 9.93544094443283E+01,
'BTU' => 3.96830723907002E-03,
'btu' => 3.96830723907002E-03
),
'eV' => array( 'J' => 1.60219000146921E-19,
'e' => 1.60218923136574E-12,
'c' => 3.82933423195043E-20,
'cal' => 3.82676978535648E-20,
'eV' => 1.0,
'ev' => 1.0,
'HPh' => 5.96826078912344E-26,
'hh' => 5.96826078912344E-26,
'Wh' => 4.45053000026614E-23,
'wh' => 4.45053000026614E-23,
'flb' => 3.80206452103492E-18,
'BTU' => 1.51857982414846E-22,
'btu' => 1.51857982414846E-22
),
'ev' => array( 'J' => 1.60219000146921E-19,
'e' => 1.60218923136574E-12,
'c' => 3.82933423195043E-20,
'cal' => 3.82676978535648E-20,
'eV' => 1.0,
'ev' => 1.0,
'HPh' => 5.96826078912344E-26,
'hh' => 5.96826078912344E-26,
'Wh' => 4.45053000026614E-23,
'wh' => 4.45053000026614E-23,
'flb' => 3.80206452103492E-18,
'BTU' => 1.51857982414846E-22,
'btu' => 1.51857982414846E-22
),
'HPh' => array( 'J' => 2.68451741316170E+06,
'e' => 2.68451612283024E+13,
'c' => 6.41616438565991E+05,
'cal' => 6.41186757845835E+05,
'eV' => 1.67553000000000E+25,
'ev' => 1.67553000000000E+25,
'HPh' => 1.0,
'hh' => 1.0,
'Wh' => 7.45699653134593E+02,
'wh' => 7.45699653134593E+02,
'flb' => 6.37047316692964E+07,
'BTU' => 2.54442605275546E+03,
'btu' => 2.54442605275546E+03
),
'hh' => array( 'J' => 2.68451741316170E+06,
'e' => 2.68451612283024E+13,
'c' => 6.41616438565991E+05,
'cal' => 6.41186757845835E+05,
'eV' => 1.67553000000000E+25,
'ev' => 1.67553000000000E+25,
'HPh' => 1.0,
'hh' => 1.0,
'Wh' => 7.45699653134593E+02,
'wh' => 7.45699653134593E+02,
'flb' => 6.37047316692964E+07,
'BTU' => 2.54442605275546E+03,
'btu' => 2.54442605275546E+03
),
'Wh' => array( 'J' => 3.59999820554720E+03,
'e' => 3.59999647518369E+10,
'c' => 8.60422069219046E+02,
'cal' => 8.59845857713046E+02,
'eV' => 2.24692340000000E+22,
'ev' => 2.24692340000000E+22,
'HPh' => 1.34102248243839E-03,
'hh' => 1.34102248243839E-03,
'Wh' => 1.0,
'wh' => 1.0,
'flb' => 8.54294774062316E+04,
'BTU' => 3.41213254164705E+00,
'btu' => 3.41213254164705E+00
),
'wh' => array( 'J' => 3.59999820554720E+03,
'e' => 3.59999647518369E+10,
'c' => 8.60422069219046E+02,
'cal' => 8.59845857713046E+02,
'eV' => 2.24692340000000E+22,
'ev' => 2.24692340000000E+22,
'HPh' => 1.34102248243839E-03,
'hh' => 1.34102248243839E-03,
'Wh' => 1.0,
'wh' => 1.0,
'flb' => 8.54294774062316E+04,
'BTU' => 3.41213254164705E+00,
'btu' => 3.41213254164705E+00
),
'flb' => array( 'J' => 4.21400003236424E-02,
'e' => 4.21399800687660E+05,
'c' => 1.00717234301644E-02,
'cal' => 1.00649785509554E-02,
'eV' => 2.63015000000000E+17,
'ev' => 2.63015000000000E+17,
'HPh' => 1.56974211145130E-08,
'hh' => 1.56974211145130E-08,
'Wh' => 1.17055614802000E-05,
'wh' => 1.17055614802000E-05,
'flb' => 1.0,
'BTU' => 3.99409272448406E-05,
'btu' => 3.99409272448406E-05
),
'BTU' => array( 'J' => 1.05505813786749E+03,
'e' => 1.05505763074665E+10,
'c' => 2.52165488508168E+02,
'cal' => 2.51996617135510E+02,
'eV' => 6.58510000000000E+21,
'ev' => 6.58510000000000E+21,
'HPh' => 3.93015941224568E-04,
'hh' => 3.93015941224568E-04,
'Wh' => 2.93071851047526E-01,
'wh' => 2.93071851047526E-01,
'flb' => 2.50369750774671E+04,
'BTU' => 1.0,
'btu' => 1.0,
),
'btu' => array( 'J' => 1.05505813786749E+03,
'e' => 1.05505763074665E+10,
'c' => 2.52165488508168E+02,
'cal' => 2.51996617135510E+02,
'eV' => 6.58510000000000E+21,
'ev' => 6.58510000000000E+21,
'HPh' => 3.93015941224568E-04,
'hh' => 3.93015941224568E-04,
'Wh' => 2.93071851047526E-01,
'wh' => 2.93071851047526E-01,
'flb' => 2.50369750774671E+04,
'BTU' => 1.0,
'btu' => 1.0,
)
),
'Power' => array( 'HP' => array( 'HP' => 1.0,
'h' => 1.0,
'W' => 7.45701000000000E+02,
'w' => 7.45701000000000E+02
),
'h' => array( 'HP' => 1.0,
'h' => 1.0,
'W' => 7.45701000000000E+02,
'w' => 7.45701000000000E+02
),
'W' => array( 'HP' => 1.34102006031908E-03,
'h' => 1.34102006031908E-03,
'W' => 1.0,
'w' => 1.0
),
'w' => array( 'HP' => 1.34102006031908E-03,
'h' => 1.34102006031908E-03,
'W' => 1.0,
'w' => 1.0
)
),
'Magnetism' => array( 'T' => array( 'T' => 1.0,
'ga' => 10000.0
),
'ga' => array( 'T' => 0.0001,
'ga' => 1.0
)
),
'Liquid' => array( 'tsp' => array( 'tsp' => 1.0,
'tbs' => 3.33333333333333E-01,
'oz' => 1.66666666666667E-01,
'cup' => 2.08333333333333E-02,
'pt' => 1.04166666666667E-02,
'us_pt' => 1.04166666666667E-02,
'uk_pt' => 8.67558516821960E-03,
'qt' => 5.20833333333333E-03,
'gal' => 1.30208333333333E-03,
'l' => 4.92999408400710E-03,
'lt' => 4.92999408400710E-03
),
'tbs' => array( 'tsp' => 3.00000000000000E+00,
'tbs' => 1.0,
'oz' => 5.00000000000000E-01,
'cup' => 6.25000000000000E-02,
'pt' => 3.12500000000000E-02,
'us_pt' => 3.12500000000000E-02,
'uk_pt' => 2.60267555046588E-02,
'qt' => 1.56250000000000E-02,
'gal' => 3.90625000000000E-03,
'l' => 1.47899822520213E-02,
'lt' => 1.47899822520213E-02
),
'oz' => array( 'tsp' => 6.00000000000000E+00,
'tbs' => 2.00000000000000E+00,
'oz' => 1.0,
'cup' => 1.25000000000000E-01,
'pt' => 6.25000000000000E-02,
'us_pt' => 6.25000000000000E-02,
'uk_pt' => 5.20535110093176E-02,
'qt' => 3.12500000000000E-02,
'gal' => 7.81250000000000E-03,
'l' => 2.95799645040426E-02,
'lt' => 2.95799645040426E-02
),
'cup' => array( 'tsp' => 4.80000000000000E+01,
'tbs' => 1.60000000000000E+01,
'oz' => 8.00000000000000E+00,
'cup' => 1.0,
'pt' => 5.00000000000000E-01,
'us_pt' => 5.00000000000000E-01,
'uk_pt' => 4.16428088074541E-01,
'qt' => 2.50000000000000E-01,
'gal' => 6.25000000000000E-02,
'l' => 2.36639716032341E-01,
'lt' => 2.36639716032341E-01
),
'pt' => array( 'tsp' => 9.60000000000000E+01,
'tbs' => 3.20000000000000E+01,
'oz' => 1.60000000000000E+01,
'cup' => 2.00000000000000E+00,
'pt' => 1.0,
'us_pt' => 1.0,
'uk_pt' => 8.32856176149081E-01,
'qt' => 5.00000000000000E-01,
'gal' => 1.25000000000000E-01,
'l' => 4.73279432064682E-01,
'lt' => 4.73279432064682E-01
),
'us_pt' => array( 'tsp' => 9.60000000000000E+01,
'tbs' => 3.20000000000000E+01,
'oz' => 1.60000000000000E+01,
'cup' => 2.00000000000000E+00,
'pt' => 1.0,
'us_pt' => 1.0,
'uk_pt' => 8.32856176149081E-01,
'qt' => 5.00000000000000E-01,
'gal' => 1.25000000000000E-01,
'l' => 4.73279432064682E-01,
'lt' => 4.73279432064682E-01
),
'uk_pt' => array( 'tsp' => 1.15266000000000E+02,
'tbs' => 3.84220000000000E+01,
'oz' => 1.92110000000000E+01,
'cup' => 2.40137500000000E+00,
'pt' => 1.20068750000000E+00,
'us_pt' => 1.20068750000000E+00,
'uk_pt' => 1.0,
'qt' => 6.00343750000000E-01,
'gal' => 1.50085937500000E-01,
'l' => 5.68260698087162E-01,
'lt' => 5.68260698087162E-01
),
'qt' => array( 'tsp' => 1.92000000000000E+02,
'tbs' => 6.40000000000000E+01,
'oz' => 3.20000000000000E+01,
'cup' => 4.00000000000000E+00,
'pt' => 2.00000000000000E+00,
'us_pt' => 2.00000000000000E+00,
'uk_pt' => 1.66571235229816E+00,
'qt' => 1.0,
'gal' => 2.50000000000000E-01,
'l' => 9.46558864129363E-01,
'lt' => 9.46558864129363E-01
),
'gal' => array( 'tsp' => 7.68000000000000E+02,
'tbs' => 2.56000000000000E+02,
'oz' => 1.28000000000000E+02,
'cup' => 1.60000000000000E+01,
'pt' => 8.00000000000000E+00,
'us_pt' => 8.00000000000000E+00,
'uk_pt' => 6.66284940919265E+00,
'qt' => 4.00000000000000E+00,
'gal' => 1.0,
'l' => 3.78623545651745E+00,
'lt' => 3.78623545651745E+00
),
'l' => array( 'tsp' => 2.02840000000000E+02,
'tbs' => 6.76133333333333E+01,
'oz' => 3.38066666666667E+01,
'cup' => 4.22583333333333E+00,
'pt' => 2.11291666666667E+00,
'us_pt' => 2.11291666666667E+00,
'uk_pt' => 1.75975569552166E+00,
'qt' => 1.05645833333333E+00,
'gal' => 2.64114583333333E-01,
'l' => 1.0,
'lt' => 1.0
),
'lt' => array( 'tsp' => 2.02840000000000E+02,
'tbs' => 6.76133333333333E+01,
'oz' => 3.38066666666667E+01,
'cup' => 4.22583333333333E+00,
'pt' => 2.11291666666667E+00,
'us_pt' => 2.11291666666667E+00,
'uk_pt' => 1.75975569552166E+00,
'qt' => 1.05645833333333E+00,
'gal' => 2.64114583333333E-01,
'l' => 1.0,
'lt' => 1.0
)
)
);
/**
* getConversionGroups
*
* @return array
*/
public static function getConversionGroups() {
$conversionGroups = array();
foreach(self::$_conversionUnits as $conversionUnit) {
$conversionGroups[] = $conversionUnit['Group'];
}
return array_merge(array_unique($conversionGroups));
} // function getConversionGroups()
/**
* getConversionGroupUnits
*
* @return array
*/
public static function getConversionGroupUnits($group = NULL) {
$conversionGroups = array();
foreach(self::$_conversionUnits as $conversionUnit => $conversionGroup) {
if ((is_null($group)) || ($conversionGroup['Group'] == $group)) {
$conversionGroups[$conversionGroup['Group']][] = $conversionUnit;
}
}
return $conversionGroups;
} // function getConversionGroupUnits()
/**
* getConversionGroupUnitDetails
*
* @return array
*/
public static function getConversionGroupUnitDetails($group = NULL) {
$conversionGroups = array();
foreach(self::$_conversionUnits as $conversionUnit => $conversionGroup) {
if ((is_null($group)) || ($conversionGroup['Group'] == $group)) {
$conversionGroups[$conversionGroup['Group']][] = array( 'unit' => $conversionUnit,
'description' => $conversionGroup['Unit Name']
);
}
}
return $conversionGroups;
} // function getConversionGroupUnitDetails()
/**
* getConversionGroups
*
* @return array
*/
public static function getConversionMultipliers() {
return self::$_conversionMultipliers;
} // function getConversionGroups()
/**
* CONVERTUOM
*
* @param float $value
* @param string $fromUOM
* @param string $toUOM
* @return float
*/
public static function CONVERTUOM($value, $fromUOM, $toUOM) {
$value = self::flattenSingleValue($value);
$fromUOM = self::flattenSingleValue($fromUOM);
$toUOM = self::flattenSingleValue($toUOM);
if (!is_numeric($value)) {
return self::$_errorCodes['value'];
}
$fromMultiplier = 1;
if (isset(self::$_conversionUnits[$fromUOM])) {
$unitGroup1 = self::$_conversionUnits[$fromUOM]['Group'];
} else {
$fromMultiplier = substr($fromUOM,0,1);
$fromUOM = substr($fromUOM,1);
if (isset(self::$_conversionMultipliers[$fromMultiplier])) {
$fromMultiplier = self::$_conversionMultipliers[$fromMultiplier]['multiplier'];
} else {
return self::$_errorCodes['na'];
}
if ((isset(self::$_conversionUnits[$fromUOM])) && (self::$_conversionUnits[$fromUOM]['AllowPrefix'])) {
$unitGroup1 = self::$_conversionUnits[$fromUOM]['Group'];
} else {
return self::$_errorCodes['na'];
}
}
$value *= $fromMultiplier;
$toMultiplier = 1;
if (isset(self::$_conversionUnits[$toUOM])) {
$unitGroup2 = self::$_conversionUnits[$toUOM]['Group'];
} else {
$toMultiplier = substr($toUOM,0,1);
$toUOM = substr($toUOM,1);
if (isset(self::$_conversionMultipliers[$toMultiplier])) {
$toMultiplier = self::$_conversionMultipliers[$toMultiplier]['multiplier'];
} else {
return self::$_errorCodes['na'];
}
if ((isset(self::$_conversionUnits[$toUOM])) && (self::$_conversionUnits[$toUOM]['AllowPrefix'])) {
$unitGroup2 = self::$_conversionUnits[$toUOM]['Group'];
} else {
return self::$_errorCodes['na'];
}
}
if ($unitGroup1 != $unitGroup2) {
return self::$_errorCodes['na'];
}
if ($fromUOM == $toUOM) {
return 1.0;
} elseif ($unitGroup1 == 'Temperature') {
if (($fromUOM == 'F') || ($fromUOM == 'fah')) {
if (($toUOM == 'F') || ($toUOM == 'fah')) {
return 1.0;
} else {
$value = (($value - 32) / 1.8);
if (($toUOM == 'K') || ($toUOM == 'kel')) {
$value += 273.15;
}
return $value;
}
} elseif ((($fromUOM == 'K') || ($fromUOM == 'kel')) &&
(($toUOM == 'K') || ($toUOM == 'kel'))) {
return 1.0;
} elseif ((($fromUOM == 'C') || ($fromUOM == 'cel')) &&
(($toUOM == 'C') || ($toUOM == 'cel'))) {
return 1.0;
}
if (($toUOM == 'F') || ($toUOM == 'fah')) {
if (($fromUOM == 'K') || ($fromUOM == 'kel')) {
$value -= 273.15;
}
return ($value * 1.8) + 32;
}
if (($toUOM == 'C') || ($toUOM == 'cel')) {
return $value - 273.15;
}
return $value + 273.15;
}
return ($value * self::$_unitConversions[$unitGroup1][$fromUOM][$toUOM]) / $toMultiplier;
} // function CONVERTUOM()
/**
* BESSELI
*
* Returns the modified Bessel function, which is equivalent to the Bessel function evaluated for purely imaginary arguments
*
* @param float $x
* @param float $n
* @return int
*/
public static function BESSELI($x, $n) {
$x = self::flattenSingleValue($x);
$n = floor(self::flattenSingleValue($n));
if ((is_numeric($x)) && (is_numeric($n))) {
if ($n < 0) {
return self::$_errorCodes['num'];
}
$f_2_PI = 2 * pi();
if (abs($x) <= 30) {
$fTerm = pow($x / 2, $n) / self::FACT($n);
$nK = 1;
$fResult = $fTerm;
$fSqrX = ($x * $x) / 4;
do {
$fTerm *= $fSqrX;
$fTerm /= ($nK * ($nK + $n));
$fResult += $fTerm;
} while ((abs($fTerm) > 1e-10) && (++$nK < 100));
} else {
$fXAbs = abs($x);
$fResult = exp($fXAbs) / sqrt($f_2_PI * $fXAbs);
if (($n && 1) && ($x < 0)) {
$fResult = -$fResult;
}
}
return $fResult;
}
return self::$_errorCodes['value'];
} // function BESSELI()
/**
* BESSELJ
*
* Returns the Bessel function
*
* @param float $x
* @param float $n
* @return int
*/
public static function BESSELJ($x, $n) {
$x = self::flattenSingleValue($x);
$n = floor(self::flattenSingleValue($n));
if ((is_numeric($x)) && (is_numeric($n))) {
if ($n < 0) {
return self::$_errorCodes['num'];
}
$f_PI_DIV_2 = M_PI / 2;
$f_PI_DIV_4 = M_PI / 4;
$fResult = 0;
if (abs($x) <= 30) {
$fTerm = pow($x / 2, $n) / self::FACT($n);
$nK = 1;
$fResult = $fTerm;
$fSqrX = ($x * $x) / -4;
do {
$fTerm *= $fSqrX;
$fTerm /= ($nK * ($nK + $n));
$fResult += $fTerm;
} while ((abs($fTerm) > 1e-10) && (++$nK < 100));
} else {
$fXAbs = abs($x);
$fResult = sqrt(M_2DIVPI / $fXAbs) * cos($fXAbs - $n * $f_PI_DIV_2 - $f_PI_DIV_4);
if (($n && 1) && ($x < 0)) {
$fResult = -$fResult;
}
}
return $fResult;
}
return self::$_errorCodes['value'];
} // function BESSELJ()
private static function _Besselk0($fNum) {
if ($fNum <= 2) {
$fNum2 = $fNum * 0.5;
$y = ($fNum2 * $fNum2);
$fRet = -log($fNum2) * self::BESSELI($fNum, 0) +
(-0.57721566 + $y * (0.42278420 + $y * (0.23069756 + $y * (0.3488590e-1 + $y * (0.262698e-2 + $y *
(0.10750e-3 + $y * 0.74e-5))))));
} else {
$y = 2 / $fNum;
$fRet = exp(-$fNum) / sqrt($fNum) *
(1.25331414 + $y * (-0.7832358e-1 + $y * (0.2189568e-1 + $y * (-0.1062446e-1 + $y *
(0.587872e-2 + $y * (-0.251540e-2 + $y * 0.53208e-3))))));
}
return $fRet;
} // function _Besselk0()
private static function _Besselk1($fNum) {
if ($fNum <= 2) {
$fNum2 = $fNum * 0.5;
$y = ($fNum2 * $fNum2);
$fRet = log($fNum2) * self::BESSELI($fNum, 1) +
(1 + $y * (0.15443144 + $y * (-0.67278579 + $y * (-0.18156897 + $y * (-0.1919402e-1 + $y *
(-0.110404e-2 + $y * (-0.4686e-4))))))) / $fNum;
} else {
$y = 2 / $fNum;
$fRet = exp(-$fNum) / sqrt($fNum) *
(1.25331414 + $y * (0.23498619 + $y * (-0.3655620e-1 + $y * (0.1504268e-1 + $y * (-0.780353e-2 + $y *
(0.325614e-2 + $y * (-0.68245e-3)))))));
}
return $fRet;
} // function _Besselk1()
/**
* BESSELK
*
* Returns the modified Bessel function, which is equivalent to the Bessel functions evaluated for purely imaginary arguments.
*
* @param float $x
* @param float $ord
* @return float
*/
public static function BESSELK($x, $ord) {
$x = self::flattenSingleValue($x);
$ord = floor(self::flattenSingleValue($ord));
if ((is_numeric($x)) && (is_numeric($ord))) {
if ($ord < 0) {
return self::$_errorCodes['num'];
}
switch($ord) {
case 0 : return self::_Besselk0($x);
break;
case 1 : return self::_Besselk1($x);
break;
default : $fTox = 2 / $x;
$fBkm = self::_Besselk0($x);
$fBk = self::_Besselk1($x);
for ($n = 1; $n < $ord; ++$n) {
$fBkp = $fBkm + $n * $fTox * $fBk;
$fBkm = $fBk;
$fBk = $fBkp;
}
}
return $fBk;
}
return self::$_errorCodes['value'];
} // function BESSELK()
private static function _Bessely0($fNum) {
if ($fNum < 8.0) {
$y = ($fNum * $fNum);
$f1 = -2957821389.0 + $y * (7062834065.0 + $y * (-512359803.6 + $y * (10879881.29 + $y * (-86327.92757 + $y * 228.4622733))));
$f2 = 40076544269.0 + $y * (745249964.8 + $y * (7189466.438 + $y * (47447.26470 + $y * (226.1030244 + $y))));
$fRet = $f1 / $f2 + M_2DIVPI * self::BESSELJ($fNum, 0) * log($fNum);
} else {
$z = 8.0 / $fNum;
$y = ($z * $z);
$xx = $fNum - 0.785398164;
$f1 = 1 + $y * (-0.1098628627e-2 + $y * (0.2734510407e-4 + $y * (-0.2073370639e-5 + $y * 0.2093887211e-6)));
$f2 = -0.1562499995e-1 + $y * (0.1430488765e-3 + $y * (-0.6911147651e-5 + $y * (0.7621095161e-6 + $y * (-0.934945152e-7))));
$fRet = sqrt(M_2DIVPI / $fNum) * (sin($xx) * $f1 + $z * cos($xx) * $f2);
}
return $fRet;
} // function _Bessely0()
private static function _Bessely1($fNum) {
if ($fNum < 8.0) {
$y = ($fNum * $fNum);
$f1 = $fNum * (-0.4900604943e13 + $y * (0.1275274390e13 + $y * (-0.5153438139e11 + $y * (0.7349264551e9 + $y *
(-0.4237922726e7 + $y * 0.8511937935e4)))));
$f2 = 0.2499580570e14 + $y * (0.4244419664e12 + $y * (0.3733650367e10 + $y * (0.2245904002e8 + $y *
(0.1020426050e6 + $y * (0.3549632885e3 + $y)))));
$fRet = $f1 / $f2 + M_2DIVPI * ( self::BESSELJ($fNum, 1) * log($fNum) - 1 / $fNum);
} else {
$z = 8.0 / $fNum;
$y = ($z * $z);
$xx = $fNum - 2.356194491;
$f1 = 1 + $y * (0.183105e-2 + $y * (-0.3516396496e-4 + $y * (0.2457520174e-5 + $y * (-0.240337019e6))));
$f2 = 0.04687499995 + $y * (-0.2002690873e-3 + $y * (0.8449199096e-5 + $y * (-0.88228987e-6 + $y * 0.105787412e-6)));
$fRet = sqrt(M_2DIVPI / $fNum) * (sin($xx) * $f1 + $z * cos($xx) * $f2);
#i12430# ...but this seems to work much better.
// $fRet = sqrt(M_2DIVPI / $fNum) * sin($fNum - 2.356194491);
}
return $fRet;
} // function _Bessely1()
/**
* BESSELY
*
* Returns the Bessel function, which is also called the Weber function or the Neumann function.
*
* @param float $x
* @param float $n
* @return int
*/
public static function BESSELY($x, $ord) {
$x = self::flattenSingleValue($x);
$ord = floor(self::flattenSingleValue($ord));
if ((is_numeric($x)) && (is_numeric($ord))) {
if ($ord < 0) {
return self::$_errorCodes['num'];
}
switch($ord) {
case 0 : return self::_Bessely0($x);
break;
case 1 : return self::_Bessely1($x);
break;
default: $fTox = 2 / $x;
$fBym = self::_Bessely0($x);
$fBy = self::_Bessely1($x);
for ($n = 1; $n < $ord; ++$n) {
$fByp = $n * $fTox * $fBy - $fBym;
$fBym = $fBy;
$fBy = $fByp;
}
}
return $fBy;
}
return self::$_errorCodes['value'];
} // function BESSELY()
/**
* DELTA
*
* Tests whether two values are equal. Returns 1 if number1 = number2; returns 0 otherwise.
*
* @param float $a
* @param float $b
* @return int
*/
public static function DELTA($a, $b=0) {
$a = self::flattenSingleValue($a);
$b = self::flattenSingleValue($b);
return (int) ($a == $b);
} // function DELTA()
/**
* GESTEP
*
* Returns 1 if number = step; returns 0 (zero) otherwise
*
* @param float $number
* @param float $step
* @return int
*/
public static function GESTEP($number, $step=0) {
$number = self::flattenSingleValue($number);
$step = self::flattenSingleValue($step);
return (int) ($number >= $step);
} // function GESTEP()
//
// Private method to calculate the erf value
//
private static $_two_sqrtpi = 1.128379167095512574;
private static function _erfVal($x) {
if (abs($x) > 2.2) {
return 1 - self::_erfcVal($x);
}
$sum = $term = $x;
$xsqr = ($x * $x);
$j = 1;
do {
$term *= $xsqr / $j;
$sum -= $term / (2 * $j + 1);
++$j;
$term *= $xsqr / $j;
$sum += $term / (2 * $j + 1);
++$j;
if ($sum == 0.0) {
break;
}
} while (abs($term / $sum) > PRECISION);
return self::$_two_sqrtpi * $sum;
} // function _erfVal()
/**
* ERF
*
* Returns the error function integrated between lower_limit and upper_limit
*
* @param float $lower lower bound for integrating ERF
* @param float $upper upper bound for integrating ERF.
* If omitted, ERF integrates between zero and lower_limit
* @return int
*/
public static function ERF($lower, $upper = null) {
$lower = self::flattenSingleValue($lower);
$upper = self::flattenSingleValue($upper);
if (is_numeric($lower)) {
if ($lower < 0) {
return self::$_errorCodes['num'];
}
if (is_null($upper)) {
return self::_erfVal($lower);
}
if (is_numeric($upper)) {
if ($upper < 0) {
return self::$_errorCodes['num'];
}
return self::_erfVal($upper) - self::_erfVal($lower);
}
}
return self::$_errorCodes['value'];
} // function ERF()
//
// Private method to calculate the erfc value
//
private static $_one_sqrtpi = 0.564189583547756287;
private static function _erfcVal($x) {
if (abs($x) < 2.2) {
return 1 - self::_erfVal($x);
}
if ($x < 0) {
return 2 - self::erfc(-$x);
}
$a = $n = 1;
$b = $c = $x;
$d = ($x * $x) + 0.5;
$q1 = $q2 = $b / $d;
$t = 0;
do {
$t = $a * $n + $b * $x;
$a = $b;
$b = $t;
$t = $c * $n + $d * $x;
$c = $d;
$d = $t;
$n += 0.5;
$q1 = $q2;
$q2 = $b / $d;
} while ((abs($q1 - $q2) / $q2) > PRECISION);
return self::$_one_sqrtpi * exp(-$x * $x) * $q2;
} // function _erfcVal()
/**
* ERFC
*
* Returns the complementary ERF function integrated between x and infinity
*
* @param float $x The lower bound for integrating ERF
* @return int
*/
public static function ERFC($x) {
$x = self::flattenSingleValue($x);
if (is_numeric($x)) {
if ($x < 0) {
return self::$_errorCodes['num'];
}
return self::_erfcVal($x);
}
return self::$_errorCodes['value'];
} // function ERFC()
/**
* LOWERCASE
*
* Converts a string value to upper case.
*
* @param string $mixedCaseString
* @return string
*/
public static function LOWERCASE($mixedCaseString) {
$mixedCaseString = self::flattenSingleValue($mixedCaseString);
if (is_bool($mixedCaseString)) {
$mixedCaseString = ($mixedCaseString) ? 'TRUE' : 'FALSE';
}
if (function_exists('mb_convert_case')) {
return mb_convert_case($mixedCaseString, MB_CASE_LOWER, 'UTF-8');
} else {
return strtoupper($mixedCaseString);
}
} // function LOWERCASE()
/**
* UPPERCASE
*
* Converts a string value to upper case.
*
* @param string $mixedCaseString
* @return string
*/
public static function UPPERCASE($mixedCaseString) {
$mixedCaseString = self::flattenSingleValue($mixedCaseString);
if (is_bool($mixedCaseString)) {
$mixedCaseString = ($mixedCaseString) ? 'TRUE' : 'FALSE';
}
if (function_exists('mb_convert_case')) {
return mb_convert_case($mixedCaseString, MB_CASE_UPPER, 'UTF-8');
} else {
return strtoupper($mixedCaseString);
}
} // function UPPERCASE()
/**
* PROPERCASE
*
* Converts a string value to upper case.
*
* @param string $mixedCaseString
* @return string
*/
public static function PROPERCASE($mixedCaseString) {
$mixedCaseString = self::flattenSingleValue($mixedCaseString);
if (is_bool($mixedCaseString)) {
$mixedCaseString = ($mixedCaseString) ? 'TRUE' : 'FALSE';
}
if (function_exists('mb_convert_case')) {
return mb_convert_case($mixedCaseString, MB_CASE_TITLE, 'UTF-8');
} else {
return ucwords($mixedCaseString);
}
} // function PROPERCASE()
/**
* DOLLAR
*
* This function converts a number to text using currency format, with the decimals rounded to the specified place.
* The format used is $#,##0.00_);($#,##0.00)..
*
* @param float $value The value to format
* @param int $decimals The number of digits to display to the right of the decimal point.
* If decimals is negative, number is rounded to the left of the decimal point.
* If you omit decimals, it is assumed to be 2
* @return string
*/
public static function DOLLAR($value = 0, $decimals = 2) {
$value = self::flattenSingleValue($value);
$decimals = is_null($decimals) ? 0 : self::flattenSingleValue($decimals);
// Validate parameters
if (!is_numeric($value) || !is_numeric($decimals)) {
return self::$_errorCodes['num'];
}
$decimals = floor($decimals);
if ($decimals > 0) {
return money_format('%.'.$decimals.'n',$value);
} else {
$round = pow(10,abs($decimals));
if ($value < 0) { $round = 0-$round; }
$value = self::MROUND($value,$round);
// The implementation of money_format used if the standard PHP function is not available can't handle decimal places of 0,
// so we display to 1 dp and chop off that character and the decimal separator using substr
return substr(money_format('%.1n',$value),0,-2);
}
} // function DOLLAR()
/**
* DOLLARDE
*
* Converts a dollar price expressed as an integer part and a fraction part into a dollar price expressed as a decimal number.
* Fractional dollar numbers are sometimes used for security prices.
*
* @param float $fractional_dollar Fractional Dollar
* @param int $fraction Fraction
* @return float
*/
public static function DOLLARDE($fractional_dollar = Null, $fraction = 0) {
$fractional_dollar = self::flattenSingleValue($fractional_dollar);
$fraction = (int)self::flattenSingleValue($fraction);
// Validate parameters
if (is_null($fractional_dollar) || $fraction < 0) {
return self::$_errorCodes['num'];
}
if ($fraction == 0) {
return self::$_errorCodes['divisionbyzero'];
}
$dollars = floor($fractional_dollar);
$cents = fmod($fractional_dollar,1);
$cents /= $fraction;
$cents *= pow(10,ceil(log10($fraction)));
return $dollars + $cents;
} // function DOLLARDE()
/**
* DOLLARFR
*
* Converts a dollar price expressed as a decimal number into a dollar price expressed as a fraction.
* Fractional dollar numbers are sometimes used for security prices.
*
* @param float $decimal_dollar Decimal Dollar
* @param int $fraction Fraction
* @return float
*/
public static function DOLLARFR($decimal_dollar = Null, $fraction = 0) {
$decimal_dollar = self::flattenSingleValue($decimal_dollar);
$fraction = (int)self::flattenSingleValue($fraction);
// Validate parameters
if (is_null($decimal_dollar) || $fraction < 0) {
return self::$_errorCodes['num'];
}
if ($fraction == 0) {
return self::$_errorCodes['divisionbyzero'];
}
$dollars = floor($decimal_dollar);
$cents = fmod($decimal_dollar,1);
$cents *= $fraction;
$cents *= pow(10,-ceil(log10($fraction)));
return $dollars + $cents;
} // function DOLLARFR()
/**
* EFFECT
*
* Returns the effective interest rate given the nominal rate and the number of compounding payments per year.
*
* @param float $nominal_rate Nominal interest rate
* @param int $npery Number of compounding payments per year
* @return float
*/
public static function EFFECT($nominal_rate = 0, $npery = 0) {
$nominal_rate = self::flattenSingleValue($nominal_rate);
$npery = (int)self::flattenSingleValue($npery);
// Validate parameters
if ($nominal_rate <= 0 || $npery < 1) {
return self::$_errorCodes['num'];
}
return pow((1 + $nominal_rate / $npery), $npery) - 1;
} // function EFFECT()
/**
* NOMINAL
*
* Returns the nominal interest rate given the effective rate and the number of compounding payments per year.
*
* @param float $effect_rate Effective interest rate
* @param int $npery Number of compounding payments per year
* @return float
*/
public static function NOMINAL($effect_rate = 0, $npery = 0) {
$effect_rate = self::flattenSingleValue($effect_rate);
$npery = (int)self::flattenSingleValue($npery);
// Validate parameters
if ($effect_rate <= 0 || $npery < 1) {
return self::$_errorCodes['num'];
}
// Calculate
return $npery * (pow($effect_rate + 1, 1 / $npery) - 1);
} // function NOMINAL()
/**
* PV
*
* Returns the Present Value of a cash flow with constant payments and interest rate (annuities).
*
* @param float $rate Interest rate per period
* @param int $nper Number of periods
* @param float $pmt Periodic payment (annuity)
* @param float $fv Future Value
* @param int $type Payment type: 0 = at the end of each period, 1 = at the beginning of each period
* @return float
*/
public static function PV($rate = 0, $nper = 0, $pmt = 0, $fv = 0, $type = 0) {
$rate = self::flattenSingleValue($rate);
$nper = self::flattenSingleValue($nper);
$pmt = self::flattenSingleValue($pmt);
$fv = self::flattenSingleValue($fv);
$type = self::flattenSingleValue($type);
// Validate parameters
if ($type != 0 && $type != 1) {
return self::$_errorCodes['num'];
}
// Calculate
if (!is_null($rate) && $rate != 0) {
return (-$pmt * (1 + $rate * $type) * ((pow(1 + $rate, $nper) - 1) / $rate) - $fv) / pow(1 + $rate, $nper);
} else {
return -$fv - $pmt * $nper;
}
} // function PV()
/**
* FV
*
* Returns the Future Value of a cash flow with constant payments and interest rate (annuities).
*
* @param float $rate Interest rate per period
* @param int $nper Number of periods
* @param float $pmt Periodic payment (annuity)
* @param float $pv Present Value
* @param int $type Payment type: 0 = at the end of each period, 1 = at the beginning of each period
* @return float
*/
public static function FV($rate = 0, $nper = 0, $pmt = 0, $pv = 0, $type = 0) {
$rate = self::flattenSingleValue($rate);
$nper = self::flattenSingleValue($nper);
$pmt = self::flattenSingleValue($pmt);
$pv = self::flattenSingleValue($pv);
$type = self::flattenSingleValue($type);
// Validate parameters
if ($type != 0 && $type != 1) {
return self::$_errorCodes['num'];
}
// Calculate
if (!is_null($rate) && $rate != 0) {
return -$pv * pow(1 + $rate, $nper) - $pmt * (1 + $rate * $type) * (pow(1 + $rate, $nper) - 1) / $rate;
} else {
return -$pv - $pmt * $nper;
}
} // function FV()
/**
* FVSCHEDULE
*
*/
public static function FVSCHEDULE($principal, $schedule) {
$principal = self::flattenSingleValue($principal);
$schedule = self::flattenArray($schedule);
foreach($schedule as $n) {
$principal *= 1 + $n;
}
return $principal;
} // function FVSCHEDULE()
/**
* PMT
*
* Returns the constant payment (annuity) for a cash flow with a constant interest rate.
*
* @param float $rate Interest rate per period
* @param int $nper Number of periods
* @param float $pv Present Value
* @param float $fv Future Value
* @param int $type Payment type: 0 = at the end of each period, 1 = at the beginning of each period
* @return float
*/
public static function PMT($rate = 0, $nper = 0, $pv = 0, $fv = 0, $type = 0) {
$rate = self::flattenSingleValue($rate);
$nper = self::flattenSingleValue($nper);
$pv = self::flattenSingleValue($pv);
$fv = self::flattenSingleValue($fv);
$type = self::flattenSingleValue($type);
// Validate parameters
if ($type != 0 && $type != 1) {
return self::$_errorCodes['num'];
}
// Calculate
if (!is_null($rate) && $rate != 0) {
return (-$fv - $pv * pow(1 + $rate, $nper)) / (1 + $rate * $type) / ((pow(1 + $rate, $nper) - 1) / $rate);
} else {
return (-$pv - $fv) / $nper;
}
} // function PMT()
/**
* NPER
*
* Returns the number of periods for a cash flow with constant periodic payments (annuities), and interest rate.
*
* @param float $rate Interest rate per period
* @param int $pmt Periodic payment (annuity)
* @param float $pv Present Value
* @param float $fv Future Value
* @param int $type Payment type: 0 = at the end of each period, 1 = at the beginning of each period
* @return float
*/
public static function NPER($rate = 0, $pmt = 0, $pv = 0, $fv = 0, $type = 0) {
$rate = self::flattenSingleValue($rate);
$pmt = self::flattenSingleValue($pmt);
$pv = self::flattenSingleValue($pv);
$fv = self::flattenSingleValue($fv);
$type = self::flattenSingleValue($type);
// Validate parameters
if ($type != 0 && $type != 1) {
return self::$_errorCodes['num'];
}
// Calculate
if (!is_null($rate) && $rate != 0) {
if ($pmt == 0 && $pv == 0) {
return self::$_errorCodes['num'];
}
return log(($pmt * (1 + $rate * $type) / $rate - $fv) / ($pv + $pmt * (1 + $rate * $type) / $rate)) / log(1 + $rate);
} else {
if ($pmt == 0) {
return self::$_errorCodes['num'];
}
return (-$pv -$fv) / $pmt;
}
} // function NPER()
private static function _interestAndPrincipal($rate=0, $per=0, $nper=0, $pv=0, $fv=0, $type=0) {
$pmt = self::PMT($rate, $nper, $pv, $fv, $type);
$capital = $pv;
for ($i = 1; $i<= $per; ++$i) {
$interest = ($type && $i == 1)? 0 : -$capital * $rate;
$principal = $pmt - $interest;
$capital += $principal;
}
return array($interest, $principal);
} // function _interestAndPrincipal()
/**
* IPMT
*
* Returns the interest payment for a given period for an investment based on periodic, constant payments and a constant interest rate.
*
* @param float $rate Interest rate per period
* @param int $per Period for which we want to find the interest
* @param int $nper Number of periods
* @param float $pv Present Value
* @param float $fv Future Value
* @param int $type Payment type: 0 = at the end of each period, 1 = at the beginning of each period
* @return float
*/
public static function IPMT($rate, $per, $nper, $pv, $fv = 0, $type = 0) {
$rate = self::flattenSingleValue($rate);
$per = (int) self::flattenSingleValue($per);
$nper = (int) self::flattenSingleValue($nper);
$pv = self::flattenSingleValue($pv);
$fv = self::flattenSingleValue($fv);
$type = (int) self::flattenSingleValue($type);
// Validate parameters
if ($type != 0 && $type != 1) {
return self::$_errorCodes['num'];
}
if ($per <= 0 || $per > $nper) {
return self::$_errorCodes['value'];
}
// Calculate
$interestAndPrincipal = self::_interestAndPrincipal($rate, $per, $nper, $pv, $fv, $type);
return $interestAndPrincipal[0];
} // function IPMT()
/**
* CUMIPMT
*
* Returns the cumulative interest paid on a loan between start_period and end_period.
*
* @param float $rate Interest rate per period
* @param int $nper Number of periods
* @param float $pv Present Value
* @param int start The first period in the calculation.
* Payment periods are numbered beginning with 1.
* @param int end The last period in the calculation.
* @param int $type Payment type: 0 = at the end of each period, 1 = at the beginning of each period
* @return float
*/
public static function CUMIPMT($rate, $nper, $pv, $start, $end, $type = 0) {
$rate = self::flattenSingleValue($rate);
$nper = (int) self::flattenSingleValue($nper);
$pv = self::flattenSingleValue($pv);
$start = (int) self::flattenSingleValue($start);
$end = (int) self::flattenSingleValue($end);
$type = (int) self::flattenSingleValue($type);
// Validate parameters
if ($type != 0 && $type != 1) {
return self::$_errorCodes['num'];
}
if ($start < 1 || $start > $end) {
return self::$_errorCodes['value'];
}
// Calculate
$interest = 0;
for ($per = $start; $per <= $end; ++$per) {
$interest += self::IPMT($rate, $per, $nper, $pv, 0, $type);
}
return $interest;
} // function CUMIPMT()
/**
* PPMT
*
* Returns the interest payment for a given period for an investment based on periodic, constant payments and a constant interest rate.
*
* @param float $rate Interest rate per period
* @param int $per Period for which we want to find the interest
* @param int $nper Number of periods
* @param float $pv Present Value
* @param float $fv Future Value
* @param int $type Payment type: 0 = at the end of each period, 1 = at the beginning of each period
* @return float
*/
public static function PPMT($rate, $per, $nper, $pv, $fv = 0, $type = 0) {
$rate = self::flattenSingleValue($rate);
$per = (int) self::flattenSingleValue($per);
$nper = (int) self::flattenSingleValue($nper);
$pv = self::flattenSingleValue($pv);
$fv = self::flattenSingleValue($fv);
$type = (int) self::flattenSingleValue($type);
// Validate parameters
if ($type != 0 && $type != 1) {
return self::$_errorCodes['num'];
}
if ($per <= 0 || $per > $nper) {
return self::$_errorCodes['value'];
}
// Calculate
$interestAndPrincipal = self::_interestAndPrincipal($rate, $per, $nper, $pv, $fv, $type);
return $interestAndPrincipal[1];
} // function PPMT()
/**
* CUMPRINC
*
* Returns the cumulative principal paid on a loan between start_period and end_period.
*
* @param float $rate Interest rate per period
* @param int $nper Number of periods
* @param float $pv Present Value
* @param int start The first period in the calculation.
* Payment periods are numbered beginning with 1.
* @param int end The last period in the calculation.
* @param int $type Payment type: 0 = at the end of each period, 1 = at the beginning of each period
* @return float
*/
public static function CUMPRINC($rate, $nper, $pv, $start, $end, $type = 0) {
$rate = self::flattenSingleValue($rate);
$nper = (int) self::flattenSingleValue($nper);
$pv = self::flattenSingleValue($pv);
$start = (int) self::flattenSingleValue($start);
$end = (int) self::flattenSingleValue($end);
$type = (int) self::flattenSingleValue($type);
// Validate parameters
if ($type != 0 && $type != 1) {
return self::$_errorCodes['num'];
}
if ($start < 1 || $start > $end) {
return self::$_errorCodes['value'];
}
// Calculate
$principal = 0;
for ($per = $start; $per <= $end; ++$per) {
$principal += self::PPMT($rate, $per, $nper, $pv, 0, $type);
}
return $principal;
} // function CUMPRINC()
/**
* ISPMT
*
* Returns the interest payment for an investment based on an interest rate and a constant payment schedule.
*
* Excel Function:
* =ISPMT(interest_rate, period, number_payments, PV)
*
* interest_rate is the interest rate for the investment
*
* period is the period to calculate the interest rate. It must be betweeen 1 and number_payments.
*
* number_payments is the number of payments for the annuity
*
* PV is the loan amount or present value of the payments
*/
public static function ISPMT() {
// Return value
$returnValue = 0;
// Get the parameters
$aArgs = self::flattenArray(func_get_args());
$interestRate = array_shift($aArgs);
$period = array_shift($aArgs);
$numberPeriods = array_shift($aArgs);
$principleRemaining = array_shift($aArgs);
// Calculate
$principlePayment = ($principleRemaining * 1.0) / ($numberPeriods * 1.0);
for($i=0; $i <= $period; ++$i) {
$returnValue = $interestRate * $principleRemaining * -1;
$principleRemaining -= $principlePayment;
// principle needs to be 0 after the last payment, don't let floating point screw it up
if($i == $numberPeriods) {
$returnValue = 0;
}
}
return($returnValue);
} // function ISPMT()
/**
* NPV
*
* Returns the Net Present Value of a cash flow series given a discount rate.
*
* @param float Discount interest rate
* @param array Cash flow series
* @return float
*/
public static function NPV() {
// Return value
$returnValue = 0;
// Loop through arguments
$aArgs = self::flattenArray(func_get_args());
// Calculate
$rate = array_shift($aArgs);
for ($i = 1; $i <= count($aArgs); ++$i) {
// Is it a numeric value?
if (is_numeric($aArgs[$i - 1])) {
$returnValue += $aArgs[$i - 1] / pow(1 + $rate, $i);
}
}
// Return
return $returnValue;
} // function NPV()
/**
* XNPV
*
* Returns the net present value for a schedule of cash flows that is not necessarily periodic.
* To calculate the net present value for a series of cash flows that is periodic, use the NPV function.
*
* @param float Discount interest rate
* @param array Cash flow series
* @return float
*/
public static function XNPV($rate, $values, $dates) {
if ((!is_array($values)) || (!is_array($dates))) return self::$_errorCodes['value'];
$values = self::flattenArray($values);
$dates = self::flattenArray($dates);
$valCount = count($values);
if ($valCount != count($dates)) return self::$_errorCodes['num'];
$xnpv = 0.0;
for ($i = 0; $i < $valCount; ++$i) {
$xnpv += $values[$i] / pow(1 + $rate, self::DATEDIF($dates[0],$dates[$i],'d') / 365);
}
return (is_finite($xnpv) ? $xnpv : self::$_errorCodes['value']);
} // function XNPV()
public static function IRR($values, $guess = 0.1) {
if (!is_array($values)) return self::$_errorCodes['value'];
$values = self::flattenArray($values);
$guess = self::flattenSingleValue($guess);
// create an initial range, with a root somewhere between 0 and guess
$x1 = 0.0;
$x2 = $guess;
$f1 = self::NPV($x1, $values);
$f2 = self::NPV($x2, $values);
for ($i = 0; $i < FINANCIAL_MAX_ITERATIONS; ++$i) {
if (($f1 * $f2) < 0.0) break;
if (abs($f1) < abs($f2)) {
$f1 = self::NPV($x1 += 1.6 * ($x1 - $x2), $values);
} else {
$f2 = self::NPV($x2 += 1.6 * ($x2 - $x1), $values);
}
}
if (($f1 * $f2) > 0.0) return self::$_errorCodes['value'];
$f = self::NPV($x1, $values);
if ($f < 0.0) {
$rtb = $x1;
$dx = $x2 - $x1;
} else {
$rtb = $x2;
$dx = $x1 - $x2;
}
for ($i = 0; $i < FINANCIAL_MAX_ITERATIONS; ++$i) {
$dx *= 0.5;
$x_mid = $rtb + $dx;
$f_mid = self::NPV($x_mid, $values);
if ($f_mid <= 0.0) $rtb = $x_mid;
if ((abs($f_mid) < FINANCIAL_PRECISION) || (abs($dx) < FINANCIAL_PRECISION)) return $x_mid;
}
return self::$_errorCodes['value'];
} // function IRR()
public static function MIRR($values, $finance_rate, $reinvestment_rate) {
if (!is_array($values)) return self::$_errorCodes['value'];
$values = self::flattenArray($values);
$finance_rate = self::flattenSingleValue($finance_rate);
$reinvestment_rate = self::flattenSingleValue($reinvestment_rate);
$n = count($values);
$rr = 1.0 + $reinvestment_rate;
$fr = 1.0 + $finance_rate;
$npv_pos = $npv_neg = 0.0;
foreach($values as $i => $v) {
if ($v >= 0) {
$npv_pos += $v / pow($rr, $i);
} else {
$npv_neg += $v / pow($fr, $i);
}
}
if (($npv_neg == 0) || ($npv_pos == 0) || ($reinvestment_rate <= -1)) {
return self::$_errorCodes['value'];
}
$mirr = pow((-$npv_pos * pow($rr, $n))
/ ($npv_neg * ($rr)), (1.0 / ($n - 1))) - 1.0;
return (is_finite($mirr) ? $mirr : self::$_errorCodes['value']);
} // function MIRR()
public static function XIRR($values, $dates, $guess = 0.1) {
if ((!is_array($values)) && (!is_array($dates))) return self::$_errorCodes['value'];
$values = self::flattenArray($values);
$dates = self::flattenArray($dates);
$guess = self::flattenSingleValue($guess);
if (count($values) != count($dates)) return self::$_errorCodes['num'];
// create an initial range, with a root somewhere between 0 and guess
$x1 = 0.0;
$x2 = $guess;
$f1 = self::XNPV($x1, $values, $dates);
$f2 = self::XNPV($x2, $values, $dates);
for ($i = 0; $i < FINANCIAL_MAX_ITERATIONS; ++$i) {
if (($f1 * $f2) < 0.0) break;
if (abs($f1) < abs($f2)) {
$f1 = self::XNPV($x1 += 1.6 * ($x1 - $x2), $values, $dates);
} else {
$f2 = self::XNPV($x2 += 1.6 * ($x2 - $x1), $values, $dates);
}
}
if (($f1 * $f2) > 0.0) return self::$_errorCodes['value'];
$f = self::XNPV($x1, $values, $dates);
if ($f < 0.0) {
$rtb = $x1;
$dx = $x2 - $x1;
} else {
$rtb = $x2;
$dx = $x1 - $x2;
}
for ($i = 0; $i < FINANCIAL_MAX_ITERATIONS; ++$i) {
$dx *= 0.5;
$x_mid = $rtb + $dx;
$f_mid = self::XNPV($x_mid, $values, $dates);
if ($f_mid <= 0.0) $rtb = $x_mid;
if ((abs($f_mid) < FINANCIAL_PRECISION) || (abs($dx) < FINANCIAL_PRECISION)) return $x_mid;
}
return self::$_errorCodes['value'];
}
/**
* RATE
*
**/
public static function RATE($nper, $pmt, $pv, $fv = 0.0, $type = 0, $guess = 0.1) {
$nper = (int) self::flattenSingleValue($nper);
$pmt = self::flattenSingleValue($pmt);
$pv = self::flattenSingleValue($pv);
$fv = (is_null($fv)) ? 0.0 : self::flattenSingleValue($fv);
$type = (is_null($type)) ? 0 : (int) self::flattenSingleValue($type);
$guess = (is_null($guess)) ? 0.1 : self::flattenSingleValue($guess);
$rate = $guess;
if (abs($rate) < FINANCIAL_PRECISION) {
$y = $pv * (1 + $nper * $rate) + $pmt * (1 + $rate * $type) * $nper + $fv;
} else {
$f = exp($nper * log(1 + $rate));
$y = $pv * $f + $pmt * (1 / $rate + $type) * ($f - 1) + $fv;
}
$y0 = $pv + $pmt * $nper + $fv;
$y1 = $pv * $f + $pmt * (1 / $rate + $type) * ($f - 1) + $fv;
// find root by secant method
$i = $x0 = 0.0;
$x1 = $rate;
while ((abs($y0 - $y1) > FINANCIAL_PRECISION) && ($i < FINANCIAL_MAX_ITERATIONS)) {
$rate = ($y1 * $x0 - $y0 * $x1) / ($y1 - $y0);
$x0 = $x1;
$x1 = $rate;
if (abs($rate) < FINANCIAL_PRECISION) {
$y = $pv * (1 + $nper * $rate) + $pmt * (1 + $rate * $type) * $nper + $fv;
} else {
$f = exp($nper * log(1 + $rate));
$y = $pv * $f + $pmt * (1 / $rate + $type) * ($f - 1) + $fv;
}
$y0 = $y1;
$y1 = $y;
++$i;
}
return $rate;
} // function RATE()
/**
* DB
*
* Returns the depreciation of an asset for a specified period using the fixed-declining balance method.
* This form of depreciation is used if you want to get a higher depreciation value at the beginning of the depreciation
* (as opposed to linear depreciation). The depreciation value is reduced with every depreciation period by the
* depreciation already deducted from the initial cost.
*
* @param float cost Initial cost of the asset.
* @param float salvage Value at the end of the depreciation. (Sometimes called the salvage value of the asset)
* @param int life Number of periods over which the asset is depreciated. (Sometimes called the useful life of the asset)
* @param int period The period for which you want to calculate the depreciation. Period must use the same units as life.
* @param float month Number of months in the first year. If month is omitted, it defaults to 12.
* @return float
*/
public static function DB($cost, $salvage, $life, $period, $month=12) {
$cost = (float) self::flattenSingleValue($cost);
$salvage = (float) self::flattenSingleValue($salvage);
$life = (int) self::flattenSingleValue($life);
$period = (int) self::flattenSingleValue($period);
$month = (int) self::flattenSingleValue($month);
// Validate
if ((is_numeric($cost)) && (is_numeric($salvage)) && (is_numeric($life)) && (is_numeric($period)) && (is_numeric($month))) {
if ($cost == 0) {
return 0.0;
} elseif (($cost < 0) || (($salvage / $cost) < 0) || ($life <= 0) || ($period < 1) || ($month < 1)) {
return self::$_errorCodes['num'];
}
// Set Fixed Depreciation Rate
$fixedDepreciationRate = 1 - pow(($salvage / $cost), (1 / $life));
$fixedDepreciationRate = round($fixedDepreciationRate, 3);
// Loop through each period calculating the depreciation
$previousDepreciation = 0;
for ($per = 1; $per <= $period; ++$per) {
if ($per == 1) {
$depreciation = $cost * $fixedDepreciationRate * $month / 12;
} elseif ($per == ($life + 1)) {
$depreciation = ($cost - $previousDepreciation) * $fixedDepreciationRate * (12 - $month) / 12;
} else {
$depreciation = ($cost - $previousDepreciation) * $fixedDepreciationRate;
}
$previousDepreciation += $depreciation;
}
if (self::$compatibilityMode == self::COMPATIBILITY_GNUMERIC) {
$depreciation = round($depreciation,2);
}
return $depreciation;
}
return self::$_errorCodes['value'];
} // function DB()
/**
* DDB
*
* Returns the depreciation of an asset for a specified period using the double-declining balance method or some other method you specify.
*
* @param float cost Initial cost of the asset.
* @param float salvage Value at the end of the depreciation. (Sometimes called the salvage value of the asset)
* @param int life Number of periods over which the asset is depreciated. (Sometimes called the useful life of the asset)
* @param int period The period for which you want to calculate the depreciation. Period must use the same units as life.
* @param float factor The rate at which the balance declines.
* If factor is omitted, it is assumed to be 2 (the double-declining balance method).
* @return float
*/
public static function DDB($cost, $salvage, $life, $period, $factor=2.0) {
$cost = (float) self::flattenSingleValue($cost);
$salvage = (float) self::flattenSingleValue($salvage);
$life = (int) self::flattenSingleValue($life);
$period = (int) self::flattenSingleValue($period);
$factor = (float) self::flattenSingleValue($factor);
// Validate
if ((is_numeric($cost)) && (is_numeric($salvage)) && (is_numeric($life)) && (is_numeric($period)) && (is_numeric($factor))) {
if (($cost <= 0) || (($salvage / $cost) < 0) || ($life <= 0) || ($period < 1) || ($factor <= 0.0) || ($period > $life)) {
return self::$_errorCodes['num'];
}
// Set Fixed Depreciation Rate
$fixedDepreciationRate = 1 - pow(($salvage / $cost), (1 / $life));
$fixedDepreciationRate = round($fixedDepreciationRate, 3);
// Loop through each period calculating the depreciation
$previousDepreciation = 0;
for ($per = 1; $per <= $period; ++$per) {
$depreciation = min( ($cost - $previousDepreciation) * ($factor / $life), ($cost - $salvage - $previousDepreciation) );
$previousDepreciation += $depreciation;
}
if (self::$compatibilityMode == self::COMPATIBILITY_GNUMERIC) {
$depreciation = round($depreciation,2);
}
return $depreciation;
}
return self::$_errorCodes['value'];
} // function DDB()
private static function _daysPerYear($year,$basis) {
switch ($basis) {
case 0 :
case 2 :
case 4 :
$daysPerYear = 360;
break;
case 3 :
$daysPerYear = 365;
break;
case 1 :
if (self::_isLeapYear(self::YEAR($year))) {
$daysPerYear = 366;
} else {
$daysPerYear = 365;
}
break;
default :
return self::$_errorCodes['num'];
}
return $daysPerYear;
} // function _daysPerYear()
/**
* ACCRINT
*
* Returns the discount rate for a security.
*
* @param mixed issue The security's issue date.
* @param mixed firstinter The security's first interest date.
* @param mixed settlement The security's settlement date.
* @param float rate The security's annual coupon rate.
* @param float par The security's par value.
* @param int basis The type of day count to use.
* 0 or omitted US (NASD) 30/360
* 1 Actual/actual
* 2 Actual/360
* 3 Actual/365
* 4 European 30/360
* @return float
*/
public static function ACCRINT($issue, $firstinter, $settlement, $rate, $par=1000, $frequency=1, $basis=0) {
$issue = self::flattenSingleValue($issue);
$firstinter = self::flattenSingleValue($firstinter);
$settlement = self::flattenSingleValue($settlement);
$rate = (float) self::flattenSingleValue($rate);
$par = (is_null($par)) ? 1000 : (float) self::flattenSingleValue($par);
$frequency = (is_null($frequency)) ? 1 : (int) self::flattenSingleValue($frequency);
$basis = (is_null($basis)) ? 0 : (int) self::flattenSingleValue($basis);
// Validate
if ((is_numeric($rate)) && (is_numeric($par))) {
if (($rate <= 0) || ($par <= 0)) {
return self::$_errorCodes['num'];
}
$daysBetweenIssueAndSettlement = self::YEARFRAC($issue, $settlement, $basis);
if (!is_numeric($daysBetweenIssueAndSettlement)) {
return $daysBetweenIssueAndSettlement;
}
$daysPerYear = self::_daysPerYear(self::YEAR($issue),$basis);
if (!is_numeric($daysPerYear)) {
return $daysPerYear;
}
$daysBetweenIssueAndSettlement *= $daysPerYear;
return $par * $rate * ($daysBetweenIssueAndSettlement / $daysPerYear);
}
return self::$_errorCodes['value'];
} // function ACCRINT()
/**
* ACCRINTM
*
* Returns the discount rate for a security.
*
* @param mixed issue The security's issue date.
* @param mixed settlement The security's settlement date.
* @param float rate The security's annual coupon rate.
* @param float par The security's par value.
* @param int basis The type of day count to use.
* 0 or omitted US (NASD) 30/360
* 1 Actual/actual
* 2 Actual/360
* 3 Actual/365
* 4 European 30/360
* @return float
*/
public static function ACCRINTM($issue, $settlement, $rate, $par=1000, $basis=0) {
$issue = self::flattenSingleValue($issue);
$settlement = self::flattenSingleValue($settlement);
$rate = (float) self::flattenSingleValue($rate);
$par = (is_null($par)) ? 1000 : (float) self::flattenSingleValue($par);
$basis = (is_null($basis)) ? 0 : (int) self::flattenSingleValue($basis);
// Validate
if ((is_numeric($rate)) && (is_numeric($par))) {
if (($rate <= 0) || ($par <= 0)) {
return self::$_errorCodes['num'];
}
$daysBetweenIssueAndSettlement = self::YEARFRAC($issue, $settlement, $basis);
if (!is_numeric($daysBetweenIssueAndSettlement)) {
return $daysBetweenIssueAndSettlement;
}
$daysPerYear = self::_daysPerYear(self::YEAR($issue),$basis);
if (!is_numeric($daysPerYear)) {
return $daysPerYear;
}
$daysBetweenIssueAndSettlement *= $daysPerYear;
return $par * $rate * ($daysBetweenIssueAndSettlement / $daysPerYear);
}
return self::$_errorCodes['value'];
} // function ACCRINTM()
public static function AMORDEGRC($cost, $purchased, $firstPeriod, $salvage, $period, $rate, $basis=0) {
$cost = self::flattenSingleValue($cost);
$purchased = self::flattenSingleValue($purchased);
$firstPeriod = self::flattenSingleValue($firstPeriod);
$salvage = self::flattenSingleValue($salvage);
$period = floor(self::flattenSingleValue($period));
$rate = self::flattenSingleValue($rate);
$basis = floor(self::flattenSingleValue($basis));
$fUsePer = 1.0 / $rate;
if ($fUsePer < 3.0) {
$amortiseCoeff = 1.0;
} elseif ($fUsePer < 5.0) {
$amortiseCoeff = 1.5;
} elseif ($fUsePer <= 6.0) {
$amortiseCoeff = 2.0;
} else {
$amortiseCoeff = 2.5;
}
$rate *= $amortiseCoeff;
$fNRate = floor((self::YEARFRAC($purchased, $firstPeriod, $basis) * $rate * $cost) + 0.5);
$cost -= $fNRate;
$fRest = $cost - $salvage;
for ($n = 0; $n < $period; ++$n) {
$fNRate = floor(($rate * $cost) + 0.5);
$fRest -= $fNRate;
if ($fRest < 0.0) {
switch ($period - $n) {
case 0 :
case 1 : return floor(($cost * 0.5) + 0.5);
break;
default : return 0.0;
break;
}
}
$cost -= $fNRate;
}
return $fNRate;
} // function AMORDEGRC()
public static function AMORLINC($cost, $purchased, $firstPeriod, $salvage, $period, $rate, $basis=0) {
$cost = self::flattenSingleValue($cost);
$purchased = self::flattenSingleValue($purchased);
$firstPeriod = self::flattenSingleValue($firstPeriod);
$salvage = self::flattenSingleValue($salvage);
$period = self::flattenSingleValue($period);
$rate = self::flattenSingleValue($rate);
$basis = self::flattenSingleValue($basis);
$fOneRate = $cost * $rate;
$fCostDelta = $cost - $salvage;
$f0Rate = self::YEARFRAC($purchased, $firstPeriod, $basis) * $rate * $cost;
$nNumOfFullPeriods = intval(($cost - $salvage - $f0Rate) / $fOneRate);
if ($period == 0) {
return $f0Rate;
} elseif ($period <= $nNumOfFullPeriods) {
return $fOneRate;
} elseif ($period == ($nNumOfFullPeriods + 1)) {
return ($fCostDelta - $fOneRate * $nNumOfFullPeriods - $f0Rate);
} else {
return 0.0;
}
} // function AMORLINC()
public static function COUPNUM($settlement, $maturity, $frequency, $basis=0) {
$settlement = self::flattenSingleValue($settlement);
$maturity = self::flattenSingleValue($maturity);
$frequency = self::flattenSingleValue($frequency);
$basis = self::flattenSingleValue($basis);
$daysBetweenSettlementAndMaturity = self::YEARFRAC($settlement, $maturity, $basis) * 365;
switch ($frequency) {
case 1: // annual payments
return ceil($daysBetweenSettlementAndMaturity / 360);
case 2: // half-yearly
return ceil($daysBetweenSettlementAndMaturity / 180);
case 4: // quarterly
return ceil($daysBetweenSettlementAndMaturity / 90);
}
return self::$_errorCodes['value'];
} // function COUPNUM()
public static function COUPDAYBS($settlement, $maturity, $frequency, $basis=0) {
$settlement = self::flattenSingleValue($settlement);
$maturity = self::flattenSingleValue($maturity);
$frequency = self::flattenSingleValue($frequency);
$basis = self::flattenSingleValue($basis);
$daysBetweenSettlementAndMaturity = self::YEARFRAC($settlement, $maturity, $basis) * 365;
switch ($frequency) {
case 1: // annual payments
return 365 - ($daysBetweenSettlementAndMaturity % 360);
case 2: // half-yearly
return 365 - ($daysBetweenSettlementAndMaturity % 360);
case 4: // quarterly
return self::DATEDIF($maturity, $settlement);
}
return self::$_errorCodes['value'];
} // function COUPDAYBS()
/**
* DISC
*
* Returns the discount rate for a security.
*
* @param mixed settlement The security's settlement date.
* The security settlement date is the date after the issue date when the security is traded to the buyer.
* @param mixed maturity The security's maturity date.
* The maturity date is the date when the security expires.
* @param int price The security's price per $100 face value.
* @param int redemption the security's redemption value per $100 face value.
* @param int basis The type of day count to use.
* 0 or omitted US (NASD) 30/360
* 1 Actual/actual
* 2 Actual/360
* 3 Actual/365
* 4 European 30/360
* @return float
*/
public static function DISC($settlement, $maturity, $price, $redemption, $basis=0) {
$settlement = self::flattenSingleValue($settlement);
$maturity = self::flattenSingleValue($maturity);
$price = (float) self::flattenSingleValue($price);
$redemption = (float) self::flattenSingleValue($redemption);
$basis = (int) self::flattenSingleValue($basis);
// Validate
if ((is_numeric($price)) && (is_numeric($redemption)) && (is_numeric($basis))) {
if (($price <= 0) || ($redemption <= 0)) {
return self::$_errorCodes['num'];
}
$daysBetweenSettlementAndMaturity = self::YEARFRAC($settlement, $maturity, $basis);
if (!is_numeric($daysBetweenSettlementAndMaturity)) {
return $daysBetweenSettlementAndMaturity;
}
return ((1 - $price / $redemption) / $daysBetweenSettlementAndMaturity);
}
return self::$_errorCodes['value'];
} // function DISC()
/**
* PRICEDISC
*
* Returns the price per $100 face value of a discounted security.
*
* @param mixed settlement The security's settlement date.
* The security settlement date is the date after the issue date when the security is traded to the buyer.
* @param mixed maturity The security's maturity date.
* The maturity date is the date when the security expires.
* @param int discount The security's discount rate.
* @param int redemption The security's redemption value per $100 face value.
* @param int basis The type of day count to use.
* 0 or omitted US (NASD) 30/360
* 1 Actual/actual
* 2 Actual/360
* 3 Actual/365
* 4 European 30/360
* @return float
*/
public static function PRICEDISC($settlement, $maturity, $discount, $redemption, $basis=0) {
$settlement = self::flattenSingleValue($settlement);
$maturity = self::flattenSingleValue($maturity);
$discount = (float) self::flattenSingleValue($discount);
$redemption = (float) self::flattenSingleValue($redemption);
$basis = (int) self::flattenSingleValue($basis);
// Validate
if ((is_numeric($discount)) && (is_numeric($redemption)) && (is_numeric($basis))) {
if (($discount <= 0) || ($redemption <= 0)) {
return self::$_errorCodes['num'];
}
$daysBetweenSettlementAndMaturity = self::YEARFRAC($settlement, $maturity, $basis);
if (!is_numeric($daysBetweenSettlementAndMaturity)) {
return $daysBetweenSettlementAndMaturity;
}
return $redemption * (1 - $discount * $daysBetweenSettlementAndMaturity);
}
return self::$_errorCodes['value'];
} // function PRICEDISC()
/**
* PRICEMAT
*
* Returns the price per $100 face value of a security that pays interest at maturity.
*
* @param mixed settlement The security's settlement date.
* The security's settlement date is the date after the issue date when the security is traded to the buyer.
* @param mixed maturity The security's maturity date.
* The maturity date is the date when the security expires.
* @param mixed issue The security's issue date.
* @param int rate The security's interest rate at date of issue.
* @param int yield The security's annual yield.
* @param int basis The type of day count to use.
* 0 or omitted US (NASD) 30/360
* 1 Actual/actual
* 2 Actual/360
* 3 Actual/365
* 4 European 30/360
* @return float
*/
public static function PRICEMAT($settlement, $maturity, $issue, $rate, $yield, $basis=0) {
$settlement = self::flattenSingleValue($settlement);
$maturity = self::flattenSingleValue($maturity);
$issue = self::flattenSingleValue($issue);
$rate = self::flattenSingleValue($rate);
$yield = self::flattenSingleValue($yield);
$basis = (int) self::flattenSingleValue($basis);
// Validate
if (is_numeric($rate) && is_numeric($yield)) {
if (($rate <= 0) || ($yield <= 0)) {
return self::$_errorCodes['num'];
}
$daysPerYear = self::_daysPerYear(self::YEAR($settlement),$basis);
if (!is_numeric($daysPerYear)) {
return $daysPerYear;
}
$daysBetweenIssueAndSettlement = self::YEARFRAC($issue, $settlement, $basis);
if (!is_numeric($daysBetweenIssueAndSettlement)) {
return $daysBetweenIssueAndSettlement;
}
$daysBetweenIssueAndSettlement *= $daysPerYear;
$daysBetweenIssueAndMaturity = self::YEARFRAC($issue, $maturity, $basis);
if (!is_numeric($daysBetweenIssueAndMaturity)) {
return $daysBetweenIssueAndMaturity;
}
$daysBetweenIssueAndMaturity *= $daysPerYear;
$daysBetweenSettlementAndMaturity = self::YEARFRAC($settlement, $maturity, $basis);
if (!is_numeric($daysBetweenSettlementAndMaturity)) {
return $daysBetweenSettlementAndMaturity;
}
$daysBetweenSettlementAndMaturity *= $daysPerYear;
return ((100 + (($daysBetweenIssueAndMaturity / $daysPerYear) * $rate * 100)) /
(1 + (($daysBetweenSettlementAndMaturity / $daysPerYear) * $yield)) -
(($daysBetweenIssueAndSettlement / $daysPerYear) * $rate * 100));
}
return self::$_errorCodes['value'];
} // function PRICEMAT()
/**
* RECEIVED
*
* Returns the price per $100 face value of a discounted security.
*
* @param mixed settlement The security's settlement date.
* The security settlement date is the date after the issue date when the security is traded to the buyer.
* @param mixed maturity The security's maturity date.
* The maturity date is the date when the security expires.
* @param int investment The amount invested in the security.
* @param int discount The security's discount rate.
* @param int basis The type of day count to use.
* 0 or omitted US (NASD) 30/360
* 1 Actual/actual
* 2 Actual/360
* 3 Actual/365
* 4 European 30/360
* @return float
*/
public static function RECEIVED($settlement, $maturity, $investment, $discount, $basis=0) {
$settlement = self::flattenSingleValue($settlement);
$maturity = self::flattenSingleValue($maturity);
$investment = (float) self::flattenSingleValue($investment);
$discount = (float) self::flattenSingleValue($discount);
$basis = (int) self::flattenSingleValue($basis);
// Validate
if ((is_numeric($investment)) && (is_numeric($discount)) && (is_numeric($basis))) {
if (($investment <= 0) || ($discount <= 0)) {
return self::$_errorCodes['num'];
}
$daysBetweenSettlementAndMaturity = self::YEARFRAC($settlement, $maturity, $basis);
if (!is_numeric($daysBetweenSettlementAndMaturity)) {
return $daysBetweenSettlementAndMaturity;
}
return $investment / ( 1 - ($discount * $daysBetweenSettlementAndMaturity));
}
return self::$_errorCodes['value'];
} // function RECEIVED()
/**
* INTRATE
*
* Returns the interest rate for a fully invested security.
*
* @param mixed settlement The security's settlement date.
* The security settlement date is the date after the issue date when the security is traded to the buyer.
* @param mixed maturity The security's maturity date.
* The maturity date is the date when the security expires.
* @param int investment The amount invested in the security.
* @param int redemption The amount to be received at maturity.
* @param int basis The type of day count to use.
* 0 or omitted US (NASD) 30/360
* 1 Actual/actual
* 2 Actual/360
* 3 Actual/365
* 4 European 30/360
* @return float
*/
public static function INTRATE($settlement, $maturity, $investment, $redemption, $basis=0) {
$settlement = self::flattenSingleValue($settlement);
$maturity = self::flattenSingleValue($maturity);
$investment = (float) self::flattenSingleValue($investment);
$redemption = (float) self::flattenSingleValue($redemption);
$basis = (int) self::flattenSingleValue($basis);
// Validate
if ((is_numeric($investment)) && (is_numeric($redemption)) && (is_numeric($basis))) {
if (($investment <= 0) || ($redemption <= 0)) {
return self::$_errorCodes['num'];
}
$daysBetweenSettlementAndMaturity = self::YEARFRAC($settlement, $maturity, $basis);
if (!is_numeric($daysBetweenSettlementAndMaturity)) {
return $daysBetweenSettlementAndMaturity;
}
return (($redemption / $investment) - 1) / ($daysBetweenSettlementAndMaturity);
}
return self::$_errorCodes['value'];
} // function INTRATE()
/**
* TBILLEQ
*
* Returns the bond-equivalent yield for a Treasury bill.
*
* @param mixed settlement The Treasury bill's settlement date.
* The Treasury bill's settlement date is the date after the issue date when the Treasury bill is traded to the buyer.
* @param mixed maturity The Treasury bill's maturity date.
* The maturity date is the date when the Treasury bill expires.
* @param int discount The Treasury bill's discount rate.
* @return float
*/
public static function TBILLEQ($settlement, $maturity, $discount) {
$settlement = self::flattenSingleValue($settlement);
$maturity = self::flattenSingleValue($maturity);
$discount = self::flattenSingleValue($discount);
// Use TBILLPRICE for validation
$testValue = self::TBILLPRICE($settlement, $maturity, $discount);
if (is_string($testValue)) {
return $testValue;
}
if (is_string($maturity = self::_getDateValue($maturity))) {
return self::$_errorCodes['value'];
}
if (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE) {
++$maturity;
$daysBetweenSettlementAndMaturity = self::YEARFRAC($settlement, $maturity) * 360;
} else {
$daysBetweenSettlementAndMaturity = (self::_getDateValue($maturity) - self::_getDateValue($settlement));
}
return (365 * $discount) / (360 - $discount * $daysBetweenSettlementAndMaturity);
} // function TBILLEQ()
/**
* TBILLPRICE
*
* Returns the yield for a Treasury bill.
*
* @param mixed settlement The Treasury bill's settlement date.
* The Treasury bill's settlement date is the date after the issue date when the Treasury bill is traded to the buyer.
* @param mixed maturity The Treasury bill's maturity date.
* The maturity date is the date when the Treasury bill expires.
* @param int discount The Treasury bill's discount rate.
* @return float
*/
public static function TBILLPRICE($settlement, $maturity, $discount) {
$settlement = self::flattenSingleValue($settlement);
$maturity = self::flattenSingleValue($maturity);
$discount = self::flattenSingleValue($discount);
if (is_string($maturity = self::_getDateValue($maturity))) {
return self::$_errorCodes['value'];
}
// Validate
if (is_numeric($discount)) {
if ($discount <= 0) {
return self::$_errorCodes['num'];
}
if (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE) {
++$maturity;
$daysBetweenSettlementAndMaturity = self::YEARFRAC($settlement, $maturity) * 360;
if (!is_numeric($daysBetweenSettlementAndMaturity)) {
return $daysBetweenSettlementAndMaturity;
}
} else {
$daysBetweenSettlementAndMaturity = (self::_getDateValue($maturity) - self::_getDateValue($settlement));
}
if ($daysBetweenSettlementAndMaturity > 360) {
return self::$_errorCodes['num'];
}
$price = 100 * (1 - (($discount * $daysBetweenSettlementAndMaturity) / 360));
if ($price <= 0) {
return self::$_errorCodes['num'];
}
return $price;
}
return self::$_errorCodes['value'];
} // function TBILLPRICE()
/**
* TBILLYIELD
*
* Returns the yield for a Treasury bill.
*
* @param mixed settlement The Treasury bill's settlement date.
* The Treasury bill's settlement date is the date after the issue date when the Treasury bill is traded to the buyer.
* @param mixed maturity The Treasury bill's maturity date.
* The maturity date is the date when the Treasury bill expires.
* @param int price The Treasury bill's price per $100 face value.
* @return float
*/
public static function TBILLYIELD($settlement, $maturity, $price) {
$settlement = self::flattenSingleValue($settlement);
$maturity = self::flattenSingleValue($maturity);
$price = self::flattenSingleValue($price);
// Validate
if (is_numeric($price)) {
if ($price <= 0) {
return self::$_errorCodes['num'];
}
if (self::$compatibilityMode == self::COMPATIBILITY_OPENOFFICE) {
++$maturity;
$daysBetweenSettlementAndMaturity = self::YEARFRAC($settlement, $maturity) * 360;
if (!is_numeric($daysBetweenSettlementAndMaturity)) {
return $daysBetweenSettlementAndMaturity;
}
} else {
$daysBetweenSettlementAndMaturity = (self::_getDateValue($maturity) - self::_getDateValue($settlement));
}
if ($daysBetweenSettlementAndMaturity > 360) {
return self::$_errorCodes['num'];
}
return ((100 - $price) / $price) * (360 / $daysBetweenSettlementAndMaturity);
}
return self::$_errorCodes['value'];
} // function TBILLYIELD()
/**
* SLN
*
* Returns the straight-line depreciation of an asset for one period
*
* @param cost Initial cost of the asset
* @param salvage Value at the end of the depreciation
* @param life Number of periods over which the asset is depreciated
* @return float
*/
public static function SLN($cost, $salvage, $life) {
$cost = self::flattenSingleValue($cost);
$salvage = self::flattenSingleValue($salvage);
$life = self::flattenSingleValue($life);
// Calculate
if ((is_numeric($cost)) && (is_numeric($salvage)) && (is_numeric($life))) {
if ($life < 0) {
return self::$_errorCodes['num'];
}
return ($cost - $salvage) / $life;
}
return self::$_errorCodes['value'];
} // function SLN()
/**
* YIELDMAT
*
* Returns the annual yield of a security that pays interest at maturity.
*
* @param mixed settlement The security's settlement date.
* The security's settlement date is the date after the issue date when the security is traded to the buyer.
* @param mixed maturity The security's maturity date.
* The maturity date is the date when the security expires.
* @param mixed issue The security's issue date.
* @param int rate The security's interest rate at date of issue.
* @param int price The security's price per $100 face value.
* @param int basis The type of day count to use.
* 0 or omitted US (NASD) 30/360
* 1 Actual/actual
* 2 Actual/360
* 3 Actual/365
* 4 European 30/360
* @return float
*/
public static function YIELDMAT($settlement, $maturity, $issue, $rate, $price, $basis=0) {
$settlement = self::flattenSingleValue($settlement);
$maturity = self::flattenSingleValue($maturity);
$issue = self::flattenSingleValue($issue);
$rate = self::flattenSingleValue($rate);
$price = self::flattenSingleValue($price);
$basis = (int) self::flattenSingleValue($basis);
// Validate
if (is_numeric($rate) && is_numeric($price)) {
if (($rate <= 0) || ($price <= 0)) {
return self::$_errorCodes['num'];
}
$daysPerYear = self::_daysPerYear(self::YEAR($settlement),$basis);
if (!is_numeric($daysPerYear)) {
return $daysPerYear;
}
$daysBetweenIssueAndSettlement = self::YEARFRAC($issue, $settlement, $basis);
if (!is_numeric($daysBetweenIssueAndSettlement)) {
return $daysBetweenIssueAndSettlement;
}
$daysBetweenIssueAndSettlement *= $daysPerYear;
$daysBetweenIssueAndMaturity = self::YEARFRAC($issue, $maturity, $basis);
if (!is_numeric($daysBetweenIssueAndMaturity)) {
return $daysBetweenIssueAndMaturity;
}
$daysBetweenIssueAndMaturity *= $daysPerYear;
$daysBetweenSettlementAndMaturity = self::YEARFRAC($settlement, $maturity, $basis);
if (!is_numeric($daysBetweenSettlementAndMaturity)) {
return $daysBetweenSettlementAndMaturity;
}
$daysBetweenSettlementAndMaturity *= $daysPerYear;
return ((1 + (($daysBetweenIssueAndMaturity / $daysPerYear) * $rate) - (($price / 100) + (($daysBetweenIssueAndSettlement / $daysPerYear) * $rate))) /
(($price / 100) + (($daysBetweenIssueAndSettlement / $daysPerYear) * $rate))) *
($daysPerYear / $daysBetweenSettlementAndMaturity);
}
return self::$_errorCodes['value'];
} // function YIELDMAT()
/**
* YIELDDISC
*
* Returns the annual yield of a security that pays interest at maturity.
*
* @param mixed settlement The security's settlement date.
* The security's settlement date is the date after the issue date when the security is traded to the buyer.
* @param mixed maturity The security's maturity date.
* The maturity date is the date when the security expires.
* @param int price The security's price per $100 face value.
* @param int redemption The security's redemption value per $100 face value.
* @param int basis The type of day count to use.
* 0 or omitted US (NASD) 30/360
* 1 Actual/actual
* 2 Actual/360
* 3 Actual/365
* 4 European 30/360
* @return float
*/
public static function YIELDDISC($settlement, $maturity, $price, $redemption, $basis=0) {
$settlement = self::flattenSingleValue($settlement);
$maturity = self::flattenSingleValue($maturity);
$price = self::flattenSingleValue($price);
$redemption = self::flattenSingleValue($redemption);
$basis = (int) self::flattenSingleValue($basis);
// Validate
if (is_numeric($price) && is_numeric($redemption)) {
if (($price <= 0) || ($redemption <= 0)) {
return self::$_errorCodes['num'];
}
$daysPerYear = self::_daysPerYear(self::YEAR($settlement),$basis);
if (!is_numeric($daysPerYear)) {
return $daysPerYear;
}
$daysBetweenSettlementAndMaturity = self::YEARFRAC($settlement, $maturity,$basis);
if (!is_numeric($daysBetweenSettlementAndMaturity)) {
return $daysBetweenSettlementAndMaturity;
}
$daysBetweenSettlementAndMaturity *= $daysPerYear;
return (($redemption - $price) / $price) * ($daysPerYear / $daysBetweenSettlementAndMaturity);
}
return self::$_errorCodes['value'];
} // function YIELDDISC()
/**
* CELL_ADDRESS
*
* Creates a cell address as text, given specified row and column numbers.
*
* @param row Row number to use in the cell reference
* @param column Column number to use in the cell reference
* @param relativity Flag indicating the type of reference to return
* 1 or omitted Absolute
* 2 Absolute row; relative column
* 3 Relative row; absolute column
* 4 Relative
* @param referenceStyle A logical value that specifies the A1 or R1C1 reference style.
* TRUE or omitted CELL_ADDRESS returns an A1-style reference
* FALSE CELL_ADDRESS returns an R1C1-style reference
* @param sheetText Optional Name of worksheet to use
* @return string
*/
public static function CELL_ADDRESS($row, $column, $relativity=1, $referenceStyle=True, $sheetText='') {
$row = self::flattenSingleValue($row);
$column = self::flattenSingleValue($column);
$relativity = self::flattenSingleValue($relativity);
$sheetText = self::flattenSingleValue($sheetText);
if (($row < 1) || ($column < 1)) {
return self::$_errorCodes['value'];
}
if ($sheetText > '') {
if (strpos($sheetText,' ') !== False) { $sheetText = "'".$sheetText."'"; }
$sheetText .='!';
}
if ((!is_bool($referenceStyle)) || $referenceStyle) {
$rowRelative = $columnRelative = '$';
$column = PHPExcel_Cell::stringFromColumnIndex($column-1);
if (($relativity == 2) || ($relativity == 4)) { $columnRelative = ''; }
if (($relativity == 3) || ($relativity == 4)) { $rowRelative = ''; }
return $sheetText.$columnRelative.$column.$rowRelative.$row;
} else {
if (($relativity == 2) || ($relativity == 4)) { $column = '['.$column.']'; }
if (($relativity == 3) || ($relativity == 4)) { $row = '['.$row.']'; }
return $sheetText.'R'.$row.'C'.$column;
}
} // function CELL_ADDRESS()
/**
* COLUMN
*
* Returns the column number of the given cell reference
* If the cell reference is a range of cells, COLUMN returns the column numbers of each column in the reference as a horizontal array.
* If cell reference is omitted, and the function is being called through the calculation engine, then it is assumed to be the
* reference of the cell in which the COLUMN function appears; otherwise this function returns 0.
*
* @param cellAddress A reference to a range of cells for which you want the column numbers
* @return integer or array of integer
*/
public static function COLUMN($cellAddress=Null) {
if (is_null($cellAddress) || trim($cellAddress) === '') { return 0; }
if (is_array($cellAddress)) {
foreach($cellAddress as $columnKey => $value) {
$columnKey = preg_replace('/[^a-z]/i','',$columnKey);
return (integer) PHPExcel_Cell::columnIndexFromString($columnKey);
}
} else {
if (strpos($cellAddress,'!') !== false) {
list($sheet,$cellAddress) = explode('!',$cellAddress);
}
if (strpos($cellAddress,':') !== false) {
list($startAddress,$endAddress) = explode(':',$cellAddress);
$startAddress = preg_replace('/[^a-z]/i','',$startAddress);
$endAddress = preg_replace('/[^a-z]/i','',$endAddress);
$returnValue = array();
do {
$returnValue[] = (integer) PHPExcel_Cell::columnIndexFromString($startAddress);
} while ($startAddress++ != $endAddress);
return $returnValue;
} else {
$cellAddress = preg_replace('/[^a-z]/i','',$cellAddress);
return (integer) PHPExcel_Cell::columnIndexFromString($cellAddress);
}
}
} // function COLUMN()
/**
* COLUMNS
*
* Returns the number of columns in an array or reference.
*
* @param cellAddress An array or array formula, or a reference to a range of cells for which you want the number of columns
* @return integer
*/
public static function COLUMNS($cellAddress=Null) {
if (is_null($cellAddress) || $cellAddress === '') {
return 1;
} elseif (!is_array($cellAddress)) {
return self::$_errorCodes['value'];
}
$isMatrix = (is_numeric(array_shift(array_keys($cellAddress))));
list($columns,$rows) = PHPExcel_Calculation::_getMatrixDimensions($cellAddress);
if ($isMatrix) {
return $rows;
} else {
return $columns;
}
} // function COLUMNS()
/**
* ROW
*
* Returns the row number of the given cell reference
* If the cell reference is a range of cells, ROW returns the row numbers of each row in the reference as a vertical array.
* If cell reference is omitted, and the function is being called through the calculation engine, then it is assumed to be the
* reference of the cell in which the ROW function appears; otherwise this function returns 0.
*
* @param cellAddress A reference to a range of cells for which you want the row numbers
* @return integer or array of integer
*/
public static function ROW($cellAddress=Null) {
if (is_null($cellAddress) || trim($cellAddress) === '') { return 0; }
if (is_array($cellAddress)) {
foreach($cellAddress as $columnKey => $rowValue) {
foreach($rowValue as $rowKey => $cellValue) {
return (integer) preg_replace('/[^0-9]/i','',$rowKey);
}
}
} else {
if (strpos($cellAddress,'!') !== false) {
list($sheet,$cellAddress) = explode('!',$cellAddress);
}
if (strpos($cellAddress,':') !== false) {
list($startAddress,$endAddress) = explode(':',$cellAddress);
$startAddress = preg_replace('/[^0-9]/','',$startAddress);
$endAddress = preg_replace('/[^0-9]/','',$endAddress);
$returnValue = array();
do {
$returnValue[][] = (integer) $startAddress;
} while ($startAddress++ != $endAddress);
return $returnValue;
} else {
list($cellAddress) = explode(':',$cellAddress);
return (integer) preg_replace('/[^0-9]/','',$cellAddress);
}
}
} // function ROW()
/**
* ROWS
*
* Returns the number of rows in an array or reference.
*
* @param cellAddress An array or array formula, or a reference to a range of cells for which you want the number of rows
* @return integer
*/
public static function ROWS($cellAddress=Null) {
if (is_null($cellAddress) || $cellAddress === '') {
return 1;
} elseif (!is_array($cellAddress)) {
return self::$_errorCodes['value'];
}
$isMatrix = (is_numeric(array_shift(array_keys($cellAddress))));
list($columns,$rows) = PHPExcel_Calculation::_getMatrixDimensions($cellAddress);
if ($isMatrix) {
return $columns;
} else {
return $rows;
}
} // function ROWS()
/**
* INDIRECT
*
* Returns the number of rows in an array or reference.
*
* @param cellAddress An array or array formula, or a reference to a range of cells for which you want the number of rows
* @return integer
*/
public static function INDIRECT($cellAddress=Null, PHPExcel_Cell $pCell = null) {
$cellAddress = self::flattenSingleValue($cellAddress);
if (is_null($cellAddress) || $cellAddress === '') {
return self::REF();
}
$cellAddress1 = $cellAddress;
$cellAddress2 = NULL;
if (strpos($cellAddress,':') !== false) {
list($cellAddress1,$cellAddress2) = explode(':',$cellAddress);
}
if ((!preg_match('/^'.PHPExcel_Calculation::CALCULATION_REGEXP_CELLREF.'$/i', $cellAddress1, $matches)) ||
((!is_null($cellAddress2)) && (!preg_match('/^'.PHPExcel_Calculation::CALCULATION_REGEXP_CELLREF.'$/i', $cellAddress2, $matches)))) {
return self::REF();
}
if (strpos($cellAddress,'!') !== false) {
list($sheetName,$cellAddress) = explode('!',$cellAddress);
$pSheet = $pCell->getParent()->getParent()->getSheetByName($sheetName);
} else {
$pSheet = $pCell->getParent();
}
return PHPExcel_Calculation::getInstance()->extractCellRange($cellAddress, $pSheet, False);
} // function INDIRECT()
/**
* OFFSET
*
* Returns a reference to a range that is a specified number of rows and columns from a cell or range of cells.
* The reference that is returned can be a single cell or a range of cells. You can specify the number of rows and
* the number of columns to be returned.
*
* @param cellAddress The reference from which you want to base the offset. Reference must refer to a cell or
* range of adjacent cells; otherwise, OFFSET returns the #VALUE! error value.
* @param rows The number of rows, up or down, that you want the upper-left cell to refer to.
* Using 5 as the rows argument specifies that the upper-left cell in the reference is
* five rows below reference. Rows can be positive (which means below the starting reference)
* or negative (which means above the starting reference).
* @param cols The number of columns, to the left or right, that you want the upper-left cell of the result
* to refer to. Using 5 as the cols argument specifies that the upper-left cell in the
* reference is five columns to the right of reference. Cols can be positive (which means
* to the right of the starting reference) or negative (which means to the left of the
* starting reference).
* @param height The height, in number of rows, that you want the returned reference to be. Height must be a positive number.
* @param width The width, in number of columns, that you want the returned reference to be. Width must be a positive number.
* @return string A reference to a cell or range of cells
*/
public static function OFFSET($cellAddress=Null,$rows=0,$columns=0,$height=null,$width=null) {
if ($cellAddress == Null) {
return 0;
}
$pCell = array_pop(func_get_args());
if (!is_object($pCell)) {
return self::$_errorCodes['reference'];
}
$sheetName = null;
if (strpos($cellAddress,"!")) {
list($sheetName,$cellAddress) = explode("!",$cellAddress);
}
if (strpos($cellAddress,":")) {
list($startCell,$endCell) = explode(":",$cellAddress);
} else {
$startCell = $endCell = $cellAddress;
}
list($startCellColumn,$startCellRow) = PHPExcel_Cell::coordinateFromString($startCell);
list($endCellColumn,$endCellRow) = PHPExcel_Cell::coordinateFromString($endCell);
$startCellRow += $rows;
$startCellColumn = PHPExcel_Cell::columnIndexFromString($startCellColumn) - 1;
$startCellColumn += $columns;
if (($startCellRow <= 0) || ($startCellColumn < 0)) {
return self::$_errorCodes['reference'];
}
$endCellColumn = PHPExcel_Cell::columnIndexFromString($endCellColumn) - 1;
if (($width != null) && (!is_object($width))) {
$endCellColumn = $startCellColumn + $width - 1;
} else {
$endCellColumn += $columns;
}
$startCellColumn = PHPExcel_Cell::stringFromColumnIndex($startCellColumn);
if (($height != null) && (!is_object($height))) {
$endCellRow = $startCellRow + $height - 1;
} else {
$endCellRow += $rows;
}
if (($endCellRow <= 0) || ($endCellColumn < 0)) {
return self::$_errorCodes['reference'];
}
$endCellColumn = PHPExcel_Cell::stringFromColumnIndex($endCellColumn);
$cellAddress = $startCellColumn.$startCellRow;
if (($startCellColumn != $endCellColumn) || ($startCellRow != $endCellRow)) {
$cellAddress .= ':'.$endCellColumn.$endCellRow;
}
if ($sheetName !== null) {
$pSheet = $pCell->getParent()->getParent()->getSheetByName($sheetName);
} else {
$pSheet = $pCell->getParent();
}
return PHPExcel_Calculation::getInstance()->extractCellRange($cellAddress, $pSheet, False);
} // function OFFSET()
public static function CHOOSE() {
$chooseArgs = func_get_args();
$chosenEntry = self::flattenArray(array_shift($chooseArgs));
$entryCount = count($chooseArgs) - 1;
if(is_array($chosenEntry)) {
$chosenEntry = array_shift($chosenEntry);
}
if ((is_numeric($chosenEntry)) && (!is_bool($chosenEntry))) {
--$chosenEntry;
} else {
return self::$_errorCodes['value'];
}
$chosenEntry = floor($chosenEntry);
if (($chosenEntry <= 0) || ($chosenEntry > $entryCount)) {
return self::$_errorCodes['value'];
}
if (is_array($chooseArgs[$chosenEntry])) {
return self::flattenArray($chooseArgs[$chosenEntry]);
} else {
return $chooseArgs[$chosenEntry];
}
} // function CHOOSE()
/**
* MATCH
*
* The MATCH function searches for a specified item in a range of cells
*
* @param lookup_value The value that you want to match in lookup_array
* @param lookup_array The range of cells being searched
* @param match_type The number -1, 0, or 1. -1 means above, 0 means exact match, 1 means below. If match_type is 1 or -1, the list has to be ordered.
* @return integer The relative position of the found item
*/
public static function MATCH($lookup_value, $lookup_array, $match_type=1) {
// flatten the lookup_array
$lookup_array = self::flattenArray($lookup_array);
// flatten lookup_value since it may be a cell reference to a value or the value itself
$lookup_value = self::flattenSingleValue($lookup_value);
// MATCH is not case sensitive
$lookup_value = strtolower($lookup_value);
/*
echo "-------------------- looking for $lookup_value in ";
print_r($lookup_array);
echo " ";
//return 1;
/**/
// **
// check inputs
// **
// lookup_value type has to be number, text, or logical values
if (!is_numeric($lookup_value) && !is_string($lookup_value) && !is_bool($lookup_value)){
// error: lookup_array should contain only number, text, or logical values
//echo "error: lookup_array should contain only number, text, or logical values ";
return self::$_errorCodes['na'];
}
// match_type is 0, 1 or -1
if ($match_type!==0 && $match_type!==-1 && $match_type!==1){
// error: wrong value for match_type
//echo "error: wrong value for match_type ";
return self::$_errorCodes['na'];
}
// lookup_array should not be empty
if (sizeof($lookup_array)<=0){
// error: empty range
//echo "error: empty range ".sizeof($lookup_array)." ";
return self::$_errorCodes['na'];
}
// lookup_array should contain only number, text, or logical values
for ($i=0;$i<sizeof($lookup_array);++$i){
// check the type of the value
if (!is_numeric($lookup_array[$i]) && !is_string($lookup_array[$i]) && !is_bool($lookup_array[$i])){
// error: lookup_array should contain only number, text, or logical values
//echo "error: lookup_array should contain only number, text, or logical values ";
return self::$_errorCodes['na'];
}
// convert tpo lowercase
if (is_string($lookup_array[$i]))
$lookup_array[$i] = strtolower($lookup_array[$i]);
}
// if match_type is 1 or -1, the list has to be ordered
if($match_type==1 || $match_type==-1){
// **
// iniitialization
// store the last value
$iLastValue=$lookup_array[0];
// **
// loop on the cells
for ($i=0;$i<sizeof($lookup_array);++$i){
// check ascending order
if(($match_type==1 && $lookup_array[$i]<$iLastValue)
// OR check descending order
|| ($match_type==-1 && $lookup_array[$i]>$iLastValue)){
// error: list is not ordered correctly
//echo "error: list is not ordered correctly ";
return self::$_errorCodes['na'];
}
}
}
// **
// find the match
// **
// loop on the cells
for ($i=0; $i < sizeof($lookup_array); ++$i){
// if match_type is 0 <=> find the first value that is exactly equal to lookup_value
if ($match_type==0 && $lookup_array[$i]==$lookup_value){
// this is the exact match
return $i+1;
}
// if match_type is -1 <=> find the smallest value that is greater than or equal to lookup_value
if ($match_type==-1 && $lookup_array[$i] < $lookup_value){
if ($i<1){
// 1st cell was allready smaller than the lookup_value
break;
}
else
// the previous cell was the match
return $i;
}
// if match_type is 1 <=> find the largest value that is less than or equal to lookup_value
if ($match_type==1 && $lookup_array[$i] > $lookup_value){
if ($i<1){
// 1st cell was allready bigger than the lookup_value
break;
}
else
// the previous cell was the match
return $i;
}
}
// unsuccessful in finding a match, return #N/A error value
//echo "unsuccessful in finding a match ";
return self::$_errorCodes['na'];
} // function MATCH()
/**
* Uses an index to choose a value from a reference or array
* implemented: Return the value of a specified cell or array of cells Array form
* not implemented: Return a reference to specified cells Reference form
*
* @param range_array a range of cells or an array constant
* @param row_num selects the row in array from which to return a value. If row_num is omitted, column_num is required.
* @param column_num selects the column in array from which to return a value. If column_num is omitted, row_num is required.
*/
public static function INDEX($arrayValues,$rowNum = 0,$columnNum = 0) {
if (($rowNum < 0) || ($columnNum < 0)) {
return self::$_errorCodes['value'];
}
$rowKeys = array_keys($arrayValues);
$columnKeys = @array_keys($arrayValues[$rowKeys[0]]);
if ($columnNum > count($columnKeys)) {
return self::$_errorCodes['value'];
} elseif ($columnNum == 0) {
if ($rowNum == 0) {
return $arrayValues;
}
$rowNum = $rowKeys[--$rowNum];
$returnArray = array();
foreach($arrayValues as $arrayColumn) {
if (is_array($arrayColumn)) {
if (isset($arrayColumn[$rowNum])) {
$returnArray[] = $arrayColumn[$rowNum];
} else {
return $arrayValues[$rowNum];
}
} else {
return $arrayValues[$rowNum];
}
}
return $returnArray;
}
$columnNum = $columnKeys[--$columnNum];
if ($rowNum > count($rowKeys)) {
return self::$_errorCodes['value'];
} elseif ($rowNum == 0) {
return $arrayValues[$columnNum];
}
$rowNum = $rowKeys[--$rowNum];
return $arrayValues[$rowNum][$columnNum];
} // function INDEX()
/**
* SYD
*
* Returns the sum-of-years' digits depreciation of an asset for a specified period.
*
* @param cost Initial cost of the asset
* @param salvage Value at the end of the depreciation
* @param life Number of periods over which the asset is depreciated
* @param period Period
* @return float
*/
public static function SYD($cost, $salvage, $life, $period) {
$cost = self::flattenSingleValue($cost);
$salvage = self::flattenSingleValue($salvage);
$life = self::flattenSingleValue($life);
$period = self::flattenSingleValue($period);
// Calculate
if ((is_numeric($cost)) && (is_numeric($salvage)) && (is_numeric($life)) && (is_numeric($period))) {
if (($life < 1) || ($period > $life)) {
return self::$_errorCodes['num'];
}
return (($cost - $salvage) * ($life - $period + 1) * 2) / ($life * ($life + 1));
}
return self::$_errorCodes['value'];
} // function SYD()
/**
* TRANSPOSE
*
* @param array $matrixData A matrix of values
* @return array
*
* Unlike the Excel TRANSPOSE function, which will only work on a single row or column, this function will transpose a full matrix.
*/
public static function TRANSPOSE($matrixData) {
$returnMatrix = array();
if (!is_array($matrixData)) { $matrixData = array(array($matrixData)); }
$column = 0;
foreach($matrixData as $matrixRow) {
$row = 0;
foreach($matrixRow as $matrixCell) {
$returnMatrix[$row][$column] = $matrixCell;
++$row;
}
++$column;
}
return $returnMatrix;
} // function TRANSPOSE()
/**
* MMULT
*
* @param array $matrixData1 A matrix of values
* @param array $matrixData2 A matrix of values
* @return array
*/
public static function MMULT($matrixData1,$matrixData2) {
$matrixAData = $matrixBData = array();
if (!is_array($matrixData1)) { $matrixData1 = array(array($matrixData1)); }
if (!is_array($matrixData2)) { $matrixData2 = array(array($matrixData2)); }
$rowA = 0;
foreach($matrixData1 as $matrixRow) {
$columnA = 0;
foreach($matrixRow as $matrixCell) {
if ((is_string($matrixCell)) || ($matrixCell === null)) {
return self::$_errorCodes['value'];
}
$matrixAData[$rowA][$columnA] = $matrixCell;
++$columnA;
}
++$rowA;
}
try {
$matrixA = new Matrix($matrixAData);
$rowB = 0;
foreach($matrixData2 as $matrixRow) {
$columnB = 0;
foreach($matrixRow as $matrixCell) {
if ((is_string($matrixCell)) || ($matrixCell === null)) {
return self::$_errorCodes['value'];
}
$matrixBData[$rowB][$columnB] = $matrixCell;
++$columnB;
}
++$rowB;
}
$matrixB = new Matrix($matrixBData);
if (($rowA != $columnB) || ($rowB != $columnA)) {
return self::$_errorCodes['value'];
}
return $matrixA->times($matrixB)->getArray();
} catch (Exception $ex) {
return self::$_errorCodes['value'];
}
} // function MMULT()
/**
* MINVERSE
*
* @param array $matrixValues A matrix of values
* @return array
*/
public static function MINVERSE($matrixValues) {
$matrixData = array();
if (!is_array($matrixValues)) { $matrixValues = array(array($matrixValues)); }
$row = $maxColumn = 0;
foreach($matrixValues as $matrixRow) {
$column = 0;
foreach($matrixRow as $matrixCell) {
if ((is_string($matrixCell)) || ($matrixCell === null)) {
return self::$_errorCodes['value'];
}
$matrixData[$column][$row] = $matrixCell;
++$column;
}
if ($column > $maxColumn) { $maxColumn = $column; }
++$row;
}
if ($row != $maxColumn) { return self::$_errorCodes['value']; }
try {
$matrix = new Matrix($matrixData);
return $matrix->inverse()->getArray();
} catch (Exception $ex) {
return self::$_errorCodes['value'];
}
} // function MINVERSE()
/**
* MDETERM
*
* @param array $matrixValues A matrix of values
* @return float
*/
public static function MDETERM($matrixValues) {
$matrixData = array();
if (!is_array($matrixValues)) { $matrixValues = array(array($matrixValues)); }
$row = $maxColumn = 0;
foreach($matrixValues as $matrixRow) {
$column = 0;
foreach($matrixRow as $matrixCell) {
if ((is_string($matrixCell)) || ($matrixCell === null)) {
return self::$_errorCodes['value'];
}
$matrixData[$column][$row] = $matrixCell;
++$column;
}
if ($column > $maxColumn) { $maxColumn = $column; }
++$row;
}
if ($row != $maxColumn) { return self::$_errorCodes['value']; }
try {
$matrix = new Matrix($matrixData);
return $matrix->det();
} catch (Exception $ex) {
return self::$_errorCodes['value'];
}
} // function MDETERM()
/**
* SUMPRODUCT
*
* @param mixed $value Value to check
* @return float
*/
public static function SUMPRODUCT() {
$arrayList = func_get_args();
$wrkArray = self::flattenArray(array_shift($arrayList));
$wrkCellCount = count($wrkArray);
foreach($arrayList as $matrixData) {
$array2 = self::flattenArray($matrixData);
$count = count($array2);
if ($wrkCellCount != $count) {
return self::$_errorCodes['value'];
}
foreach ($array2 as $i => $val) {
if (((is_numeric($wrkArray[$i])) && (!is_string($wrkArray[$i]))) &&
((is_numeric($val)) && (!is_string($val)))) {
$wrkArray[$i] *= $val;
}
}
}
return array_sum($wrkArray);
} // function SUMPRODUCT()
/**
* SUMX2MY2
*
* @param mixed $value Value to check
* @return float
*/
public static function SUMX2MY2($matrixData1,$matrixData2) {
$array1 = self::flattenArray($matrixData1);
$array2 = self::flattenArray($matrixData2);
$count1 = count($array1);
$count2 = count($array2);
if ($count1 < $count2) {
$count = $count1;
} else {
$count = $count2;
}
$result = 0;
for ($i = 0; $i < $count; ++$i) {
if (((is_numeric($array1[$i])) && (!is_string($array1[$i]))) &&
((is_numeric($array2[$i])) && (!is_string($array2[$i])))) {
$result += ($array1[$i] * $array1[$i]) - ($array2[$i] * $array2[$i]);
}
}
return $result;
} // function SUMX2MY2()
/**
* SUMX2PY2
*
* @param mixed $value Value to check
* @return float
*/
public static function SUMX2PY2($matrixData1,$matrixData2) {
$array1 = self::flattenArray($matrixData1);
$array2 = self::flattenArray($matrixData2);
$count1 = count($array1);
$count2 = count($array2);
if ($count1 < $count2) {
$count = $count1;
} else {
$count = $count2;
}
$result = 0;
for ($i = 0; $i < $count; ++$i) {
if (((is_numeric($array1[$i])) && (!is_string($array1[$i]))) &&
((is_numeric($array2[$i])) && (!is_string($array2[$i])))) {
$result += ($array1[$i] * $array1[$i]) + ($array2[$i] * $array2[$i]);
}
}
return $result;
} // function SUMX2PY2()
/**
* SUMXMY2
*
* @param mixed $value Value to check
* @return float
*/
public static function SUMXMY2($matrixData1,$matrixData2) {
$array1 = self::flattenArray($matrixData1);
$array2 = self::flattenArray($matrixData2);
$count1 = count($array1);
$count2 = count($array2);
if ($count1 < $count2) {
$count = $count1;
} else {
$count = $count2;
}
$result = 0;
for ($i = 0; $i < $count; ++$i) {
if (((is_numeric($array1[$i])) && (!is_string($array1[$i]))) &&
((is_numeric($array2[$i])) && (!is_string($array2[$i])))) {
$result += ($array1[$i] - $array2[$i]) * ($array1[$i] - $array2[$i]);
}
}
return $result;
} // function SUMXMY2()
private static function _vlookupSort($a,$b) {
$firstColumn = array_shift(array_keys($a));
if (strtolower($a[$firstColumn]) == strtolower($b[$firstColumn])) {
return 0;
}
return (strtolower($a[$firstColumn]) < strtolower($b[$firstColumn])) ? -1 : 1;
} // function _vlookupSort()
/**
* VLOOKUP
* The VLOOKUP function searches for value in the left-most column of lookup_array and returns the value in the same row based on the index_number.
* @param lookup_value The value that you want to match in lookup_array
* @param lookup_array The range of cells being searched
* @param index_number The column number in table_array from which the matching value must be returned. The first column is 1.
* @param not_exact_match Determines if you are looking for an exact match based on lookup_value.
* @return mixed The value of the found cell
*/
public static function VLOOKUP($lookup_value, $lookup_array, $index_number, $not_exact_match=true) {
// index_number must be greater than or equal to 1
if ($index_number < 1) {
return self::$_errorCodes['value'];
}
// index_number must be less than or equal to the number of columns in lookup_array
if ((!is_array($lookup_array)) || (count($lookup_array) < 1)) {
return self::$_errorCodes['reference'];
} else {
$firstRow = array_pop(array_keys($lookup_array));
if ((!is_array($lookup_array[$firstRow])) || ($index_number > count($lookup_array[$firstRow]))) {
return self::$_errorCodes['reference'];
} else {
$columnKeys = array_keys($lookup_array[$firstRow]);
$returnColumn = $columnKeys[--$index_number];
$firstColumn = array_shift($columnKeys);
}
}
if (!$not_exact_match) {
uasort($lookup_array,array('self','_vlookupSort'));
}
$rowNumber = $rowValue = False;
foreach($lookup_array as $rowKey => $rowData) {
if (strtolower($rowData[$firstColumn]) > strtolower($lookup_value)) {
break;
}
$rowNumber = $rowKey;
$rowValue = $rowData[$firstColumn];
}
if ($rowNumber !== false) {
if ((!$not_exact_match) && ($rowValue != $lookup_value)) {
// if an exact match is required, we have what we need to return an appropriate response
return self::$_errorCodes['na'];
} else {
// otherwise return the appropriate value
return $lookup_array[$rowNumber][$returnColumn];
}
}
return self::$_errorCodes['na'];
} // function VLOOKUP()
/**
* LOOKUP
* The LOOKUP function searches for value either from a one-row or one-column range or from an array.
* @param lookup_value The value that you want to match in lookup_array
* @param lookup_vector The range of cells being searched
* @param result_vector The column from which the matching value must be returned
* @return mixed The value of the found cell
*/
public static function LOOKUP($lookup_value, $lookup_vector, $result_vector=null) {
$lookup_value = self::flattenSingleValue($lookup_value);
if (!is_array($lookup_vector)) {
return self::$_errorCodes['na'];
}
$lookupRows = count($lookup_vector);
$lookupColumns = count($lookup_vector[array_shift(array_keys($lookup_vector))]);
if ((($lookupRows == 1) && ($lookupColumns > 1)) || (($lookupRows == 2) && ($lookupColumns != 2))) {
$lookup_vector = self::TRANSPOSE($lookup_vector);
$lookupRows = count($lookup_vector);
$lookupColumns = count($lookup_vector[array_shift(array_keys($lookup_vector))]);
}
if (is_null($result_vector)) {
$result_vector = $lookup_vector;
}
$resultRows = count($result_vector);
$resultColumns = count($result_vector[array_shift(array_keys($result_vector))]);
if ((($resultRows == 1) && ($resultColumns > 1)) || (($resultRows == 2) && ($resultColumns != 2))) {
$result_vector = self::TRANSPOSE($result_vector);
$resultRows = count($result_vector);
$resultColumns = count($result_vector[array_shift(array_keys($result_vector))]);
}
if ($lookupRows == 2) {
$result_vector = array_pop($lookup_vector);
$lookup_vector = array_shift($lookup_vector);
}
if ($lookupColumns != 2) {
foreach($lookup_vector as &$value) {
if (is_array($value)) {
$key1 = $key2 = array_shift(array_keys($value));
$key2++;
$dataValue1 = $value[$key1];
} else {
$key1 = 0;
$key2 = 1;
$dataValue1 = $value;
}
$dataValue2 = array_shift($result_vector);
if (is_array($dataValue2)) {
$dataValue2 = array_shift($dataValue2);
}
$value = array($key1 => $dataValue1, $key2 => $dataValue2);
}
unset($value);
}
return self::VLOOKUP($lookup_value,$lookup_vector,2);
} // function LOOKUP()
/**
* Convert a multi-dimensional array to a simple 1-dimensional array
*
* @param array $array Array to be flattened
* @return array Flattened array
*/
public static function flattenArray($array) {
if (!is_array($array)) {
return (array) $array;
}
$arrayValues = array();
foreach ($array as $value) {
if (is_array($value)) {
foreach ($value as $val) {
if (is_array($val)) {
foreach ($val as $v) {
$arrayValues[] = $v;
}
} else {
$arrayValues[] = $val;
}
}
} else {
$arrayValues[] = $value;
}
}
return $arrayValues;
} // function flattenArray()
/**
* Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing
*
* @param array $array Array to be flattened
* @return array Flattened array
*/
public static function flattenArrayIndexed($array) {
if (!is_array($array)) {
return (array) $array;
}
$arrayValues = array();
foreach ($array as $k1 => $value) {
if (is_array($value)) {
foreach ($value as $k2 => $val) {
if (is_array($val)) {
foreach ($val as $k3 => $v) {
$arrayValues[$k1.'.'.$k2.'.'.$k3] = $v;
}
} else {
$arrayValues[$k1.'.'.$k2] = $val;
}
}
} else {
$arrayValues[$k1] = $value;
}
}
return $arrayValues;
} // function flattenArrayIndexed()
/**
* Convert an array to a single scalar value by extracting the first element
*
* @param mixed $value Array or scalar value
* @return mixed
*/
public static function flattenSingleValue($value = '') {
if (is_array($value)) {
return self::flattenSingleValue(array_pop($value));
}
return $value;
} // function flattenSingleValue()
} // class PHPExcel_Calculation_Functions
//
// There are a few mathematical functions that aren't available on all versions of PHP for all platforms
// These functions aren't available in Windows implementations of PHP prior to version 5.3.0
// So we test if they do exist for this version of PHP/operating platform; and if not we create them
//
if (!function_exists('acosh')) {
function acosh($x) {
return 2 * log(sqrt(($x + 1) / 2) + sqrt(($x - 1) / 2));
} // function acosh()
}
if (!function_exists('asinh')) {
function asinh($x) {
return log($x + sqrt(1 + $x * $x));
} // function asinh()
}
if (!function_exists('atanh')) {
function atanh($x) {
return (log(1 + $x) - log(1 - $x)) / 2;
} // function atanh()
}
if (!function_exists('money_format')) {
function money_format($format, $number) {
$regex = array( '/%((?:[\^!\-]|\+|\(|\=.)*)([0-9]+)?(?:#([0-9]+))?',
'(?:\.([0-9]+))?([in%])/'
);
$regex = implode('', $regex);
if (setlocale(LC_MONETARY, null) == '') {
setlocale(LC_MONETARY, '');
}
$locale = localeconv();
$number = floatval($number);
if (!preg_match($regex, $format, $fmatch)) {
trigger_error("No format specified or invalid format", E_USER_WARNING);
return $number;
}
$flags = array( 'fillchar' => preg_match('/\=(.)/', $fmatch[1], $match) ? $match[1] : ' ',
'nogroup' => preg_match('/\^/', $fmatch[1]) > 0,
'usesignal' => preg_match('/\+|\(/', $fmatch[1], $match) ? $match[0] : '+',
'nosimbol' => preg_match('/\!/', $fmatch[1]) > 0,
'isleft' => preg_match('/\-/', $fmatch[1]) > 0
);
$width = trim($fmatch[2]) ? (int)$fmatch[2] : 0;
$left = trim($fmatch[3]) ? (int)$fmatch[3] : 0;
$right = trim($fmatch[4]) ? (int)$fmatch[4] : $locale['int_frac_digits'];
$conversion = $fmatch[5];
$positive = true;
if ($number < 0) {
$positive = false;
$number *= -1;
}
$letter = $positive ? 'p' : 'n';
$prefix = $suffix = $cprefix = $csuffix = $signal = '';
if (!$positive) {
$signal = $locale['negative_sign'];
switch (true) {
case $locale['n_sign_posn'] == 0 || $flags['usesignal'] == '(':
$prefix = '(';
$suffix = ')';
break;
case $locale['n_sign_posn'] == 1:
$prefix = $signal;
break;
case $locale['n_sign_posn'] == 2:
$suffix = $signal;
break;
case $locale['n_sign_posn'] == 3:
$cprefix = $signal;
break;
case $locale['n_sign_posn'] == 4:
$csuffix = $signal;
break;
}
}
if (!$flags['nosimbol']) {
$currency = $cprefix;
$currency .= ($conversion == 'i' ? $locale['int_curr_symbol'] : $locale['currency_symbol']);
$currency .= $csuffix;
$currency = iconv('ISO-8859-1','UTF-8',$currency);
} else {
$currency = '';
}
$space = $locale["{$letter}_sep_by_space"] ? ' ' : '';
$number = number_format($number, $right, $locale['mon_decimal_point'], $flags['nogroup'] ? '' : $locale['mon_thousands_sep'] );
$number = explode($locale['mon_decimal_point'], $number);
$n = strlen($prefix) + strlen($currency);
if ($left > 0 && $left > $n) {
if ($flags['isleft']) {
$number[0] .= str_repeat($flags['fillchar'], $left - $n);
} else {
$number[0] = str_repeat($flags['fillchar'], $left - $n) . $number[0];
}
}
$number = implode($locale['mon_decimal_point'], $number);
if ($locale["{$letter}_cs_precedes"]) {
$number = $prefix . $currency . $space . $number . $suffix;
} else {
$number = $prefix . $number . $space . $currency . $suffix;
}
if ($width > 0) {
$number = str_pad($number, $width, $flags['fillchar'], $flags['isleft'] ? STR_PAD_RIGHT : STR_PAD_LEFT);
}
$format = str_replace($fmatch[0], $number, $format);
return $format;
} // function money_format()
}
//
// Strangely, PHP doesn't have a mb_str_replace multibyte function
// As we'll only ever use this function with UTF-8 characters, we can simply "hard-code" the character set
//
if ((!function_exists('mb_str_replace')) &&
(function_exists('mb_substr')) && (function_exists('mb_strlen')) && (function_exists('mb_strpos'))) {
function mb_str_replace($search, $replace, $subject) {
if(is_array($subject)) {
$ret = array();
foreach($subject as $key => $val) {
$ret[$key] = mb_str_replace($search, $replace, $val);
}
return $ret;
}
foreach((array) $search as $key => $s) {
if($s == '') {
continue;
}
$r = !is_array($replace) ? $replace : (array_key_exists($key, $replace) ? $replace[$key] : '');
$pos = mb_strpos($subject, $s, 0, 'UTF-8');
while($pos !== false) {
$subject = mb_substr($subject, 0, $pos, 'UTF-8') . $r . mb_substr($subject, $pos + mb_strlen($s, 'UTF-8'), 65535, 'UTF-8');
$pos = mb_strpos($subject, $s, $pos + mb_strlen($r, 'UTF-8'), 'UTF-8');
}
}
return $subject;
}
}

Source for file Functions.php