1374 lines
38 KiB
PHP
1374 lines
38 KiB
PHP
<?php
|
|
/**
|
|
* PHPExcel
|
|
*
|
|
* Copyright (c) 2006 - 2014 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 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
|
|
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL
|
|
* @version ##VERSION##, ##DATE##
|
|
*/
|
|
|
|
|
|
/** PHPExcel root directory */
|
|
if (!defined('PHPEXCEL_ROOT')) {
|
|
/**
|
|
* @ignore
|
|
*/
|
|
define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
|
|
require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
|
|
}
|
|
|
|
|
|
/**
|
|
* PHPExcel_Calculation_MathTrig
|
|
*
|
|
* @category PHPExcel
|
|
* @package PHPExcel_Calculation
|
|
* @copyright Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
|
|
*/
|
|
class PHPExcel_Calculation_MathTrig {
|
|
|
|
//
|
|
// 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 (!empty($factorArray)) {
|
|
rsort($factorArray);
|
|
return $factorArray;
|
|
} else {
|
|
return array((integer) $value);
|
|
}
|
|
} // function _factors()
|
|
|
|
|
|
private static function _romanCut($num, $n) {
|
|
return ($num - ($num % $n ) ) / $n;
|
|
} // function _romanCut()
|
|
|
|
|
|
/**
|
|
* 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 ATAN2($xCoordinate = NULL, $yCoordinate = NULL) {
|
|
$xCoordinate = PHPExcel_Calculation_Functions::flattenSingleValue($xCoordinate);
|
|
$yCoordinate = PHPExcel_Calculation_Functions::flattenSingleValue($yCoordinate);
|
|
|
|
$xCoordinate = ($xCoordinate !== NULL) ? $xCoordinate : 0.0;
|
|
$yCoordinate = ($yCoordinate !== NULL) ? $yCoordinate : 0.0;
|
|
|
|
if (((is_numeric($xCoordinate)) || (is_bool($xCoordinate))) &&
|
|
((is_numeric($yCoordinate))) || (is_bool($yCoordinate))) {
|
|
$xCoordinate = (float) $xCoordinate;
|
|
$yCoordinate = (float) $yCoordinate;
|
|
|
|
if (($xCoordinate == 0) && ($yCoordinate == 0)) {
|
|
return PHPExcel_Calculation_Functions::DIV0();
|
|
}
|
|
|
|
return atan2($yCoordinate, $xCoordinate);
|
|
}
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
} // function ATAN2()
|
|
|
|
|
|
/**
|
|
* CEILING
|
|
*
|
|
* Returns number rounded up, away from zero, to the nearest multiple of significance.
|
|
* For example, if you want to avoid using pennies in your prices and your product is
|
|
* priced at $4.42, use the formula =CEILING(4.42,0.05) to round prices up to the
|
|
* nearest nickel.
|
|
*
|
|
* Excel Function:
|
|
* CEILING(number[,significance])
|
|
*
|
|
* @access public
|
|
* @category Mathematical and Trigonometric Functions
|
|
* @param float $number The number you want to round.
|
|
* @param float $significance The multiple to which you want to round.
|
|
* @return float Rounded Number
|
|
*/
|
|
public static function CEILING($number, $significance = NULL) {
|
|
$number = PHPExcel_Calculation_Functions::flattenSingleValue($number);
|
|
$significance = PHPExcel_Calculation_Functions::flattenSingleValue($significance);
|
|
|
|
if ((is_null($significance)) &&
|
|
(PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC)) {
|
|
$significance = $number/abs($number);
|
|
}
|
|
|
|
if ((is_numeric($number)) && (is_numeric($significance))) {
|
|
if ($significance == 0.0) {
|
|
return 0.0;
|
|
} elseif (self::SIGN($number) == self::SIGN($significance)) {
|
|
return ceil($number / $significance) * $significance;
|
|
} else {
|
|
return PHPExcel_Calculation_Functions::NaN();
|
|
}
|
|
}
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
} // function CEILING()
|
|
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* Excel Function:
|
|
* COMBIN(numObjs,numInSet)
|
|
*
|
|
* @access public
|
|
* @category Mathematical and Trigonometric Functions
|
|
* @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 = PHPExcel_Calculation_Functions::flattenSingleValue($numObjs);
|
|
$numInSet = PHPExcel_Calculation_Functions::flattenSingleValue($numInSet);
|
|
|
|
if ((is_numeric($numObjs)) && (is_numeric($numInSet))) {
|
|
if ($numObjs < $numInSet) {
|
|
return PHPExcel_Calculation_Functions::NaN();
|
|
} elseif ($numInSet < 0) {
|
|
return PHPExcel_Calculation_Functions::NaN();
|
|
}
|
|
return round(self::FACT($numObjs) / self::FACT($numObjs - $numInSet)) / self::FACT($numInSet);
|
|
}
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
} // function COMBIN()
|
|
|
|
|
|
/**
|
|
* EVEN
|
|
*
|
|
* Returns number rounded up to the nearest even integer.
|
|
* You can use this function for processing items that come in twos. For example,
|
|
* a packing crate accepts rows of one or two items. The crate is full when
|
|
* the number of items, rounded up to the nearest two, matches the crate's
|
|
* capacity.
|
|
*
|
|
* Excel Function:
|
|
* EVEN(number)
|
|
*
|
|
* @access public
|
|
* @category Mathematical and Trigonometric Functions
|
|
* @param float $number Number to round
|
|
* @return int Rounded Number
|
|
*/
|
|
public static function EVEN($number) {
|
|
$number = PHPExcel_Calculation_Functions::flattenSingleValue($number);
|
|
|
|
if (is_null($number)) {
|
|
return 0;
|
|
} elseif (is_bool($number)) {
|
|
$number = (int) $number;
|
|
}
|
|
|
|
if (is_numeric($number)) {
|
|
$significance = 2 * self::SIGN($number);
|
|
return (int) self::CEILING($number,$significance);
|
|
}
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
} // function EVEN()
|
|
|
|
|
|
/**
|
|
* FACT
|
|
*
|
|
* Returns the factorial of a number.
|
|
* The factorial of a number is equal to 1*2*3*...* number.
|
|
*
|
|
* Excel Function:
|
|
* FACT(factVal)
|
|
*
|
|
* @access public
|
|
* @category Mathematical and Trigonometric Functions
|
|
* @param float $factVal Factorial Value
|
|
* @return int Factorial
|
|
*/
|
|
public static function FACT($factVal) {
|
|
$factVal = PHPExcel_Calculation_Functions::flattenSingleValue($factVal);
|
|
|
|
if (is_numeric($factVal)) {
|
|
if ($factVal < 0) {
|
|
return PHPExcel_Calculation_Functions::NaN();
|
|
}
|
|
$factLoop = floor($factVal);
|
|
if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
|
|
if ($factVal > $factLoop) {
|
|
return PHPExcel_Calculation_Functions::NaN();
|
|
}
|
|
}
|
|
|
|
$factorial = 1;
|
|
while ($factLoop > 1) {
|
|
$factorial *= $factLoop--;
|
|
}
|
|
return $factorial ;
|
|
}
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
} // function FACT()
|
|
|
|
|
|
/**
|
|
* FACTDOUBLE
|
|
*
|
|
* Returns the double factorial of a number.
|
|
*
|
|
* Excel Function:
|
|
* FACTDOUBLE(factVal)
|
|
*
|
|
* @access public
|
|
* @category Mathematical and Trigonometric Functions
|
|
* @param float $factVal Factorial Value
|
|
* @return int Double Factorial
|
|
*/
|
|
public static function FACTDOUBLE($factVal) {
|
|
$factLoop = PHPExcel_Calculation_Functions::flattenSingleValue($factVal);
|
|
|
|
if (is_numeric($factLoop)) {
|
|
$factLoop = floor($factLoop);
|
|
if ($factVal < 0) {
|
|
return PHPExcel_Calculation_Functions::NaN();
|
|
}
|
|
$factorial = 1;
|
|
while ($factLoop > 1) {
|
|
$factorial *= $factLoop--;
|
|
--$factLoop;
|
|
}
|
|
return $factorial ;
|
|
}
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
} // function FACTDOUBLE()
|
|
|
|
|
|
/**
|
|
* FLOOR
|
|
*
|
|
* Rounds number down, toward zero, to the nearest multiple of significance.
|
|
*
|
|
* Excel Function:
|
|
* FLOOR(number[,significance])
|
|
*
|
|
* @access public
|
|
* @category Mathematical and Trigonometric Functions
|
|
* @param float $number Number to round
|
|
* @param float $significance Significance
|
|
* @return float Rounded Number
|
|
*/
|
|
public static function FLOOR($number, $significance = NULL) {
|
|
$number = PHPExcel_Calculation_Functions::flattenSingleValue($number);
|
|
$significance = PHPExcel_Calculation_Functions::flattenSingleValue($significance);
|
|
|
|
if ((is_null($significance)) && (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC)) {
|
|
$significance = $number/abs($number);
|
|
}
|
|
|
|
if ((is_numeric($number)) && (is_numeric($significance))) {
|
|
if ((float) $significance == 0.0) {
|
|
return PHPExcel_Calculation_Functions::DIV0();
|
|
}
|
|
if (self::SIGN($number) == self::SIGN($significance)) {
|
|
return floor($number / $significance) * $significance;
|
|
} else {
|
|
return PHPExcel_Calculation_Functions::NaN();
|
|
}
|
|
}
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
} // function FLOOR()
|
|
|
|
|
|
/**
|
|
* GCD
|
|
*
|
|
* Returns the greatest common divisor of a series of numbers.
|
|
* The greatest common divisor is the largest integer that divides both
|
|
* number1 and number2 without a remainder.
|
|
*
|
|
* Excel Function:
|
|
* GCD(number1[,number2[, ...]])
|
|
*
|
|
* @access public
|
|
* @category Mathematical and Trigonometric Functions
|
|
* @param mixed $arg,... Data values
|
|
* @return integer Greatest Common Divisor
|
|
*/
|
|
public static function GCD() {
|
|
$returnValue = 1;
|
|
$allValuesFactors = array();
|
|
// Loop through arguments
|
|
foreach(PHPExcel_Calculation_Functions::flattenArray(func_get_args()) as $value) {
|
|
if (!is_numeric($value)) {
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
} elseif ($value == 0) {
|
|
continue;
|
|
} elseif($value < 0) {
|
|
return PHPExcel_Calculation_Functions::NaN();
|
|
}
|
|
$myFactors = self::_factors($value);
|
|
$myCountedFactors = array_count_values($myFactors);
|
|
$allValuesFactors[] = $myCountedFactors;
|
|
}
|
|
$allValuesCount = count($allValuesFactors);
|
|
if ($allValuesCount == 0) {
|
|
return 0;
|
|
}
|
|
|
|
$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()
|
|
|
|
|
|
/**
|
|
* INT
|
|
*
|
|
* Casts a floating point value to an integer
|
|
*
|
|
* Excel Function:
|
|
* INT(number)
|
|
*
|
|
* @access public
|
|
* @category Mathematical and Trigonometric Functions
|
|
* @param float $number Number to cast to an integer
|
|
* @return integer Integer value
|
|
*/
|
|
public static function INT($number) {
|
|
$number = PHPExcel_Calculation_Functions::flattenSingleValue($number);
|
|
|
|
if (is_null($number)) {
|
|
return 0;
|
|
} elseif (is_bool($number)) {
|
|
return (int) $number;
|
|
}
|
|
if (is_numeric($number)) {
|
|
return (int) floor($number);
|
|
}
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
} // function INT()
|
|
|
|
|
|
/**
|
|
* LCM
|
|
*
|
|
* Returns the lowest common multiplier of a series of numbers
|
|
* The least common multiple is the smallest positive integer that is a multiple
|
|
* of all integer arguments number1, number2, and so on. Use LCM to add fractions
|
|
* with different denominators.
|
|
*
|
|
* Excel Function:
|
|
* LCM(number1[,number2[, ...]])
|
|
*
|
|
* @access public
|
|
* @category Mathematical and Trigonometric Functions
|
|
* @param mixed $arg,... Data values
|
|
* @return int Lowest Common Multiplier
|
|
*/
|
|
public static function LCM() {
|
|
$returnValue = 1;
|
|
$allPoweredFactors = array();
|
|
// Loop through arguments
|
|
foreach(PHPExcel_Calculation_Functions::flattenArray(func_get_args()) as $value) {
|
|
if (!is_numeric($value)) {
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
}
|
|
if ($value == 0) {
|
|
return 0;
|
|
} elseif ($value < 0) {
|
|
return PHPExcel_Calculation_Functions::NaN();
|
|
}
|
|
$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()
|
|
|
|
|
|
/**
|
|
* 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 $number 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 = NULL, $base = 10) {
|
|
$number = PHPExcel_Calculation_Functions::flattenSingleValue($number);
|
|
$base = (is_null($base)) ? 10 : (float) PHPExcel_Calculation_Functions::flattenSingleValue($base);
|
|
|
|
if ((!is_numeric($base)) || (!is_numeric($number)))
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
if (($base <= 0) || ($number <= 0))
|
|
return PHPExcel_Calculation_Functions::NaN();
|
|
return log($number, $base);
|
|
} // function LOG_BASE()
|
|
|
|
|
|
/**
|
|
* MDETERM
|
|
*
|
|
* Returns the matrix determinant of an array.
|
|
*
|
|
* Excel Function:
|
|
* MDETERM(array)
|
|
*
|
|
* @access public
|
|
* @category Mathematical and Trigonometric Functions
|
|
* @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) {
|
|
if (!is_array($matrixRow)) { $matrixRow = array($matrixRow); }
|
|
$column = 0;
|
|
foreach($matrixRow as $matrixCell) {
|
|
if ((is_string($matrixCell)) || ($matrixCell === null)) {
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
}
|
|
$matrixData[$column][$row] = $matrixCell;
|
|
++$column;
|
|
}
|
|
if ($column > $maxColumn) { $maxColumn = $column; }
|
|
++$row;
|
|
}
|
|
if ($row != $maxColumn) { return PHPExcel_Calculation_Functions::VALUE(); }
|
|
|
|
try {
|
|
$matrix = new PHPExcel_Shared_JAMA_Matrix($matrixData);
|
|
return $matrix->det();
|
|
} catch (PHPExcel_Exception $ex) {
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
}
|
|
} // function MDETERM()
|
|
|
|
|
|
/**
|
|
* MINVERSE
|
|
*
|
|
* Returns the inverse matrix for the matrix stored in an array.
|
|
*
|
|
* Excel Function:
|
|
* MINVERSE(array)
|
|
*
|
|
* @access public
|
|
* @category Mathematical and Trigonometric Functions
|
|
* @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) {
|
|
if (!is_array($matrixRow)) { $matrixRow = array($matrixRow); }
|
|
$column = 0;
|
|
foreach($matrixRow as $matrixCell) {
|
|
if ((is_string($matrixCell)) || ($matrixCell === null)) {
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
}
|
|
$matrixData[$column][$row] = $matrixCell;
|
|
++$column;
|
|
}
|
|
if ($column > $maxColumn) { $maxColumn = $column; }
|
|
++$row;
|
|
}
|
|
if ($row != $maxColumn) { return PHPExcel_Calculation_Functions::VALUE(); }
|
|
|
|
try {
|
|
$matrix = new PHPExcel_Shared_JAMA_Matrix($matrixData);
|
|
return $matrix->inverse()->getArray();
|
|
} catch (PHPExcel_Exception $ex) {
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
}
|
|
} // function MINVERSE()
|
|
|
|
|
|
/**
|
|
* 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) {
|
|
if (!is_array($matrixRow)) { $matrixRow = array($matrixRow); }
|
|
$columnA = 0;
|
|
foreach($matrixRow as $matrixCell) {
|
|
if ((is_string($matrixCell)) || ($matrixCell === null)) {
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
}
|
|
$matrixAData[$rowA][$columnA] = $matrixCell;
|
|
++$columnA;
|
|
}
|
|
++$rowA;
|
|
}
|
|
try {
|
|
$matrixA = new PHPExcel_Shared_JAMA_Matrix($matrixAData);
|
|
$rowB = 0;
|
|
foreach($matrixData2 as $matrixRow) {
|
|
if (!is_array($matrixRow)) { $matrixRow = array($matrixRow); }
|
|
$columnB = 0;
|
|
foreach($matrixRow as $matrixCell) {
|
|
if ((is_string($matrixCell)) || ($matrixCell === null)) {
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
}
|
|
$matrixBData[$rowB][$columnB] = $matrixCell;
|
|
++$columnB;
|
|
}
|
|
++$rowB;
|
|
}
|
|
$matrixB = new PHPExcel_Shared_JAMA_Matrix($matrixBData);
|
|
|
|
if (($rowA != $columnB) || ($rowB != $columnA)) {
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
}
|
|
|
|
return $matrixA->times($matrixB)->getArray();
|
|
} catch (PHPExcel_Exception $ex) {
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
}
|
|
} // function MMULT()
|
|
|
|
|
|
/**
|
|
* MOD
|
|
*
|
|
* @param int $a Dividend
|
|
* @param int $b Divisor
|
|
* @return int Remainder
|
|
*/
|
|
public static function MOD($a = 1, $b = 1) {
|
|
$a = PHPExcel_Calculation_Functions::flattenSingleValue($a);
|
|
$b = PHPExcel_Calculation_Functions::flattenSingleValue($b);
|
|
|
|
if ($b == 0.0) {
|
|
return PHPExcel_Calculation_Functions::DIV0();
|
|
} 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()
|
|
|
|
|
|
/**
|
|
* 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 = PHPExcel_Calculation_Functions::flattenSingleValue($number);
|
|
$multiple = PHPExcel_Calculation_Functions::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 PHPExcel_Calculation_Functions::NaN();
|
|
}
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
} // function MROUND()
|
|
|
|
|
|
/**
|
|
* 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() {
|
|
$summer = 0;
|
|
$divisor = 1;
|
|
// Loop through arguments
|
|
foreach (PHPExcel_Calculation_Functions::flattenArray(func_get_args()) as $arg) {
|
|
// Is it a numeric value?
|
|
if (is_numeric($arg)) {
|
|
if ($arg < 1) {
|
|
return PHPExcel_Calculation_Functions::NaN();
|
|
}
|
|
$summer += floor($arg);
|
|
$divisor *= self::FACT($arg);
|
|
} else {
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
}
|
|
}
|
|
|
|
// Return
|
|
if ($summer > 0) {
|
|
$summer = self::FACT($summer);
|
|
return $summer / $divisor;
|
|
}
|
|
return 0;
|
|
} // function MULTINOMIAL()
|
|
|
|
|
|
/**
|
|
* 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 = PHPExcel_Calculation_Functions::flattenSingleValue($number);
|
|
|
|
if (is_null($number)) {
|
|
return 1;
|
|
} elseif (is_bool($number)) {
|
|
$number = (int) $number;
|
|
}
|
|
|
|
if (is_numeric($number)) {
|
|
$significance = self::SIGN($number);
|
|
if ($significance == 0) {
|
|
return 1;
|
|
}
|
|
|
|
$result = self::CEILING($number,$significance);
|
|
if ($result == self::EVEN($result)) {
|
|
$result += $significance;
|
|
}
|
|
|
|
return (int) $result;
|
|
}
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
} // function ODD()
|
|
|
|
|
|
/**
|
|
* 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 = PHPExcel_Calculation_Functions::flattenSingleValue($x);
|
|
$y = PHPExcel_Calculation_Functions::flattenSingleValue($y);
|
|
|
|
// Validate parameters
|
|
if ($x == 0.0 && $y == 0.0) {
|
|
return PHPExcel_Calculation_Functions::NaN();
|
|
} elseif ($x == 0.0 && $y < 0.0) {
|
|
return PHPExcel_Calculation_Functions::DIV0();
|
|
}
|
|
|
|
// Return
|
|
$result = pow($x, $y);
|
|
return (!is_nan($result) && !is_infinite($result)) ? $result : PHPExcel_Calculation_Functions::NaN();
|
|
} // function POWER()
|
|
|
|
|
|
/**
|
|
* 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
|
|
foreach (PHPExcel_Calculation_Functions::flattenArray(func_get_args()) 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
|
|
foreach (PHPExcel_Calculation_Functions::flattenArray(func_get_args()) 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()
|
|
|
|
|
|
/**
|
|
* RAND
|
|
*
|
|
* @param int $min Minimal value
|
|
* @param int $max Maximal value
|
|
* @return int Random number
|
|
*/
|
|
public static function RAND($min = 0, $max = 0) {
|
|
$min = PHPExcel_Calculation_Functions::flattenSingleValue($min);
|
|
$max = PHPExcel_Calculation_Functions::flattenSingleValue($max);
|
|
|
|
if ($min == 0 && $max == 0) {
|
|
return (rand(0,10000000)) / 10000000;
|
|
} else {
|
|
return rand($min, $max);
|
|
}
|
|
} // function RAND()
|
|
|
|
|
|
public static function ROMAN($aValue, $style=0) {
|
|
$aValue = PHPExcel_Calculation_Functions::flattenSingleValue($aValue);
|
|
$style = (is_null($style)) ? 0 : (integer) PHPExcel_Calculation_Functions::flattenSingleValue($style);
|
|
if ((!is_numeric($aValue)) || ($aValue < 0) || ($aValue >= 4000)) {
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
}
|
|
$aValue = (integer) $aValue;
|
|
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()
|
|
|
|
|
|
/**
|
|
* 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 = PHPExcel_Calculation_Functions::flattenSingleValue($number);
|
|
$digits = PHPExcel_Calculation_Functions::flattenSingleValue($digits);
|
|
|
|
if ((is_numeric($number)) && (is_numeric($digits))) {
|
|
$significance = pow(10,(int) $digits);
|
|
if ($number < 0.0) {
|
|
return floor($number * $significance) / $significance;
|
|
} else {
|
|
return ceil($number * $significance) / $significance;
|
|
}
|
|
}
|
|
return PHPExcel_Calculation_Functions::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 = PHPExcel_Calculation_Functions::flattenSingleValue($number);
|
|
$digits = PHPExcel_Calculation_Functions::flattenSingleValue($digits);
|
|
|
|
if ((is_numeric($number)) && (is_numeric($digits))) {
|
|
$significance = pow(10,(int) $digits);
|
|
if ($number < 0.0) {
|
|
return ceil($number * $significance) / $significance;
|
|
} else {
|
|
return floor($number * $significance) / $significance;
|
|
}
|
|
}
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
} // function ROUNDDOWN()
|
|
|
|
|
|
/**
|
|
* 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 = PHPExcel_Calculation_Functions::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 PHPExcel_Calculation_Functions::VALUE();
|
|
}
|
|
}
|
|
// Return
|
|
return $returnValue;
|
|
}
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
} // function SERIESSUM()
|
|
|
|
|
|
/**
|
|
* 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 = PHPExcel_Calculation_Functions::flattenSingleValue($number);
|
|
|
|
if (is_bool($number))
|
|
return (int) $number;
|
|
if (is_numeric($number)) {
|
|
if ($number == 0.0) {
|
|
return 0;
|
|
}
|
|
return $number / abs($number);
|
|
}
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
} // function SIGN()
|
|
|
|
|
|
/**
|
|
* 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 = PHPExcel_Calculation_Functions::flattenSingleValue($number);
|
|
|
|
if (is_numeric($number)) {
|
|
if ($number < 0) {
|
|
return PHPExcel_Calculation_Functions::NaN();
|
|
}
|
|
return sqrt($number * M_PI) ;
|
|
}
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
} // function SQRTPI()
|
|
|
|
|
|
/**
|
|
* 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 = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
|
|
|
|
// Calculate
|
|
$subtotal = array_shift($aArgs);
|
|
|
|
if ((is_numeric($subtotal)) && (!is_string($subtotal))) {
|
|
switch($subtotal) {
|
|
case 1 :
|
|
return PHPExcel_Calculation_Statistical::AVERAGE($aArgs);
|
|
break;
|
|
case 2 :
|
|
return PHPExcel_Calculation_Statistical::COUNT($aArgs);
|
|
break;
|
|
case 3 :
|
|
return PHPExcel_Calculation_Statistical::COUNTA($aArgs);
|
|
break;
|
|
case 4 :
|
|
return PHPExcel_Calculation_Statistical::MAX($aArgs);
|
|
break;
|
|
case 5 :
|
|
return PHPExcel_Calculation_Statistical::MIN($aArgs);
|
|
break;
|
|
case 6 :
|
|
return self::PRODUCT($aArgs);
|
|
break;
|
|
case 7 :
|
|
return PHPExcel_Calculation_Statistical::STDEV($aArgs);
|
|
break;
|
|
case 8 :
|
|
return PHPExcel_Calculation_Statistical::STDEVP($aArgs);
|
|
break;
|
|
case 9 :
|
|
return self::SUM($aArgs);
|
|
break;
|
|
case 10 :
|
|
return PHPExcel_Calculation_Statistical::VARFunc($aArgs);
|
|
break;
|
|
case 11 :
|
|
return PHPExcel_Calculation_Statistical::VARP($aArgs);
|
|
break;
|
|
}
|
|
}
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
} // function SUBTOTAL()
|
|
|
|
|
|
/**
|
|
* 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
|
|
foreach (PHPExcel_Calculation_Functions::flattenArray(func_get_args()) as $arg) {
|
|
// Is it a numeric value?
|
|
if ((is_numeric($arg)) && (!is_string($arg))) {
|
|
$returnValue += $arg;
|
|
}
|
|
}
|
|
|
|
// Return
|
|
return $returnValue;
|
|
} // function SUM()
|
|
|
|
|
|
/**
|
|
* 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 = PHPExcel_Calculation_Functions::flattenArray($aArgs);
|
|
$sumArgs = PHPExcel_Calculation_Functions::flattenArray($sumArgs);
|
|
if (empty($sumArgs)) {
|
|
$sumArgs = $aArgs;
|
|
}
|
|
$condition = PHPExcel_Calculation_Functions::_ifCondition($condition);
|
|
// Loop through arguments
|
|
foreach ($aArgs as $key => $arg) {
|
|
if (!is_numeric($arg)) {
|
|
$arg = str_replace('"', '""', $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()
|
|
|
|
|
|
/**
|
|
* SUMPRODUCT
|
|
*
|
|
* Excel Function:
|
|
* SUMPRODUCT(value1[,value2[, ...]])
|
|
*
|
|
* @access public
|
|
* @category Mathematical and Trigonometric Functions
|
|
* @param mixed $arg,... Data values
|
|
* @return float
|
|
*/
|
|
public static function SUMPRODUCT() {
|
|
$arrayList = func_get_args();
|
|
|
|
$wrkArray = PHPExcel_Calculation_Functions::flattenArray(array_shift($arrayList));
|
|
$wrkCellCount = count($wrkArray);
|
|
|
|
for ($i=0; $i< $wrkCellCount; ++$i) {
|
|
if ((!is_numeric($wrkArray[$i])) || (is_string($wrkArray[$i]))) {
|
|
$wrkArray[$i] = 0;
|
|
}
|
|
}
|
|
|
|
foreach($arrayList as $matrixData) {
|
|
$array2 = PHPExcel_Calculation_Functions::flattenArray($matrixData);
|
|
$count = count($array2);
|
|
if ($wrkCellCount != $count) {
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
}
|
|
|
|
foreach ($array2 as $i => $val) {
|
|
if ((!is_numeric($val)) || (is_string($val))) {
|
|
$val = 0;
|
|
}
|
|
$wrkArray[$i] *= $val;
|
|
}
|
|
}
|
|
|
|
return array_sum($wrkArray);
|
|
} // function SUMPRODUCT()
|
|
|
|
|
|
/**
|
|
* 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
|
|
foreach (PHPExcel_Calculation_Functions::flattenArray(func_get_args()) as $arg) {
|
|
// Is it a numeric value?
|
|
if ((is_numeric($arg)) && (!is_string($arg))) {
|
|
$returnValue += ($arg * $arg);
|
|
}
|
|
}
|
|
|
|
// Return
|
|
return $returnValue;
|
|
} // function SUMSQ()
|
|
|
|
|
|
/**
|
|
* SUMX2MY2
|
|
*
|
|
* @param mixed[] $matrixData1 Matrix #1
|
|
* @param mixed[] $matrixData2 Matrix #2
|
|
* @return float
|
|
*/
|
|
public static function SUMX2MY2($matrixData1,$matrixData2) {
|
|
$array1 = PHPExcel_Calculation_Functions::flattenArray($matrixData1);
|
|
$array2 = PHPExcel_Calculation_Functions::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[] $matrixData1 Matrix #1
|
|
* @param mixed[] $matrixData2 Matrix #2
|
|
* @return float
|
|
*/
|
|
public static function SUMX2PY2($matrixData1,$matrixData2) {
|
|
$array1 = PHPExcel_Calculation_Functions::flattenArray($matrixData1);
|
|
$array2 = PHPExcel_Calculation_Functions::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[] $matrixData1 Matrix #1
|
|
* @param mixed[] $matrixData2 Matrix #2
|
|
* @return float
|
|
*/
|
|
public static function SUMXMY2($matrixData1,$matrixData2) {
|
|
$array1 = PHPExcel_Calculation_Functions::flattenArray($matrixData1);
|
|
$array2 = PHPExcel_Calculation_Functions::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()
|
|
|
|
|
|
/**
|
|
* TRUNC
|
|
*
|
|
* Truncates value to the number of fractional digits by number_digits.
|
|
*
|
|
* @param float $value
|
|
* @param int $digits
|
|
* @return float Truncated value
|
|
*/
|
|
public static function TRUNC($value = 0, $digits = 0) {
|
|
$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
|
|
$digits = PHPExcel_Calculation_Functions::flattenSingleValue($digits);
|
|
|
|
// Validate parameters
|
|
if ((!is_numeric($value)) || (!is_numeric($digits)))
|
|
return PHPExcel_Calculation_Functions::VALUE();
|
|
$digits = floor($digits);
|
|
|
|
// Truncate
|
|
$adjust = pow(10, $digits);
|
|
|
|
if (($digits > 0) && (rtrim(intval((abs($value) - abs(intval($value))) * $adjust),'0') < $adjust/10))
|
|
return $value;
|
|
|
|
return (intval($value * $adjust)) / $adjust;
|
|
} // function TRUNC()
|
|
|
|
} // class PHPExcel_Calculation_MathTrig
|