Collaboration diagram for PHPExcel_Calculation_MathTrig:

Static Public Member Functions
static	ATAN2 ($xCoordinate=NULL, $yCoordinate=NULL)

static	CEILING ($number, $significance=NULL)

static	COMBIN ($numObjs, $numInSet)

static	EVEN ($number)

static	FACT ($factVal)

static	FACTDOUBLE ($factVal)

static	FLOOR ($number, $significance=NULL)

static	GCD ()

static	INT ($number)

static	LCM ()

static	LOG_BASE ($number=NULL, $base=10)

static	MDETERM ($matrixValues)

static	MINVERSE ($matrixValues)

static	MMULT ($matrixData1, $matrixData2)
	MMULT. More...

static	MOD ($a=1, $b=1)
	MOD. More...

static	MROUND ($number, $multiple)
	MROUND. More...

static	MULTINOMIAL ()
	MULTINOMIAL. More...

static	ODD ($number)
	ODD. More...

static	POWER ($x=0, $y=2)
	POWER. More...

static	PRODUCT ()

static	QUOTIENT ()

static	RAND ($min=0, $max=0)
	RAND. More...

static	ROMAN ($aValue, $style=0)

static	ROUNDUP ($number, $digits)
	ROUNDUP. More...

static	ROUNDDOWN ($number, $digits)
	ROUNDDOWN. More...

static	SERIESSUM ()
	SERIESSUM. More...

static	SIGN ($number)
	SIGN. More...

static	SQRTPI ($number)
	SQRTPI. More...

static	SUBTOTAL ()
	SUBTOTAL. More...

static	SUM ()

static	SUMIF ($aArgs, $condition, $sumArgs=array())

static	SUMPRODUCT ()

static	SUMSQ ()

static	SUMX2MY2 ($matrixData1, $matrixData2)
	SUMX2MY2. More...

static	SUMX2PY2 ($matrixData1, $matrixData2)
	SUMX2PY2. More...

static	SUMXMY2 ($matrixData1, $matrixData2)
	SUMXMY2. More...

static	TRUNC ($value=0, $digits=0)
	TRUNC. More...

Static Private Member Functions
static	_factors ($value)

static	_romanCut ($num, $n)

Detailed Description

Definition at line 46 of file MathTrig.php.

Member Function Documentation

◆ _factors()

static PHPExcel_Calculation_MathTrig::_factors ( $value )

staticprivate

Definition at line 51 of file MathTrig.php.

References $i, and array.

                                                  {
                 $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()

◆ _romanCut()

static PHPExcel_Calculation_MathTrig::_romanCut	(	$num,
		$n
	)

staticprivate

Definition at line 73 of file MathTrig.php.

References $n.

                                                     {
                 return ($num - ($num % $n ) ) / $n;
         }       //      function _romanCut()

◆ ATAN2()

static PHPExcel_Calculation_MathTrig::ATAN2	(	$xCoordinate = `NULL`,
		$yCoordinate = `NULL`
	)

static

Definition at line 100 of file MathTrig.php.

References PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\flattenSingleValue(), and PHPExcel_Calculation_Functions\VALUE().

                                                                                {
                 $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()

Here is the call graph for this function:

◆ CEILING()

static PHPExcel_Calculation_MathTrig::CEILING	(	$number,
		$significance = `NULL`
	)

static

Definition at line 139 of file MathTrig.php.

References PHPExcel_Calculation_Functions\COMPATIBILITY_GNUMERIC, PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\getCompatibilityMode(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

                                                                       {
                 $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 (($number == 0.0 ) || ($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()

Here is the call graph for this function:

◆ COMBIN()

static PHPExcel_Calculation_MathTrig::COMBIN	(	$numObjs,
		$numInSet
	)

static

Definition at line 176 of file MathTrig.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

Referenced by PHPExcel_Calculation_Statistical\BINOMDIST(), PHPExcel_Calculation_Statistical\HYPGEOMDIST(), and PHPExcel_Calculation_Statistical\NEGBINOMDIST().

                                                            {
                 $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()

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EVEN()

static PHPExcel_Calculation_MathTrig::EVEN ( $number )

static

Definition at line 209 of file MathTrig.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), and PHPExcel_Calculation_Functions\VALUE().

                                              {
                 $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()

Here is the call graph for this function:

◆ FACT()

static PHPExcel_Calculation_MathTrig::FACT ( $factVal )

static

Definition at line 240 of file MathTrig.php.

References PHPExcel_Calculation_Functions\COMPATIBILITY_GNUMERIC, PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\getCompatibilityMode(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

Referenced by PHPExcel_Calculation_Engineering\BESSELI(), PHPExcel_Calculation_Engineering\BESSELJ(), PHPExcel_Calculation_Statistical\PERMUT(), and PHPExcel_Calculation_Statistical\POISSON().

                                               {
                 $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()

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FACTDOUBLE()

static PHPExcel_Calculation_MathTrig::FACTDOUBLE ( $factVal )

static

Definition at line 277 of file MathTrig.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

                                                     {
                 $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()

Here is the call graph for this function:

◆ FLOOR()

static PHPExcel_Calculation_MathTrig::FLOOR	(	$number,
		$significance = `NULL`
	)

static

Definition at line 310 of file MathTrig.php.

References PHPExcel_Calculation_Functions\COMPATIBILITY_GNUMERIC, PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\getCompatibilityMode(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

                                                                     {
                 $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 PHPExcel_Calculation_Functions::DIV0();
             } elseif ($number == 0.0) {
                                 return 0.0;
                         } elseif (self::SIGN($number) == self::SIGN($significance)) {
                                 return floor($number / $significance) * $significance;
                         } else {
                                 return PHPExcel_Calculation_Functions::NaN();
                         }
                 } else
 
                 return PHPExcel_Calculation_Functions::VALUE();
         }       //      function FLOOR()

Here is the call graph for this function:

◆ GCD()

static PHPExcel_Calculation_MathTrig::GCD ( )

static

Definition at line 349 of file MathTrig.php.

References $i, $key, $keys, array, PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

Referenced by PHPExcel_Style_NumberFormat\_formatAsFraction().

                                      {
                 $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()

Here is the call graph for this function:

Here is the caller graph for this function:

◆ INT()

static PHPExcel_Calculation_MathTrig::INT ( $number )

static

Definition at line 423 of file MathTrig.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), and PHPExcel_Calculation_Functions\VALUE().

                                             {
                 $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()

Here is the call graph for this function:

◆ LCM()

static PHPExcel_Calculation_MathTrig::LCM ( )

static

Definition at line 454 of file MathTrig.php.

References array, PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

                                      {
                 $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()

Here is the call graph for this function:

◆ LOG_BASE()

static PHPExcel_Calculation_MathTrig::LOG_BASE	(	$number = `NULL`,
		$base = `10`
	)

static

Definition at line 504 of file MathTrig.php.

References $base, PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

                                                                     {
                 $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()

Here is the call graph for this function:

◆ MDETERM()

static PHPExcel_Calculation_MathTrig::MDETERM ( $matrixValues )

static

Definition at line 529 of file MathTrig.php.

References $column, $row, array, and PHPExcel_Calculation_Functions\VALUE().

                                                       {
                 $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()

Here is the call graph for this function:

◆ MINVERSE()

static PHPExcel_Calculation_MathTrig::MINVERSE ( $matrixValues )

static

Definition at line 571 of file MathTrig.php.

References $column, $row, array, and PHPExcel_Calculation_Functions\VALUE().

                                                        {
                 $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()

Here is the call graph for this function:

◆ MMULT()

static PHPExcel_Calculation_MathTrig::MMULT	(	$matrixData1,
		$matrixData2
	)

static

MMULT.

Parameters

array	$matrixData1	A matrix of values
array	$matrixData2	A matrix of values

Returns: array

Definition at line 607 of file MathTrig.php.

References array, and PHPExcel_Calculation_Functions\VALUE().

                                                                 {
                 $matrixAData = $matrixBData = array();
                 if (!is_array($matrixData1)) { $matrixData1 = array(array($matrixData1)); }
                 if (!is_array($matrixData2)) { $matrixData2 = array(array($matrixData2)); }
 
                 try {
             $rowA = 0;
             foreach($matrixData1 as $matrixRow) {
                 if (!is_array($matrixRow)) { $matrixRow = array($matrixRow); }
                 $columnA = 0;
                 foreach($matrixRow as $matrixCell) {
                     if ((!is_numeric($matrixCell)) || ($matrixCell === null)) {
                         return PHPExcel_Calculation_Functions::VALUE();
                     }
                     $matrixAData[$rowA][$columnA] = $matrixCell;
                     ++$columnA;
                 }
                 ++$rowA;
             }
                         $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_numeric($matrixCell)) || ($matrixCell === null)) {
                                                 return PHPExcel_Calculation_Functions::VALUE();
                                         }
                                         $matrixBData[$rowB][$columnB] = $matrixCell;
                                         ++$columnB;
                                 }
                                 ++$rowB;
                         }
                         $matrixB = new PHPExcel_Shared_JAMA_Matrix($matrixBData);
 
                         if ($columnA != $rowB) {
                                 return PHPExcel_Calculation_Functions::VALUE();
                         }
 
                         return $matrixA->times($matrixB)->getArray();
                 } catch (PHPExcel_Exception $ex) {
             var_dump($ex->getMessage());
                         return PHPExcel_Calculation_Functions::VALUE();
                 }
         }       //      function MMULT()

Here is the call graph for this function:

◆ MOD()

static PHPExcel_Calculation_MathTrig::MOD	(	$a = `1`,
		$b = `1`
	)

static

MOD.

Parameters

int	$a	Dividend
int	$b	Divisor

Returns: int Remainder

Definition at line 661 of file MathTrig.php.

References PHPExcel_Calculation_Functions\DIV0(), and PHPExcel_Calculation_Functions\flattenSingleValue().

                                                    {
                 $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()

Here is the call graph for this function:

◆ MROUND()

static PHPExcel_Calculation_MathTrig::MROUND	(	$number,
		$multiple
	)

static

MROUND.

Rounds a number to the nearest multiple of a specified value

Parameters

float	$number	Number to round
int	$multiple	Multiple to which you want to round $number

Returns: float Rounded Number

Definition at line 686 of file MathTrig.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

Referenced by PHPExcel_Calculation_TextData\DOLLAR().

                                                          {
                 $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()

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MULTINOMIAL()

static PHPExcel_Calculation_MathTrig::MULTINOMIAL ( )

static

MULTINOMIAL.

Returns the ratio of the factorial of a sum of values to the product of factorials.

Parameters

array of mixed Data Series

Returns: float

Definition at line 712 of file MathTrig.php.

References PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

                                              {
                 $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()

Here is the call graph for this function:

◆ ODD()

static PHPExcel_Calculation_MathTrig::ODD ( $number )

static

ODD.

Returns number rounded up to the nearest odd integer.

Parameters

float $number Number to round

Returns: int Rounded Number

Definition at line 746 of file MathTrig.php.

References $result, PHPExcel_Calculation_Functions\flattenSingleValue(), and PHPExcel_Calculation_Functions\VALUE().

                                             {
                 $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()

Here is the call graph for this function:

◆ POWER()

static PHPExcel_Calculation_MathTrig::POWER	(	$x = `0`,
		$y = `2`
	)

static

POWER.

Computes x raised to the power y.

Parameters

float	$x
float	$y

Returns: float

Definition at line 781 of file MathTrig.php.

References $result, $x, $y, PHPExcel_Calculation_Functions\DIV0(), PHPExcel_Calculation_Functions\flattenSingleValue(), and PHPExcel_Calculation_Functions\NaN().

                                                      {
                 $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()

Here is the call graph for this function:

◆ PRODUCT()

static PHPExcel_Calculation_MathTrig::PRODUCT ( )

static

Definition at line 811 of file MathTrig.php.

References PHPExcel_Calculation_Functions\flattenArray().

Referenced by PHPExcel_Calculation_Database\DPRODUCT(), and PHPExcel_Calculation_Statistical\GEOMEAN().

                                          {
                 // 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()

Here is the call graph for this function:

Here is the caller graph for this function:

◆ QUOTIENT()

static PHPExcel_Calculation_MathTrig::QUOTIENT ( )

static

Definition at line 849 of file MathTrig.php.

References PHPExcel_Calculation_Functions\flattenArray().

                                           {
                 // 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()

Here is the call graph for this function:

◆ RAND()

static PHPExcel_Calculation_MathTrig::RAND	(	$min = `0`,
		$max = `0`
	)

static

RAND.

Parameters

int	$min	Minimal value
int	$max	Maximal value

Returns: int Random number

Definition at line 881 of file MathTrig.php.

References PHPExcel_Calculation_Functions\flattenSingleValue().

                                                         {
                 $min            = PHPExcel_Calculation_Functions::flattenSingleValue($min);
                 $max            = PHPExcel_Calculation_Functions::flattenSingleValue($max);
 
                 if ($min == 0 && $max == 0) {
                         return (mt_rand(0,10000000)) / 10000000;
                 } else {
                         return mt_rand($min, $max);
                 }
         }       //      function RAND()

Here is the call graph for this function:

◆ ROMAN()

static PHPExcel_Calculation_MathTrig::ROMAN	(	$aValue,
		$style = `0`
	)

static

Definition at line 893 of file MathTrig.php.

References $m, $style, $t, PHPExcel_Calculation_Functions\flattenSingleValue(), and PHPExcel_Calculation_Functions\VALUE().

                                                         {
                 $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()

Here is the call graph for this function:

◆ ROUNDDOWN()

static PHPExcel_Calculation_MathTrig::ROUNDDOWN	(	$number,
		$digits
	)

static

ROUNDDOWN.

Rounds a number down to a specified number of decimal places

Parameters

float	$number	Number to round
int	$digits	Number of digits to which you want to round $number

Returns: float Rounded Number

Definition at line 956 of file MathTrig.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), and PHPExcel_Calculation_Functions\VALUE().

                                                           {
                 $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()

Here is the call graph for this function:

◆ ROUNDUP()

static PHPExcel_Calculation_MathTrig::ROUNDUP	(	$number,
		$digits
	)

static

ROUNDUP.

Rounds a number up to a specified number of decimal places

Parameters

float	$number	Number to round
int	$digits	Number of digits to which you want to round $number

Returns: float Rounded Number

Definition at line 931 of file MathTrig.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), and PHPExcel_Calculation_Functions\VALUE().

                                                         {
                 $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()

Here is the call graph for this function:

◆ SERIESSUM()

static PHPExcel_Calculation_MathTrig::SERIESSUM ( )

static

SERIESSUM.

Returns the sum of a power series

Parameters

float	$x	Input value to the power series
float	$n	Initial power to which you want to raise $x
float	$m	Step by which to increase $n for each term in the series
	array	of mixed Data Series

Returns: float

Definition at line 983 of file MathTrig.php.

References $i, $m, $n, $x, PHPExcel_Calculation_Functions\flattenArray(), and PHPExcel_Calculation_Functions\VALUE().

                                            {
                 // 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()

Here is the call graph for this function:

◆ SIGN()

static PHPExcel_Calculation_MathTrig::SIGN ( $number )

static

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.

Parameters

float $number Number to round

Returns: int sign value

Definition at line 1021 of file MathTrig.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), and PHPExcel_Calculation_Functions\VALUE().

                                              {
                 $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()

Here is the call graph for this function:

◆ SQRTPI()

static PHPExcel_Calculation_MathTrig::SQRTPI ( $number )

static

SQRTPI.

Returns the square root of (number * pi).

Parameters

float $number Number

Returns: float Square Root of Number * Pi

Definition at line 1044 of file MathTrig.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

                                                {
                 $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()

Here is the call graph for this function:

◆ SUBTOTAL()

static PHPExcel_Calculation_MathTrig::SUBTOTAL ( )

static

SUBTOTAL.

Returns a subtotal in a list or database.

Parameters

int	the number 1 to 11 that specifies which function to use in calculating subtotals within a list.
array	of mixed Data Series

Returns: float

Definition at line 1067 of file MathTrig.php.

References PHPExcel_Calculation_Statistical\AVERAGE(), PHPExcel_Calculation_Statistical\COUNT(), PHPExcel_Calculation_Statistical\COUNTA(), PHPExcel_Calculation_Functions\flattenArray(), PHPExcel_Calculation_Statistical\MAX(), PHPExcel_Calculation_Statistical\MIN(), PHPExcel_Calculation_Statistical\STDEV(), PHPExcel_Calculation_Statistical\STDEVP(), PHPExcel_Calculation_Functions\VALUE(), PHPExcel_Calculation_Statistical\VARFunc(), and PHPExcel_Calculation_Statistical\VARP().

                                           {
                 $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()

Here is the call graph for this function:

◆ SUM()

static PHPExcel_Calculation_MathTrig::SUM ( )

static

Definition at line 1127 of file MathTrig.php.

References PHPExcel_Calculation_Functions\flattenArray().

Referenced by PHPExcel_Calculation_Database\DSUM().

                                      {
                 // 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()

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SUMIF()

static PHPExcel_Calculation_MathTrig::SUMIF	(	$aArgs,
		$condition,
		$sumArgs = `array()`
	)

static

Definition at line 1158 of file MathTrig.php.

References $key, PHPExcel_Calculation_Functions\_ifCondition(), PHPExcel_Calculation\_wrapResult(), PHPExcel_Calculation_Functions\flattenArray(), and PHPExcel_Calculation\getInstance().

                                                                            {
                 // 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()

Here is the call graph for this function:

◆ SUMPRODUCT()

static PHPExcel_Calculation_MathTrig::SUMPRODUCT ( )

static

Definition at line 1198 of file MathTrig.php.

References $i, PHPExcel_Calculation_Functions\flattenArray(), and PHPExcel_Calculation_Functions\VALUE().

                                             {
                 $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()

Here is the call graph for this function:

◆ SUMSQ()

static PHPExcel_Calculation_MathTrig::SUMSQ ( )

static

Definition at line 1242 of file MathTrig.php.

References PHPExcel_Calculation_Functions\flattenArray().

                                        {
                 // 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()

Here is the call graph for this function:

◆ SUMX2MY2()

static PHPExcel_Calculation_MathTrig::SUMX2MY2	(	$matrixData1,
		$matrixData2
	)

static

SUMX2MY2.

Parameters

mixed[]	$matrixData1 Matrix #1
mixed[]	$matrixData2 Matrix #2

Returns: float

Definition at line 1266 of file MathTrig.php.

References $i, $result, and PHPExcel_Calculation_Functions\flattenArray().

                                                                    {
                 $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()

Here is the call graph for this function:

◆ SUMX2PY2()

static PHPExcel_Calculation_MathTrig::SUMX2PY2	(	$matrixData1,
		$matrixData2
	)

static

SUMX2PY2.

Parameters

mixed[]	$matrixData1 Matrix #1
mixed[]	$matrixData2 Matrix #2

Returns: float

Definition at line 1296 of file MathTrig.php.

References $i, $result, and PHPExcel_Calculation_Functions\flattenArray().

                                                                    {
                 $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()

Here is the call graph for this function:

◆ SUMXMY2()

static PHPExcel_Calculation_MathTrig::SUMXMY2	(	$matrixData1,
		$matrixData2
	)

static

SUMXMY2.

Parameters

mixed[]	$matrixData1 Matrix #1
mixed[]	$matrixData2 Matrix #2

Returns: float

Definition at line 1326 of file MathTrig.php.

References $i, $result, and PHPExcel_Calculation_Functions\flattenArray().

                                                                   {
                 $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()

Here is the call graph for this function:

◆ TRUNC()

static PHPExcel_Calculation_MathTrig::TRUNC	(	$value = `0`,
		$digits = `0`
	)

static

TRUNC.

Truncates value to the number of fractional digits by number_digits.

Parameters

float	$value
int	$digits

Returns: float Truncated value

Definition at line 1358 of file MathTrig.php.

References PHPExcel_Calculation_Functions\flattenSingleValue(), and PHPExcel_Calculation_Functions\VALUE().

                                                               {
                 $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()

Here is the call graph for this function:

The documentation for this class was generated from the following file:

libs/composer/vendor/phpoffice/phpexcel/Classes/PHPExcel/Calculation/MathTrig.php

Static Public Member Functions

Static Private Member Functions

Detailed Description

Member Function Documentation

◆ _factors()

◆ _romanCut()

◆ ATAN2()

◆ CEILING()

◆ COMBIN()

◆ EVEN()

◆ FACT()

◆ FACTDOUBLE()

◆ FLOOR()

◆ GCD()

◆ INT()

◆ LCM()

◆ LOG_BASE()

◆ MDETERM()

◆ MINVERSE()

◆ MMULT()

◆ MOD()

◆ MROUND()

◆ MULTINOMIAL()

◆ ODD()

◆ POWER()

◆ PRODUCT()

◆ QUOTIENT()

◆ RAND()

◆ ROMAN()

◆ ROUNDDOWN()

◆ ROUNDUP()

◆ SERIESSUM()

◆ SIGN()

◆ SQRTPI()

◆ SUBTOTAL()

◆ SUM()

◆ SUMIF()

◆ SUMPRODUCT()

◆ SUMSQ()

◆ SUMX2MY2()

◆ SUMX2PY2()

◆ SUMXMY2()

◆ TRUNC()