Collaboration diagram for PHPExcel_Calculation_Engineering:

Static Public Member Functions
static	_parseComplex ($complexNumber)
	_parseComplex More...

static	BESSELI ($x, $ord)

static	BESSELJ ($x, $ord)

static	BESSELK ($x, $ord)

static	BESSELY ($x, $ord)

static	BINTODEC ($x)

static	BINTOHEX ($x, $places=NULL)

static	BINTOOCT ($x, $places=NULL)

static	DECTOBIN ($x, $places=NULL)

static	DECTOHEX ($x, $places=null)

static	DECTOOCT ($x, $places=null)

static	HEXTOBIN ($x, $places=null)

static	HEXTODEC ($x)

static	HEXTOOCT ($x, $places=null)

static	OCTTOBIN ($x, $places=null)

static	OCTTODEC ($x)

static	OCTTOHEX ($x, $places=null)

static	COMPLEX ($realNumber=0.0, $imaginary=0.0, $suffix='i')

static	IMAGINARY ($complexNumber)

static	IMREAL ($complexNumber)

static	IMABS ($complexNumber)
	IMABS. More...

static	IMARGUMENT ($complexNumber)
	IMARGUMENT. More...

static	IMCONJUGATE ($complexNumber)
	IMCONJUGATE. More...

static	IMCOS ($complexNumber)
	IMCOS. More...

static	IMSIN ($complexNumber)
	IMSIN. More...

static	IMSQRT ($complexNumber)
	IMSQRT. More...

static	IMLN ($complexNumber)
	IMLN. More...

static	IMLOG10 ($complexNumber)
	IMLOG10. More...

static	IMLOG2 ($complexNumber)
	IMLOG2. More...

static	IMEXP ($complexNumber)
	IMEXP. More...

static	IMPOWER ($complexNumber, $realNumber)
	IMPOWER. More...

static	IMDIV ($complexDividend, $complexDivisor)
	IMDIV. More...

static	IMSUB ($complexNumber1, $complexNumber2)
	IMSUB. More...

static	IMSUM ()
	IMSUM. More...

static	IMPRODUCT ()
	IMPRODUCT. More...

static	DELTA ($a, $b=0)
	DELTA. More...

static	GESTEP ($number, $step=0)
	GESTEP. More...

static	_erfVal ($x)

static	ERF ($lower, $upper=NULL)
	ERF. More...

static	ERFC ($x)
	ERFC. More...

static	getConversionGroups ()
	getConversionGroups Returns a list of the different conversion groups for UOM conversions More...

static	getConversionGroupUnits ($group=NULL)
	getConversionGroupUnits Returns an array of units of measure, for a specified conversion group, or for all groups More...

static	getConversionGroupUnitDetails ($group=NULL)
	getConversionGroupUnitDetails More...

static	getConversionMultipliers ()
	getConversionMultipliers Returns an array of the Multiplier prefixes that can be used with Units of Measure in CONVERTUOM() More...

static	CONVERTUOM ($value, $fromUOM, $toUOM)
	CONVERTUOM. More...

Static Private Member Functions
static	_cleanComplex ($complexNumber)
	Cleans the leading characters in a complex number string. More...

static	_nbrConversionFormat ($xVal, $places)
	Formats a number base string value with leading zeroes. More...

static	_Besselk0 ($fNum)

static	_Besselk1 ($fNum)

static	_Bessely0 ($fNum)

static	_Bessely1 ($fNum)

static	_erfcVal ($x)

Static Private Attributes
static	$_conversionUnits

static	$_conversionMultipliers

static	$_unitConversions

static	$_two_sqrtpi = 1.128379167095512574

static	$_one_sqrtpi = 0.564189583547756287

Detailed Description

Definition at line 50 of file Engineering.php.

Member Function Documentation

◆ _Besselk0()

static PHPExcel_Calculation_Engineering::_Besselk0 ( $fNum )

staticprivate

Definition at line 884 of file Engineering.php.

References $y.

                                                  {
                 if ($fNum <= 2) {
                         $fNum2 = $fNum * 0.5;
                         $y = ($fNum2 * $fNum2);
                         $fRet = -log($fNum2) * self::BESSELI($fNum, 0) +
                                         (-0.57721566 + $y * (0.42278420 + $y * (0.23069756 + $y * (0.3488590e-1 + $y * (0.262698e-2 + $y *
                                         (0.10750e-3 + $y * 0.74e-5))))));
                 } else {
                         $y = 2 / $fNum;
                         $fRet = exp(-$fNum) / sqrt($fNum) *
                                         (1.25331414 + $y * (-0.7832358e-1 + $y * (0.2189568e-1 + $y * (-0.1062446e-1 + $y *
                                         (0.587872e-2 + $y * (-0.251540e-2 + $y * 0.53208e-3))))));
                 }
                 return $fRet;
         }       //      function _Besselk0()

◆ _Besselk1()

static PHPExcel_Calculation_Engineering::_Besselk1 ( $fNum )

staticprivate

Definition at line 901 of file Engineering.php.

References $y.

                                                  {
                 if ($fNum <= 2) {
                         $fNum2 = $fNum * 0.5;
                         $y = ($fNum2 * $fNum2);
                         $fRet = log($fNum2) * self::BESSELI($fNum, 1) +
                                         (1 + $y * (0.15443144 + $y * (-0.67278579 + $y * (-0.18156897 + $y * (-0.1919402e-1 + $y *
                                         (-0.110404e-2 + $y * (-0.4686e-4))))))) / $fNum;
                 } else {
                         $y = 2 / $fNum;
                         $fRet = exp(-$fNum) / sqrt($fNum) *
                                         (1.25331414 + $y * (0.23498619 + $y * (-0.3655620e-1 + $y * (0.1504268e-1 + $y * (-0.780353e-2 + $y *
                                         (0.325614e-2 + $y * (-0.68245e-3)))))));
                 }
                 return $fRet;
         }       //      function _Besselk1()

◆ _Bessely0()

static PHPExcel_Calculation_Engineering::_Bessely0 ( $fNum )

staticprivate

Definition at line 966 of file Engineering.php.

References $y.

                                                  {
                 if ($fNum < 8.0) {
                         $y = ($fNum * $fNum);
                         $f1 = -2957821389.0 + $y * (7062834065.0 + $y * (-512359803.6 + $y * (10879881.29 + $y * (-86327.92757 + $y * 228.4622733))));
                         $f2 = 40076544269.0 + $y * (745249964.8 + $y * (7189466.438 + $y * (47447.26470 + $y * (226.1030244 + $y))));
                         $fRet = $f1 / $f2 + 0.636619772 * self::BESSELJ($fNum, 0) * log($fNum);
                 } else {
                         $z = 8.0 / $fNum;
                         $y = ($z * $z);
                         $xx = $fNum - 0.785398164;
                         $f1 = 1 + $y * (-0.1098628627e-2 + $y * (0.2734510407e-4 + $y * (-0.2073370639e-5 + $y * 0.2093887211e-6)));
                         $f2 = -0.1562499995e-1 + $y * (0.1430488765e-3 + $y * (-0.6911147651e-5 + $y * (0.7621095161e-6 + $y * (-0.934945152e-7))));
                         $fRet = sqrt(0.636619772 / $fNum) * (sin($xx) * $f1 + $z * cos($xx) * $f2);
                 }
                 return $fRet;
         }       //      function _Bessely0()

◆ _Bessely1()

static PHPExcel_Calculation_Engineering::_Bessely1 ( $fNum )

staticprivate

Definition at line 984 of file Engineering.php.

References $y.

                                                  {
                 if ($fNum < 8.0) {
                         $y = ($fNum * $fNum);
                         $f1 = $fNum * (-0.4900604943e13 + $y * (0.1275274390e13 + $y * (-0.5153438139e11 + $y * (0.7349264551e9 + $y *
                                 (-0.4237922726e7 + $y * 0.8511937935e4)))));
                         $f2 = 0.2499580570e14 + $y * (0.4244419664e12 + $y * (0.3733650367e10 + $y * (0.2245904002e8 + $y *
                                 (0.1020426050e6 + $y * (0.3549632885e3 + $y)))));
                         $fRet = $f1 / $f2 + 0.636619772 * ( self::BESSELJ($fNum, 1) * log($fNum) - 1 / $fNum);
                 } else {
                         $fRet = sqrt(0.636619772 / $fNum) * sin($fNum - 2.356194491);
                 }
                 return $fRet;
         }       //      function _Bessely1()

◆ _cleanComplex()

static PHPExcel_Calculation_Engineering::_cleanComplex ( $complexNumber )

staticprivate

Cleans the leading characters in a complex number string.

Parameters

string $complexNumber The complex number to clean

Returns: string The "cleaned" complex number

Definition at line 749 of file Engineering.php.

                                                               {
                 if ($complexNumber{0} == '+') $complexNumber = substr($complexNumber,1);
                 if ($complexNumber{0} == '0') $complexNumber = substr($complexNumber,1);
                 if ($complexNumber{0} == '.') $complexNumber = '0'.$complexNumber;
                 if ($complexNumber{0} == '+') $complexNumber = substr($complexNumber,1);
                 return $complexNumber;
         }

◆ _erfcVal()

static PHPExcel_Calculation_Engineering::_erfcVal ( $x )

staticprivate

Definition at line 2289 of file Engineering.php.

References $d, $n, $t, $x, and PRECISION.

                                              {
                 if (abs($x) < 2.2) {
                         return 1 - self::_erfVal($x);
                 }
                 if ($x < 0) {
                         return 2 - self::ERFC(-$x);
                 }
                 $a = $n = 1;
                 $b = $c = $x;
                 $d = ($x * $x) + 0.5;
                 $q1 = $q2 = $b / $d;
                 $t = 0;
                 do {
                         $t = $a * $n + $b * $x;
                         $a = $b;
                         $b = $t;
                         $t = $c * $n + $d * $x;
                         $c = $d;
                         $d = $t;
                         $n += 0.5;
                         $q1 = $q2;
                         $q2 = $b / $d;
                 } while ((abs($q1 - $q2) / $q2) > PRECISION);
                 return self::$_one_sqrtpi * exp(-$x * $x) * $q2;
         }       //      function _erfcVal()

◆ _erfVal()

static PHPExcel_Calculation_Engineering::_erfVal ( $x )

static

Definition at line 2228 of file Engineering.php.

References $x, and PRECISION.

Referenced by PHPExcel_Calculation_Statistical\NORMDIST().

                                            {
                 if (abs($x) > 2.2) {
                         return 1 - self::_erfcVal($x);
                 }
                 $sum = $term = $x;
                 $xsqr = ($x * $x);
                 $j = 1;
                 do {
                         $term *= $xsqr / $j;
                         $sum -= $term / (2 * $j + 1);
                         ++$j;
                         $term *= $xsqr / $j;
                         $sum += $term / (2 * $j + 1);
                         ++$j;
                         if ($sum == 0.0) {
                                 break;
                         }
                 } while (abs($term / $sum) > PRECISION);
                 return self::$_two_sqrtpi * $sum;
         }       //      function _erfVal()

Here is the caller graph for this function:

◆ _nbrConversionFormat()

static PHPExcel_Calculation_Engineering::_nbrConversionFormat	(	$xVal,
		$places
	)

staticprivate

Formats a number base string value with leading zeroes.

Parameters

string	$xVal	The "number" to pad
integer	$places	The length that we want to pad this value

Returns: string The padded "number"

Definition at line 764 of file Engineering.php.

References PHPExcel_Calculation_Functions\NaN().

                                                                      {
                 if (!is_null($places)) {
                         if (strlen($xVal) <= $places) {
                                 return substr(str_pad($xVal, $places, '0', STR_PAD_LEFT), -10);
                         } else {
                                 return PHPExcel_Calculation_Functions::NaN();
                         }
                 }
 
                 return substr($xVal, -10);
         }       //      function _nbrConversionFormat()

Here is the call graph for this function:

◆ _parseComplex()

static PHPExcel_Calculation_Engineering::_parseComplex ( $complexNumber )

static

_parseComplex

Parses a complex number into its real and imaginary parts, and an I or J suffix

Parameters

string $complexNumber The complex number

Returns: string[] Indexed on "real", "imaginary" and "suffix"

Definition at line 696 of file Engineering.php.

References array, and string.

                                                              {
                 $workString = (string) $complexNumber;
 
                 $realNumber = $imaginary = 0;
                 //      Extract the suffix, if there is one
                 $suffix = substr($workString,-1);
                 if (!is_numeric($suffix)) {
                         $workString = substr($workString,0,-1);
                 } else {
                         $suffix = '';
                 }
 
                 //      Split the input into its Real and Imaginary components
                 $leadingSign = 0;
                 if (strlen($workString) > 0) {
                         $leadingSign = (($workString{0} == '+') || ($workString{0} == '-')) ? 1 : 0;
                 }
                 $power = '';
                 $realNumber = strtok($workString, '+-');
                 if (strtoupper(substr($realNumber,-1)) == 'E') {
                         $power = strtok('+-');
                         ++$leadingSign;
                 }
 
                 $realNumber = substr($workString,0,strlen($realNumber)+strlen($power)+$leadingSign);
 
                 if ($suffix != '') {
                         $imaginary = substr($workString,strlen($realNumber));
 
                         if (($imaginary == '') && (($realNumber == '') || ($realNumber == '+') || ($realNumber == '-'))) {
                                 $imaginary = $realNumber.'1';
                                 $realNumber = '0';
                         } else if ($imaginary == '') {
                                 $imaginary = $realNumber;
                                 $realNumber = '0';
                         } elseif (($imaginary == '+') || ($imaginary == '-')) {
                                 $imaginary .= '1';
                         }
                 }
 
                 return array( 'real'            => $realNumber,
                                           'imaginary'   => $imaginary,
                                           'suffix'              => $suffix
                                         );
         }       //      function _parseComplex()

◆ BESSELI()

static PHPExcel_Calculation_Engineering::BESSELI	(	$x,
		$ord
	)

static

Definition at line 796 of file Engineering.php.

References $x, e(), PHPExcel_Calculation_MathTrig\FACT(), PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

                                                  {
                 $x      = (is_null($x)) ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($x);
                 $ord    = (is_null($ord))       ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($ord);
 
                 if ((is_numeric($x)) && (is_numeric($ord))) {
                         $ord    = floor($ord);
                         if ($ord < 0) {
                                 return PHPExcel_Calculation_Functions::NaN();
                         }
 
                         if (abs($x) <= 30) {
                                 $fResult = $fTerm = pow($x / 2, $ord) / PHPExcel_Calculation_MathTrig::FACT($ord);
                                 $ordK = 1;
                                 $fSqrX = ($x * $x) / 4;
                                 do {
                                         $fTerm *= $fSqrX;
                                         $fTerm /= ($ordK * ($ordK + $ord));
                                         $fResult += $fTerm;
                                 } while ((abs($fTerm) > 1e-12) && (++$ordK < 100));
                         } else {
                                 $f_2_PI = 2 * M_PI;
 
                                 $fXAbs = abs($x);
                                 $fResult = exp($fXAbs) / sqrt($f_2_PI * $fXAbs);
                                 if (($ord & 1) && ($x < 0)) {
                                         $fResult = -$fResult;
                                 }
                         }
                         return (is_nan($fResult)) ? PHPExcel_Calculation_Functions::NaN() : $fResult;
                 }
                 return PHPExcel_Calculation_Functions::VALUE();
         }       //      function BESSELI()

Here is the call graph for this function:

◆ BESSELJ()

static PHPExcel_Calculation_Engineering::BESSELJ	(	$x,
		$ord
	)

static

Definition at line 848 of file Engineering.php.

References $x, e(), PHPExcel_Calculation_MathTrig\FACT(), PHPExcel_Calculation_Functions\flattenSingleValue(), M_2DIVPI, PHPExcel_Calculation_Functions\NaN(), and PHPExcel_Calculation_Functions\VALUE().

                                                  {
                 $x      = (is_null($x)) ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($x);
                 $ord    = (is_null($ord))       ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($ord);
 
                 if ((is_numeric($x)) && (is_numeric($ord))) {
                         $ord    = floor($ord);
                         if ($ord < 0) {
                                 return PHPExcel_Calculation_Functions::NaN();
                         }
 
                         $fResult = 0;
                         if (abs($x) <= 30) {
                                 $fResult = $fTerm = pow($x / 2, $ord) / PHPExcel_Calculation_MathTrig::FACT($ord);
                                 $ordK = 1;
                                 $fSqrX = ($x * $x) / -4;
                                 do {
                                         $fTerm *= $fSqrX;
                                         $fTerm /= ($ordK * ($ordK + $ord));
                                         $fResult += $fTerm;
                                 } while ((abs($fTerm) > 1e-12) && (++$ordK < 100));
                         } else {
                                 $f_PI_DIV_2 = M_PI / 2;
                                 $f_PI_DIV_4 = M_PI / 4;
 
                                 $fXAbs = abs($x);
                                 $fResult = sqrt(M_2DIVPI / $fXAbs) * cos($fXAbs - $ord * $f_PI_DIV_2 - $f_PI_DIV_4);
                                 if (($ord & 1) && ($x < 0)) {
                                         $fResult = -$fResult;
                                 }
                         }
                         return (is_nan($fResult)) ? PHPExcel_Calculation_Functions::NaN() : $fResult;
                 }
                 return PHPExcel_Calculation_Functions::VALUE();
         }       //      function BESSELJ()

Here is the call graph for this function:

◆ BESSELK()

static PHPExcel_Calculation_Engineering::BESSELK	(	$x,
		$ord
	)

static

Definition at line 937 of file Engineering.php.

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

                                                  {
                 $x              = (is_null($x))         ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($x);
                 $ord    = (is_null($ord))       ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($ord);
 
                 if ((is_numeric($x)) && (is_numeric($ord))) {
                         if (($ord < 0) || ($x == 0.0)) {
                                 return PHPExcel_Calculation_Functions::NaN();
                         }
 
                         switch(floor($ord)) {
                                 case 0 :        return self::_Besselk0($x);
                                                         break;
                                 case 1 :        return self::_Besselk1($x);
                                                         break;
                                 default :       $fTox   = 2 / $x;
                                                         $fBkm   = self::_Besselk0($x);
                                                         $fBk    = self::_Besselk1($x);
                                                         for ($n = 1; $n < $ord; ++$n) {
                                                                 $fBkp   = $fBkm + $n * $fTox * $fBk;
                                                                 $fBkm   = $fBk;
                                                                 $fBk    = $fBkp;
                                                         }
                         }
                         return (is_nan($fBk)) ? PHPExcel_Calculation_Functions::NaN() : $fBk;
                 }
                 return PHPExcel_Calculation_Functions::VALUE();
         }       //      function BESSELK()

Here is the call graph for this function:

◆ BESSELY()

static PHPExcel_Calculation_Engineering::BESSELY	(	$x,
		$ord
	)

static

Definition at line 1017 of file Engineering.php.

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

                                                  {
                 $x              = (is_null($x))         ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($x);
                 $ord    = (is_null($ord))       ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($ord);
 
                 if ((is_numeric($x)) && (is_numeric($ord))) {
                         if (($ord < 0) || ($x == 0.0)) {
                                 return PHPExcel_Calculation_Functions::NaN();
                         }
 
                         switch(floor($ord)) {
                                 case 0 :        return self::_Bessely0($x);
                                                         break;
                                 case 1 :        return self::_Bessely1($x);
                                                         break;
                                 default:        $fTox   = 2 / $x;
                                                         $fBym   = self::_Bessely0($x);
                                                         $fBy    = self::_Bessely1($x);
                                                         for ($n = 1; $n < $ord; ++$n) {
                                                                 $fByp   = $n * $fTox * $fBy - $fBym;
                                                                 $fBym   = $fBy;
                                                                 $fBy    = $fByp;
                                                         }
                         }
                         return (is_nan($fBy)) ? PHPExcel_Calculation_Functions::NaN() : $fBy;
                 }
                 return PHPExcel_Calculation_Functions::VALUE();
         }       //      function BESSELY()

Here is the call graph for this function:

◆ BINTODEC()

static PHPExcel_Calculation_Engineering::BINTODEC ( $x )

static

Definition at line 1064 of file Engineering.php.

References $out, $x, PHPExcel_Calculation_Functions\COMPATIBILITY_GNUMERIC, PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE, PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\getCompatibilityMode(), PHPExcel_Calculation_Functions\NaN(), string, and PHPExcel_Calculation_Functions\VALUE().

                                             {
                 $x      = PHPExcel_Calculation_Functions::flattenSingleValue($x);
 
                 if (is_bool($x)) {
                         if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
                                 $x = (int) $x;
                         } else {
                                 return PHPExcel_Calculation_Functions::VALUE();
                         }
                 }
                 if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
                         $x = floor($x);
                 }
                 $x = (string) $x;
                 if (strlen($x) > preg_match_all('/[01]/',$x,$out)) {
                         return PHPExcel_Calculation_Functions::NaN();
                 }
                 if (strlen($x) > 10) {
                         return PHPExcel_Calculation_Functions::NaN();
                 } elseif (strlen($x) == 10) {
                         //      Two's Complement
                         $x = substr($x,-9);
                         return '-'.(512-bindec($x));
                 }
                 return bindec($x);
         }       //      function BINTODEC()

Here is the call graph for this function:

◆ BINTOHEX()

static PHPExcel_Calculation_Engineering::BINTOHEX	(	$x,
		$places = `NULL`
	)

static

Definition at line 1116 of file Engineering.php.

References $out, $x, PHPExcel_Calculation_Functions\COMPATIBILITY_GNUMERIC, PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE, PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\getCompatibilityMode(), PHPExcel_Calculation_Functions\NaN(), string, and PHPExcel_Calculation_Functions\VALUE().

                                                           {
                 $x      = PHPExcel_Calculation_Functions::flattenSingleValue($x);
                 $places = PHPExcel_Calculation_Functions::flattenSingleValue($places);
 
                 if (is_bool($x)) {
                         if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
                                 $x = (int) $x;
                         } else {
                                 return PHPExcel_Calculation_Functions::VALUE();
                         }
                 }
                 if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
                         $x = floor($x);
                 }
                 $x = (string) $x;
                 if (strlen($x) > preg_match_all('/[01]/',$x,$out)) {
                         return PHPExcel_Calculation_Functions::NaN();
                 }
                 if (strlen($x) > 10) {
                         return PHPExcel_Calculation_Functions::NaN();
                 } elseif (strlen($x) == 10) {
                         //      Two's Complement
                         return str_repeat('F',8).substr(strtoupper(dechex(bindec(substr($x,-9)))),-2);
                 }
                 $hexVal = (string) strtoupper(dechex(bindec($x)));
 
                 return self::_nbrConversionFormat($hexVal,$places);
         }       //      function BINTOHEX()

Here is the call graph for this function:

◆ BINTOOCT()

static PHPExcel_Calculation_Engineering::BINTOOCT	(	$x,
		$places = `NULL`
	)

static

Definition at line 1170 of file Engineering.php.

References $out, $x, PHPExcel_Calculation_Functions\COMPATIBILITY_GNUMERIC, PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE, PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\getCompatibilityMode(), PHPExcel_Calculation_Functions\NaN(), string, and PHPExcel_Calculation_Functions\VALUE().

                                                           {
                 $x      = PHPExcel_Calculation_Functions::flattenSingleValue($x);
                 $places = PHPExcel_Calculation_Functions::flattenSingleValue($places);
 
                 if (is_bool($x)) {
                         if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
                                 $x = (int) $x;
                         } else {
                                 return PHPExcel_Calculation_Functions::VALUE();
                         }
                 }
                 if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
                         $x = floor($x);
                 }
                 $x = (string) $x;
                 if (strlen($x) > preg_match_all('/[01]/',$x,$out)) {
                         return PHPExcel_Calculation_Functions::NaN();
                 }
                 if (strlen($x) > 10) {
                         return PHPExcel_Calculation_Functions::NaN();
                 } elseif (strlen($x) == 10) {
                         //      Two's Complement
                         return str_repeat('7',7).substr(strtoupper(decoct(bindec(substr($x,-9)))),-3);
                 }
                 $octVal = (string) decoct(bindec($x));
 
                 return self::_nbrConversionFormat($octVal,$places);
         }       //      function BINTOOCT()

Here is the call graph for this function:

◆ COMPLEX()

static PHPExcel_Calculation_Engineering::COMPLEX	(	$realNumber = `0.0`,
		$imaginary = `0.0`,
		$suffix = `'i'`
	)

static

Definition at line 1640 of file Engineering.php.

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

                                                                                      {
                 $realNumber     = (is_null($realNumber))        ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($realNumber);
                 $imaginary      = (is_null($imaginary))         ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($imaginary);
                 $suffix         = (is_null($suffix))            ? 'i' : PHPExcel_Calculation_Functions::flattenSingleValue($suffix);
 
                 if (((is_numeric($realNumber)) && (is_numeric($imaginary))) &&
                         (($suffix == 'i') || ($suffix == 'j') || ($suffix == ''))) {
                         $realNumber     = (float) $realNumber;
                         $imaginary      = (float) $imaginary;
 
                         if ($suffix == '') $suffix = 'i';
                         if ($realNumber == 0.0) {
                                 if ($imaginary == 0.0) {
                                         return (string) '0';
                                 } elseif ($imaginary == 1.0) {
                                         return (string) $suffix;
                                 } elseif ($imaginary == -1.0) {
                                         return (string) '-'.$suffix;
                                 }
                                 return (string) $imaginary.$suffix;
                         } elseif ($imaginary == 0.0) {
                                 return (string) $realNumber;
                         } elseif ($imaginary == 1.0) {
                                 return (string) $realNumber.'+'.$suffix;
                         } elseif ($imaginary == -1.0) {
                                 return (string) $realNumber.'-'.$suffix;
                         }
                         if ($imaginary > 0) { $imaginary = (string) '+'.$imaginary; }
                         return (string) $realNumber.$imaginary.$suffix;
                 }
 
                 return PHPExcel_Calculation_Functions::VALUE();
         }       //      function COMPLEX()

Here is the call graph for this function:

◆ CONVERTUOM()

static PHPExcel_Calculation_Engineering::CONVERTUOM	(	$value,
		$fromUOM,
		$toUOM
	)

static

CONVERTUOM.

Converts a number from one measurement system to another. For example, CONVERT can translate a table of distances in miles to a table of distances in kilometers.

Excel Function: CONVERT(value,fromUOM,toUOM)

Parameters

float	$value	The value in fromUOM to convert.
string	$fromUOM	The units for value.
string	$toUOM	The units for the result.

Returns: float

Definition at line 2421 of file Engineering.php.

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

                                                                     {
                 $value          = PHPExcel_Calculation_Functions::flattenSingleValue($value);
                 $fromUOM        = PHPExcel_Calculation_Functions::flattenSingleValue($fromUOM);
                 $toUOM          = PHPExcel_Calculation_Functions::flattenSingleValue($toUOM);
 
                 if (!is_numeric($value)) {
                         return PHPExcel_Calculation_Functions::VALUE();
                 }
                 $fromMultiplier = 1.0;
                 if (isset(self::$_conversionUnits[$fromUOM])) {
                         $unitGroup1 = self::$_conversionUnits[$fromUOM]['Group'];
                 } else {
                         $fromMultiplier = substr($fromUOM,0,1);
                         $fromUOM = substr($fromUOM,1);
                         if (isset(self::$_conversionMultipliers[$fromMultiplier])) {
                                 $fromMultiplier = self::$_conversionMultipliers[$fromMultiplier]['multiplier'];
                         } else {
                                 return PHPExcel_Calculation_Functions::NA();
                         }
                         if ((isset(self::$_conversionUnits[$fromUOM])) && (self::$_conversionUnits[$fromUOM]['AllowPrefix'])) {
                                 $unitGroup1 = self::$_conversionUnits[$fromUOM]['Group'];
                         } else {
                                 return PHPExcel_Calculation_Functions::NA();
                         }
                 }
                 $value *= $fromMultiplier;
 
                 $toMultiplier = 1.0;
                 if (isset(self::$_conversionUnits[$toUOM])) {
                         $unitGroup2 = self::$_conversionUnits[$toUOM]['Group'];
                 } else {
                         $toMultiplier = substr($toUOM,0,1);
                         $toUOM = substr($toUOM,1);
                         if (isset(self::$_conversionMultipliers[$toMultiplier])) {
                                 $toMultiplier = self::$_conversionMultipliers[$toMultiplier]['multiplier'];
                         } else {
                                 return PHPExcel_Calculation_Functions::NA();
                         }
                         if ((isset(self::$_conversionUnits[$toUOM])) && (self::$_conversionUnits[$toUOM]['AllowPrefix'])) {
                                 $unitGroup2 = self::$_conversionUnits[$toUOM]['Group'];
                         } else {
                                 return PHPExcel_Calculation_Functions::NA();
                         }
                 }
                 if ($unitGroup1 != $unitGroup2) {
                         return PHPExcel_Calculation_Functions::NA();
                 }
 
                 if (($fromUOM == $toUOM) && ($fromMultiplier == $toMultiplier)) {
                         //      We've already factored $fromMultiplier into the value, so we need
                         //              to reverse it again
                         return $value / $fromMultiplier;
                 } elseif ($unitGroup1 == 'Temperature') {
                         if (($fromUOM == 'F') || ($fromUOM == 'fah')) {
                                 if (($toUOM == 'F') || ($toUOM == 'fah')) {
                                         return $value;
                                 } else {
                                         $value = (($value - 32) / 1.8);
                                         if (($toUOM == 'K') || ($toUOM == 'kel')) {
                                                 $value += 273.15;
                                         }
                                         return $value;
                                 }
                         } elseif ((($fromUOM == 'K') || ($fromUOM == 'kel')) &&
                                           (($toUOM == 'K') || ($toUOM == 'kel'))) {
                                                 return $value;
                         } elseif ((($fromUOM == 'C') || ($fromUOM == 'cel')) &&
                                           (($toUOM == 'C') || ($toUOM == 'cel'))) {
                                         return $value;
                         }
                         if (($toUOM == 'F') || ($toUOM == 'fah')) {
                                 if (($fromUOM == 'K') || ($fromUOM == 'kel')) {
                                         $value -= 273.15;
                                 }
                                 return ($value * 1.8) + 32;
                         }
                         if (($toUOM == 'C') || ($toUOM == 'cel')) {
                                 return $value - 273.15;
                         }
                         return $value + 273.15;
                 }
                 return ($value * self::$_unitConversions[$unitGroup1][$fromUOM][$toUOM]) / $toMultiplier;
         }       //      function CONVERTUOM()

Here is the call graph for this function:

◆ DECTOBIN()

static PHPExcel_Calculation_Engineering::DECTOBIN	(	$x,
		$places = `NULL`
	)

static

Definition at line 1228 of file Engineering.php.

References $out, $r, $x, PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE, PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\getCompatibilityMode(), PHPExcel_Calculation_Functions\NaN(), string, and PHPExcel_Calculation_Functions\VALUE().

                                                           {
                 $x      = PHPExcel_Calculation_Functions::flattenSingleValue($x);
                 $places = PHPExcel_Calculation_Functions::flattenSingleValue($places);
 
                 if (is_bool($x)) {
                         if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
                                 $x = (int) $x;
                         } else {
                                 return PHPExcel_Calculation_Functions::VALUE();
                         }
                 }
                 $x = (string) $x;
                 if (strlen($x) > preg_match_all('/[-0123456789.]/',$x,$out)) {
                         return PHPExcel_Calculation_Functions::VALUE();
                 }
                 $x = (string) floor($x);
                 $r = decbin($x);
                 if (strlen($r) == 32) {
                         //      Two's Complement
                         $r = substr($r,-10);
                 } elseif (strlen($r) > 11) {
                         return PHPExcel_Calculation_Functions::NaN();
                 }
 
                 return self::_nbrConversionFormat($r,$places);
         }       //      function DECTOBIN()

Here is the call graph for this function:

◆ DECTOHEX()

static PHPExcel_Calculation_Engineering::DECTOHEX	(	$x,
		$places = `null`
	)

static

Definition at line 1284 of file Engineering.php.

References $out, $r, $x, PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE, PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\getCompatibilityMode(), string, and PHPExcel_Calculation_Functions\VALUE().

                                                           {
                 $x      = PHPExcel_Calculation_Functions::flattenSingleValue($x);
                 $places = PHPExcel_Calculation_Functions::flattenSingleValue($places);
 
                 if (is_bool($x)) {
                         if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
                                 $x = (int) $x;
                         } else {
                                 return PHPExcel_Calculation_Functions::VALUE();
                         }
                 }
                 $x = (string) $x;
                 if (strlen($x) > preg_match_all('/[-0123456789.]/',$x,$out)) {
                         return PHPExcel_Calculation_Functions::VALUE();
                 }
                 $x = (string) floor($x);
                 $r = strtoupper(dechex($x));
                 if (strlen($r) == 8) {
                         //      Two's Complement
                         $r = 'FF'.$r;
                 }
 
                 return self::_nbrConversionFormat($r,$places);
         }       //      function DECTOHEX()

Here is the call graph for this function:

◆ DECTOOCT()

static PHPExcel_Calculation_Engineering::DECTOOCT	(	$x,
		$places = `null`
	)

static

Definition at line 1338 of file Engineering.php.

References $out, $r, $x, PHPExcel_Calculation_Functions\COMPATIBILITY_OPENOFFICE, PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\getCompatibilityMode(), string, and PHPExcel_Calculation_Functions\VALUE().

                                                           {
                 $x      = PHPExcel_Calculation_Functions::flattenSingleValue($x);
                 $places = PHPExcel_Calculation_Functions::flattenSingleValue($places);
 
                 if (is_bool($x)) {
                         if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
                                 $x = (int) $x;
                         } else {
                                 return PHPExcel_Calculation_Functions::VALUE();
                         }
                 }
                 $x = (string) $x;
                 if (strlen($x) > preg_match_all('/[-0123456789.]/',$x,$out)) {
                         return PHPExcel_Calculation_Functions::VALUE();
                 }
                 $x = (string) floor($x);
                 $r = decoct($x);
                 if (strlen($r) == 11) {
                         //      Two's Complement
                         $r = substr($r,-10);
                 }
 
                 return self::_nbrConversionFormat($r,$places);
         }       //      function DECTOOCT()

Here is the call graph for this function:

◆ DELTA()

static PHPExcel_Calculation_Engineering::DELTA	(	$a,
		$b = `0`
	)

static

DELTA.

Tests whether two values are equal. Returns 1 if number1 = number2; returns 0 otherwise. Use this function to filter a set of values. For example, by summing several DELTA functions you calculate the count of equal pairs. This function is also known as the Kronecker Delta function.

Excel Function: DELTA(a[,b])

Parameters

float	$a	The first number.
float	$b	The second number. If omitted, b is assumed to be zero.

Returns: int

Definition at line 2192 of file Engineering.php.

References PHPExcel_Calculation_Functions\flattenSingleValue().

                                                {
                 $a      = PHPExcel_Calculation_Functions::flattenSingleValue($a);
                 $b      = PHPExcel_Calculation_Functions::flattenSingleValue($b);
 
                 return (int) ($a == $b);
         }       //      function DELTA()

Here is the call graph for this function:

◆ ERF()

static PHPExcel_Calculation_Engineering::ERF	(	$lower,
		$upper = `NULL`
	)

static

ERF.

Returns the error function integrated between the lower and upper bound arguments.

Note: In Excel 2007 or earlier, if you input a negative value for the upper or lower bound arguments, the function would return a #NUM! error. However, in Excel 2010, the function algorithm was improved, so that it can now calculate the function for both positive and negative ranges. PHPExcel follows Excel 2010 behaviour, and accepts nagative arguments.

Excel Function: ERF(lower[,upper])

Parameters

float	$lower	lower bound for integrating ERF
float	$upper	upper bound for integrating ERF. If omitted, ERF integrates between zero and lower_limit

Returns: float

Definition at line 2268 of file Engineering.php.

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

                                                           {
                 $lower  = PHPExcel_Calculation_Functions::flattenSingleValue($lower);
                 $upper  = PHPExcel_Calculation_Functions::flattenSingleValue($upper);
 
                 if (is_numeric($lower)) {
                         if (is_null($upper)) {
                                 return self::_erfVal($lower);
                         }
                         if (is_numeric($upper)) {
                                 return self::_erfVal($upper) - self::_erfVal($lower);
                         }
                 }
                 return PHPExcel_Calculation_Functions::VALUE();
         }       //      function ERF()

Here is the call graph for this function:

◆ ERFC()

static PHPExcel_Calculation_Engineering::ERFC ( $x )

static

ERFC.

Returns the complementary ERF function integrated between x and infinity

Note: In Excel 2007 or earlier, if you input a negative value for the lower bound argument, the function would return a #NUM! error. However, in Excel 2010, the function algorithm was improved, so that it can now calculate the function for both positive and negative x values. PHPExcel follows Excel 2010 behaviour, and accepts nagative arguments.

Excel Function: ERFC(x)

Parameters

float $x The lower bound for integrating ERFC

Returns: float

Definition at line 2332 of file Engineering.php.

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

                                         {
                 $x = PHPExcel_Calculation_Functions::flattenSingleValue($x);
 
                 if (is_numeric($x)) {
                         return self::_erfcVal($x);
                 }
                 return PHPExcel_Calculation_Functions::VALUE();
         }       //      function ERFC()

Here is the call graph for this function:

◆ GESTEP()

static PHPExcel_Calculation_Engineering::GESTEP	(	$number,
		$step = `0`
	)

static

GESTEP.

Excel Function: GESTEP(number[,step])

Returns 1 if number >= step; returns 0 (zero) otherwise Use this function to filter a set of values. For example, by summing several GESTEP functions you calculate the count of values that exceed a threshold.

Parameters

float	$number	The value to test against step.
float	$step	The threshold value. If you omit a value for step, GESTEP uses zero.

Returns: int

Definition at line 2215 of file Engineering.php.

References $step, and PHPExcel_Calculation_Functions\flattenSingleValue().

                                                         {
                 $number = PHPExcel_Calculation_Functions::flattenSingleValue($number);
                 $step   = PHPExcel_Calculation_Functions::flattenSingleValue($step);
 
                 return (int) ($number >= $step);
         }       //      function GESTEP()

Here is the call graph for this function:

◆ getConversionGroups()

static PHPExcel_Calculation_Engineering::getConversionGroups ( )

static

getConversionGroups Returns a list of the different conversion groups for UOM conversions

Returns: array

Definition at line 2348 of file Engineering.php.

References array.

Referenced by EngineeringTest\testGetConversionGroups().

                                                      {
                 $conversionGroups = array();
                 foreach(self::$_conversionUnits as $conversionUnit) {
                         $conversionGroups[] = $conversionUnit['Group'];
                 }
                 return array_merge(array_unique($conversionGroups));
         }       //      function getConversionGroups()

Here is the caller graph for this function:

◆ getConversionGroupUnitDetails()

static PHPExcel_Calculation_Engineering::getConversionGroupUnitDetails ( $group = NULL )

static

getConversionGroupUnitDetails

Parameters

string $group The group whose units of measure you want to retrieve

Returns: array

Definition at line 2381 of file Engineering.php.

References array.

Referenced by EngineeringTest\testGetConversionGroupUnitDetails().

                                                                             {
                 $conversionGroups = array();
                 foreach(self::$_conversionUnits as $conversionUnit => $conversionGroup) {
                         if ((is_null($group)) || ($conversionGroup['Group'] == $group)) {
                                 $conversionGroups[$conversionGroup['Group']][] = array( 'unit'                  => $conversionUnit,
                                                                                                                                                 'description'   => $conversionGroup['Unit Name']
                                                                                                                                           );
                         }
                 }
                 return $conversionGroups;
         }       //      function getConversionGroupUnitDetails()

Here is the caller graph for this function:

◆ getConversionGroupUnits()

static PHPExcel_Calculation_Engineering::getConversionGroupUnits ( $group = NULL )

static

getConversionGroupUnits Returns an array of units of measure, for a specified conversion group, or for all groups

Parameters

string $group The group whose units of measure you want to retrieve

Returns: array

Definition at line 2364 of file Engineering.php.

References array.

Referenced by EngineeringTest\testGetConversionGroupUnits().

                                                                       {
                 $conversionGroups = array();
                 foreach(self::$_conversionUnits as $conversionUnit => $conversionGroup) {
                         if ((is_null($group)) || ($conversionGroup['Group'] == $group)) {
                                 $conversionGroups[$conversionGroup['Group']][] = $conversionUnit;
                         }
                 }
                 return $conversionGroups;
         }       //      function getConversionGroupUnits()

Here is the caller graph for this function:

◆ getConversionMultipliers()

static PHPExcel_Calculation_Engineering::getConversionMultipliers ( )

static

getConversionMultipliers Returns an array of the Multiplier prefixes that can be used with Units of Measure in CONVERTUOM()

Returns: array of mixed

Definition at line 2400 of file Engineering.php.

Referenced by EngineeringTest\testGetConversionMultipliers().

                                                           {
                 return self::$_conversionMultipliers;
         }       //      function getConversionGroups()

Here is the caller graph for this function:

◆ HEXTOBIN()

static PHPExcel_Calculation_Engineering::HEXTOBIN	(	$x,
		$places = `null`
	)

static

Definition at line 1395 of file Engineering.php.

References $out, $x, PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), string, and PHPExcel_Calculation_Functions\VALUE().

                                                           {
                 $x      = PHPExcel_Calculation_Functions::flattenSingleValue($x);
                 $places = PHPExcel_Calculation_Functions::flattenSingleValue($places);
 
                 if (is_bool($x)) {
                         return PHPExcel_Calculation_Functions::VALUE();
                 }
                 $x = (string) $x;
                 if (strlen($x) > preg_match_all('/[0123456789ABCDEF]/',strtoupper($x),$out)) {
                         return PHPExcel_Calculation_Functions::NaN();
                 }
                 $binVal = decbin(hexdec($x));
 
                 return substr(self::_nbrConversionFormat($binVal,$places),-10);
         }       //      function HEXTOBIN()

Here is the call graph for this function:

◆ HEXTODEC()

static PHPExcel_Calculation_Engineering::HEXTODEC ( $x )

static

Definition at line 1431 of file Engineering.php.

References $out, $x, PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), string, and PHPExcel_Calculation_Functions\VALUE().

                                             {
                 $x      = PHPExcel_Calculation_Functions::flattenSingleValue($x);
 
                 if (is_bool($x)) {
                         return PHPExcel_Calculation_Functions::VALUE();
                 }
                 $x = (string) $x;
                 if (strlen($x) > preg_match_all('/[0123456789ABCDEF]/',strtoupper($x),$out)) {
                         return PHPExcel_Calculation_Functions::NaN();
                 }
                 return hexdec($x);
         }       //      function HEXTODEC()

Here is the call graph for this function:

◆ HEXTOOCT()

static PHPExcel_Calculation_Engineering::HEXTOOCT	(	$x,
		$places = `null`
	)

static

Definition at line 1477 of file Engineering.php.

References $out, $x, PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), string, and PHPExcel_Calculation_Functions\VALUE().

                                                           {
                 $x      = PHPExcel_Calculation_Functions::flattenSingleValue($x);
                 $places = PHPExcel_Calculation_Functions::flattenSingleValue($places);
 
                 if (is_bool($x)) {
                         return PHPExcel_Calculation_Functions::VALUE();
                 }
                 $x = (string) $x;
                 if (strlen($x) > preg_match_all('/[0123456789ABCDEF]/',strtoupper($x),$out)) {
                         return PHPExcel_Calculation_Functions::NaN();
                 }
                 $octVal = decoct(hexdec($x));
 
                 return self::_nbrConversionFormat($octVal,$places);
         }       //      function HEXTOOCT()

Here is the call graph for this function:

◆ IMABS()

static PHPExcel_Calculation_Engineering::IMABS ( $complexNumber )

static

IMABS.

Returns the absolute value (modulus) of a complex number in x + yi or x + yj text format.

Excel Function: IMABS(complexNumber)

Parameters

string $complexNumber The complex number for which you want the absolute value.

Returns: float

Definition at line 1729 of file Engineering.php.

References PHPExcel_Calculation_Functions\flattenSingleValue().

                                                      {
                 $complexNumber  = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
 
                 $parsedComplex = self::_parseComplex($complexNumber);
 
                 return sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary']));
         }       //      function IMABS()

Here is the call graph for this function:

◆ IMAGINARY()

static PHPExcel_Calculation_Engineering::IMAGINARY ( $complexNumber )

static

Definition at line 1689 of file Engineering.php.

References PHPExcel_Calculation_Functions\flattenSingleValue().

                                                          {
                 $complexNumber  = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
 
                 $parsedComplex = self::_parseComplex($complexNumber);
                 return $parsedComplex['imaginary'];
         }       //      function IMAGINARY()

Here is the call graph for this function:

◆ IMARGUMENT()

static PHPExcel_Calculation_Engineering::IMARGUMENT ( $complexNumber )

static

IMARGUMENT.

Returns the argument theta of a complex number, i.e. the angle in radians from the real axis to the representation of the number in polar coordinates.

Excel Function: IMARGUMENT(complexNumber)

Parameters

string $complexNumber The complex number for which you want the argument theta.

Returns: float

Definition at line 1750 of file Engineering.php.

References PHPExcel_Calculation_Functions\flattenSingleValue().

                                                           {
                 $complexNumber  = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
 
                 $parsedComplex = self::_parseComplex($complexNumber);
 
                 if ($parsedComplex['real'] == 0.0) {
                         if ($parsedComplex['imaginary'] == 0.0) {
                                 return 0.0;
                         } elseif($parsedComplex['imaginary'] < 0.0) {
                                 return M_PI / -2;
                         } else {
                                 return M_PI / 2;
                         }
                 } elseif ($parsedComplex['real'] > 0.0) {
                         return atan($parsedComplex['imaginary'] / $parsedComplex['real']);
                 } elseif ($parsedComplex['imaginary'] < 0.0) {
                         return 0 - (M_PI - atan(abs($parsedComplex['imaginary']) / abs($parsedComplex['real'])));
                 } else {
                         return M_PI - atan($parsedComplex['imaginary'] / abs($parsedComplex['real']));
                 }
         }       //      function IMARGUMENT()

Here is the call graph for this function:

◆ IMCONJUGATE()

static PHPExcel_Calculation_Engineering::IMCONJUGATE ( $complexNumber )

static

IMCONJUGATE.

Returns the complex conjugate of a complex number in x + yi or x + yj text format.

Excel Function: IMCONJUGATE(complexNumber)

Parameters

string $complexNumber The complex number for which you want the conjugate.

Returns: string

Definition at line 1784 of file Engineering.php.

References PHPExcel_Calculation_Functions\flattenSingleValue().

                                                            {
                 $complexNumber  = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
 
                 $parsedComplex = self::_parseComplex($complexNumber);
 
                 if ($parsedComplex['imaginary'] == 0.0) {
                         return $parsedComplex['real'];
                 } else {
                         return self::_cleanComplex( self::COMPLEX( $parsedComplex['real'],
                                                                                                            0 - $parsedComplex['imaginary'],
                                                                                                            $parsedComplex['suffix']
                                                                                                          )
                                                                           );
                 }
         }       //      function IMCONJUGATE()

Here is the call graph for this function:

◆ IMCOS()

static PHPExcel_Calculation_Engineering::IMCOS ( $complexNumber )

static

IMCOS.

Returns the cosine of a complex number in x + yi or x + yj text format.

Excel Function: IMCOS(complexNumber)

Parameters

string $complexNumber The complex number for which you want the cosine.

Returns: string|float

Definition at line 1812 of file Engineering.php.

References PHPExcel_Calculation_Functions\flattenSingleValue().

                                                      {
                 $complexNumber  = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
 
                 $parsedComplex = self::_parseComplex($complexNumber);
 
                 if ($parsedComplex['imaginary'] == 0.0) {
                         return cos($parsedComplex['real']);
                 } else {
                         return self::IMCONJUGATE(self::COMPLEX(cos($parsedComplex['real']) * cosh($parsedComplex['imaginary']),sin($parsedComplex['real']) * sinh($parsedComplex['imaginary']),$parsedComplex['suffix']));
                 }
         }       //      function IMCOS()

Here is the call graph for this function:

◆ IMDIV()

static PHPExcel_Calculation_Engineering::IMDIV	(	$complexDividend,
		$complexDivisor
	)

static

IMDIV.

Returns the quotient of two complex numbers in x + yi or x + yj text format.

Excel Function: IMDIV(complexDividend,complexDivisor)

Parameters

string	$complexDividend	The complex numerator or dividend.
string	$complexDivisor	The complex denominator or divisor.

Returns: string

Definition at line 2040 of file Engineering.php.

References $r, PHPExcel_Calculation_Functions\flattenSingleValue(), and PHPExcel_Calculation_Functions\NaN().

                                                                        {
                 $complexDividend        = PHPExcel_Calculation_Functions::flattenSingleValue($complexDividend);
                 $complexDivisor = PHPExcel_Calculation_Functions::flattenSingleValue($complexDivisor);
 
                 $parsedComplexDividend = self::_parseComplex($complexDividend);
                 $parsedComplexDivisor = self::_parseComplex($complexDivisor);
 
                 if (($parsedComplexDividend['suffix'] != '') && ($parsedComplexDivisor['suffix'] != '') &&
                         ($parsedComplexDividend['suffix'] != $parsedComplexDivisor['suffix'])) {
                         return PHPExcel_Calculation_Functions::NaN();
                 }
                 if (($parsedComplexDividend['suffix'] != '') && ($parsedComplexDivisor['suffix'] == '')) {
                         $parsedComplexDivisor['suffix'] = $parsedComplexDividend['suffix'];
                 }
 
                 $d1 = ($parsedComplexDividend['real'] * $parsedComplexDivisor['real']) + ($parsedComplexDividend['imaginary'] * $parsedComplexDivisor['imaginary']);
                 $d2 = ($parsedComplexDividend['imaginary'] * $parsedComplexDivisor['real']) - ($parsedComplexDividend['real'] * $parsedComplexDivisor['imaginary']);
                 $d3 = ($parsedComplexDivisor['real'] * $parsedComplexDivisor['real']) + ($parsedComplexDivisor['imaginary'] * $parsedComplexDivisor['imaginary']);
 
                 $r = $d1/$d3;
                 $i = $d2/$d3;
 
                 if ($i > 0.0) {
                         return self::_cleanComplex($r.'+'.$i.$parsedComplexDivisor['suffix']);
                 } elseif ($i < 0.0) {
                         return self::_cleanComplex($r.$i.$parsedComplexDivisor['suffix']);
                 } else {
                         return $r;
                 }
         }       //      function IMDIV()

Here is the call graph for this function:

◆ IMEXP()

static PHPExcel_Calculation_Engineering::IMEXP ( $complexNumber )

static

IMEXP.

Returns the exponential of a complex number in x + yi or x + yj text format.

Excel Function: IMEXP(complexNumber)

Parameters

string $complexNumber The complex number for which you want the exponential.

Returns: string

Definition at line 1972 of file Engineering.php.

References PHPExcel_Calculation_Functions\flattenSingleValue().

                                                      {
                 $complexNumber  = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
 
                 $parsedComplex = self::_parseComplex($complexNumber);
 
                 if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
                         return '1';
                 }
 
                 $e = exp($parsedComplex['real']);
                 $eX = $e * cos($parsedComplex['imaginary']);
                 $eY = $e * sin($parsedComplex['imaginary']);
 
                 if ($parsedComplex['suffix'] == '') {
                         return self::COMPLEX($eX,$eY);
                 } else {
                         return self::COMPLEX($eX,$eY,$parsedComplex['suffix']);
                 }
         }       //      function IMEXP()

Here is the call graph for this function:

◆ IMLN()

static PHPExcel_Calculation_Engineering::IMLN ( $complexNumber )

static

IMLN.

Returns the natural logarithm of a complex number in x + yi or x + yj text format.

Excel Function: IMLN(complexNumber)

Parameters

string $complexNumber The complex number for which you want the natural logarithm.

Returns: string

Definition at line 1889 of file Engineering.php.

References $t, PHPExcel_Calculation_Functions\flattenSingleValue(), and PHPExcel_Calculation_Functions\NaN().

                                                     {
                 $complexNumber  = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
 
                 $parsedComplex = self::_parseComplex($complexNumber);
 
                 if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
                         return PHPExcel_Calculation_Functions::NaN();
                 }
 
                 $logR = log(sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary'])));
                 $t = self::IMARGUMENT($complexNumber);
 
                 if ($parsedComplex['suffix'] == '') {
                         return self::COMPLEX($logR,$t);
                 } else {
                         return self::COMPLEX($logR,$t,$parsedComplex['suffix']);
                 }
         }       //      function IMLN()

Here is the call graph for this function:

◆ IMLOG10()

static PHPExcel_Calculation_Engineering::IMLOG10 ( $complexNumber )

static

IMLOG10.

Returns the common logarithm (base 10) of a complex number in x + yi or x + yj text format.

Excel Function: IMLOG10(complexNumber)

Parameters

string $complexNumber The complex number for which you want the common logarithm.

Returns: string

Definition at line 1920 of file Engineering.php.

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

                                                        {
                 $complexNumber  = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
 
                 $parsedComplex = self::_parseComplex($complexNumber);
 
                 if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
                         return PHPExcel_Calculation_Functions::NaN();
                 } elseif (($parsedComplex['real'] > 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
                         return log10($parsedComplex['real']);
                 }
 
                 return self::IMPRODUCT(log10(EULER),self::IMLN($complexNumber));
         }       //      function IMLOG10()

Here is the call graph for this function:

◆ IMLOG2()

static PHPExcel_Calculation_Engineering::IMLOG2 ( $complexNumber )

static

IMLOG2.

Returns the base-2 logarithm of a complex number in x + yi or x + yj text format.

Excel Function: IMLOG2(complexNumber)

Parameters

string $complexNumber The complex number for which you want the base-2 logarithm.

Returns: string

Definition at line 1946 of file Engineering.php.

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

                                                       {
                 $complexNumber  = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
 
                 $parsedComplex = self::_parseComplex($complexNumber);
 
                 if (($parsedComplex['real'] == 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
                         return PHPExcel_Calculation_Functions::NaN();
                 } elseif (($parsedComplex['real'] > 0.0) && ($parsedComplex['imaginary'] == 0.0)) {
                         return log($parsedComplex['real'],2);
                 }
 
                 return self::IMPRODUCT(log(EULER,2),self::IMLN($complexNumber));
         }       //      function IMLOG2()

Here is the call graph for this function:

◆ IMPOWER()

static PHPExcel_Calculation_Engineering::IMPOWER	(	$complexNumber,
		$realNumber
	)

static

IMPOWER.

Returns a complex number in x + yi or x + yj text format raised to a power.

Excel Function: IMPOWER(complexNumber,realNumber)

Parameters

string	$complexNumber	The complex number you want to raise to a power.
float	$realNumber	The power to which you want to raise the complex number.

Returns: string

Definition at line 2005 of file Engineering.php.

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

                                                                    {
                 $complexNumber  = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
                 $realNumber             = PHPExcel_Calculation_Functions::flattenSingleValue($realNumber);
 
                 if (!is_numeric($realNumber)) {
                         return PHPExcel_Calculation_Functions::VALUE();
                 }
 
                 $parsedComplex = self::_parseComplex($complexNumber);
 
                 $r = sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary']));
                 $rPower = pow($r,$realNumber);
                 $theta = self::IMARGUMENT($complexNumber) * $realNumber;
                 if ($theta == 0) {
                         return 1;
                 } elseif ($parsedComplex['imaginary'] == 0.0) {
                         return self::COMPLEX($rPower * cos($theta),$rPower * sin($theta),$parsedComplex['suffix']);
                 } else {
                         return self::COMPLEX($rPower * cos($theta),$rPower * sin($theta),$parsedComplex['suffix']);
                 }
         }       //      function IMPOWER()

Here is the call graph for this function:

◆ IMPRODUCT()

static PHPExcel_Calculation_Engineering::IMPRODUCT ( )

static

IMPRODUCT.

Returns the product of two or more complex numbers in x + yi or x + yj text format.

Excel Function: IMPRODUCT(complexNumber[,complexNumber[,...]])

Parameters

string $complexNumber,... Series of complex numbers to multiply

Returns: string

Definition at line 2152 of file Engineering.php.

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

                                            {
                 // Return value
                 $returnValue = self::_parseComplex('1');
                 $activeSuffix = '';
 
                 // Loop through the arguments
                 $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
                 foreach ($aArgs as $arg) {
                         $parsedComplex = self::_parseComplex($arg);
 
                         $workValue = $returnValue;
                         if (($parsedComplex['suffix'] != '') && ($activeSuffix == '')) {
                                 $activeSuffix = $parsedComplex['suffix'];
                         } elseif (($parsedComplex['suffix'] != '') && ($activeSuffix != $parsedComplex['suffix'])) {
                                 return PHPExcel_Calculation_Functions::NaN();
                         }
                         $returnValue['real'] = ($workValue['real'] * $parsedComplex['real']) - ($workValue['imaginary'] * $parsedComplex['imaginary']);
                         $returnValue['imaginary'] = ($workValue['real'] * $parsedComplex['imaginary']) + ($workValue['imaginary'] * $parsedComplex['real']);
                 }
 
                 if ($returnValue['imaginary'] == 0.0) { $activeSuffix = ''; }
                 return self::COMPLEX($returnValue['real'],$returnValue['imaginary'],$activeSuffix);
         }       //      function IMPRODUCT()

Here is the call graph for this function:

◆ IMREAL()

static PHPExcel_Calculation_Engineering::IMREAL ( $complexNumber )

static

Definition at line 1710 of file Engineering.php.

References PHPExcel_Calculation_Functions\flattenSingleValue().

                                                       {
                 $complexNumber  = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
 
                 $parsedComplex = self::_parseComplex($complexNumber);
                 return $parsedComplex['real'];
         }       //      function IMREAL()

Here is the call graph for this function:

◆ IMSIN()

static PHPExcel_Calculation_Engineering::IMSIN ( $complexNumber )

static

IMSIN.

Returns the sine of a complex number in x + yi or x + yj text format.

Excel Function: IMSIN(complexNumber)

Parameters

string $complexNumber The complex number for which you want the sine.

Returns: string|float

Definition at line 1836 of file Engineering.php.

References PHPExcel_Calculation_Functions\flattenSingleValue().

                                                      {
                 $complexNumber  = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
 
                 $parsedComplex = self::_parseComplex($complexNumber);
 
                 if ($parsedComplex['imaginary'] == 0.0) {
                         return sin($parsedComplex['real']);
                 } else {
                         return self::COMPLEX(sin($parsedComplex['real']) * cosh($parsedComplex['imaginary']),cos($parsedComplex['real']) * sinh($parsedComplex['imaginary']),$parsedComplex['suffix']);
                 }
         }       //      function IMSIN()

Here is the call graph for this function:

◆ IMSQRT()

static PHPExcel_Calculation_Engineering::IMSQRT ( $complexNumber )

static

IMSQRT.

Returns the square root of a complex number in x + yi or x + yj text format.

Excel Function: IMSQRT(complexNumber)

Parameters

string $complexNumber The complex number for which you want the square root.

Returns: string

Definition at line 1860 of file Engineering.php.

References $r, and PHPExcel_Calculation_Functions\flattenSingleValue().

                                                       {
                 $complexNumber  = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
 
                 $parsedComplex = self::_parseComplex($complexNumber);
 
                 $theta = self::IMARGUMENT($complexNumber);
                 $d1 = cos($theta / 2);
                 $d2 = sin($theta / 2);
                 $r = sqrt(sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary'])));
 
                 if ($parsedComplex['suffix'] == '') {
                         return self::COMPLEX($d1 * $r,$d2 * $r);
                 } else {
                         return self::COMPLEX($d1 * $r,$d2 * $r,$parsedComplex['suffix']);
                 }
         }       //      function IMSQRT()

Here is the call graph for this function:

◆ IMSUB()

static PHPExcel_Calculation_Engineering::IMSUB	(	$complexNumber1,
		$complexNumber2
	)

static

IMSUB.

Returns the difference of two complex numbers in x + yi or x + yj text format.

Excel Function: IMSUB(complexNumber1,complexNumber2)

Parameters

string	$complexNumber1	The complex number from which to subtract complexNumber2.
string	$complexNumber2	The complex number to subtract from complexNumber1.

Returns: string

Definition at line 2084 of file Engineering.php.

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

                                                                       {
                 $complexNumber1 = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber1);
                 $complexNumber2 = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber2);
 
                 $parsedComplex1 = self::_parseComplex($complexNumber1);
                 $parsedComplex2 = self::_parseComplex($complexNumber2);
 
                 if ((($parsedComplex1['suffix'] != '') && ($parsedComplex2['suffix'] != '')) &&
                         ($parsedComplex1['suffix'] != $parsedComplex2['suffix'])) {
                         return PHPExcel_Calculation_Functions::NaN();
                 } elseif (($parsedComplex1['suffix'] == '') && ($parsedComplex2['suffix'] != '')) {
                         $parsedComplex1['suffix'] = $parsedComplex2['suffix'];
                 }
 
                 $d1 = $parsedComplex1['real'] - $parsedComplex2['real'];
                 $d2 = $parsedComplex1['imaginary'] - $parsedComplex2['imaginary'];
 
                 return self::COMPLEX($d1,$d2,$parsedComplex1['suffix']);
         }       //      function IMSUB()

Here is the call graph for this function:

◆ IMSUM()

static PHPExcel_Calculation_Engineering::IMSUM ( )

static

IMSUM.

Returns the sum of two or more complex numbers in x + yi or x + yj text format.

Excel Function: IMSUM(complexNumber[,complexNumber[,...]])

Parameters

string $complexNumber,... Series of complex numbers to add

Returns: string

Definition at line 2116 of file Engineering.php.

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

                                        {
                 // Return value
                 $returnValue = self::_parseComplex('0');
                 $activeSuffix = '';
 
                 // Loop through the arguments
                 $aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
                 foreach ($aArgs as $arg) {
                         $parsedComplex = self::_parseComplex($arg);
 
                         if ($activeSuffix == '') {
                                 $activeSuffix = $parsedComplex['suffix'];
                         } elseif (($parsedComplex['suffix'] != '') && ($activeSuffix != $parsedComplex['suffix'])) {
                                 return PHPExcel_Calculation_Functions::VALUE();
                         }
 
                         $returnValue['real'] += $parsedComplex['real'];
                         $returnValue['imaginary'] += $parsedComplex['imaginary'];
                 }
 
                 if ($returnValue['imaginary'] == 0.0) { $activeSuffix = ''; }
                 return self::COMPLEX($returnValue['real'],$returnValue['imaginary'],$activeSuffix);
         }       //      function IMSUM()

Here is the call graph for this function:

◆ OCTTOBIN()

static PHPExcel_Calculation_Engineering::OCTTOBIN	(	$x,
		$places = `null`
	)

static

Definition at line 1528 of file Engineering.php.

References $out, $r, $x, PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), string, and PHPExcel_Calculation_Functions\VALUE().

                                                           {
                 $x      = PHPExcel_Calculation_Functions::flattenSingleValue($x);
                 $places = PHPExcel_Calculation_Functions::flattenSingleValue($places);
 
                 if (is_bool($x)) {
                         return PHPExcel_Calculation_Functions::VALUE();
                 }
                 $x = (string) $x;
                 if (preg_match_all('/[01234567]/',$x,$out) != strlen($x)) {
                         return PHPExcel_Calculation_Functions::NaN();
                 }
                 $r = decbin(octdec($x));
 
                 return self::_nbrConversionFormat($r,$places);
         }       //      function OCTTOBIN()

Here is the call graph for this function:

◆ OCTTODEC()

static PHPExcel_Calculation_Engineering::OCTTODEC ( $x )

static

Definition at line 1564 of file Engineering.php.

References $out, $x, PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), string, and PHPExcel_Calculation_Functions\VALUE().

                                             {
                 $x      = PHPExcel_Calculation_Functions::flattenSingleValue($x);
 
                 if (is_bool($x)) {
                         return PHPExcel_Calculation_Functions::VALUE();
                 }
                 $x = (string) $x;
                 if (preg_match_all('/[01234567]/',$x,$out) != strlen($x)) {
                         return PHPExcel_Calculation_Functions::NaN();
                 }
                 return octdec($x);
         }       //      function OCTTODEC()

Here is the call graph for this function:

◆ OCTTOHEX()

static PHPExcel_Calculation_Engineering::OCTTOHEX	(	$x,
		$places = `null`
	)

static

Definition at line 1607 of file Engineering.php.

References $out, $x, PHPExcel_Calculation_Functions\flattenSingleValue(), PHPExcel_Calculation_Functions\NaN(), string, and PHPExcel_Calculation_Functions\VALUE().

                                                           {
                 $x      = PHPExcel_Calculation_Functions::flattenSingleValue($x);
                 $places = PHPExcel_Calculation_Functions::flattenSingleValue($places);
 
                 if (is_bool($x)) {
                         return PHPExcel_Calculation_Functions::VALUE();
                 }
                 $x = (string) $x;
                 if (preg_match_all('/[01234567]/',$x,$out) != strlen($x)) {
                         return PHPExcel_Calculation_Functions::NaN();
                 }
                 $hexVal = strtoupper(dechex(octdec($x)));
 
                 return self::_nbrConversionFormat($hexVal,$places);
         }       //      function OCTTOHEX()

Here is the call graph for this function:

Field Documentation

◆ $_conversionMultipliers

PHPExcel_Calculation_Engineering::$_conversionMultipliers

staticprivate

Initial value:

= array(        'Y'     => array(       'multiplier'    => 1E24,        'name'  => 'yotta'      ),
                                                                                                        'Z'     => array(       'multiplier'    => 1E21,        'name'  => 'zetta'      ),
                                                                                                        'E'     => array(       'multiplier'    => 1E18,        'name'  => 'exa'        ),
                                                                                                        'P'     => array(       'multiplier'    => 1E15,        'name'  => 'peta'       ),
                                                                                                        'T'     => array(       'multiplier'    => 1E12,        'name'  => 'tera'       ),
                                                                                                        'G'     => array(       'multiplier'    => 1E9,         'name'  => 'giga'       ),
                                                                                                        'M'     => array(       'multiplier'    => 1E6,         'name'  => 'mega'       ),
                                                                                                        'k'     => array(       'multiplier'    => 1E3,         'name'  => 'kilo'       ),
                                                                                                        'h'     => array(       'multiplier'    => 1E2,         'name'  => 'hecto'      ),
                                                                                                        'e'     => array(       'multiplier'    => 1E1,         'name'  => 'deka'       ),
                                                                                                        'd'     => array(       'multiplier'    => 1E-1,        'name'  => 'deci'       ),
                                                                                                        'c'     => array(       'multiplier'    => 1E-2,        'name'  => 'centi'      ),
                                                                                                        'm'     => array(       'multiplier'    => 1E-3,        'name'  => 'milli'      ),
                                                                                                        'u'     => array(       'multiplier'    => 1E-6,        'name'  => 'micro'      ),
                                                                                                        'n'     => array(       'multiplier'    => 1E-9,        'name'  => 'nano'       ),
                                                                                                        'p'     => array(       'multiplier'    => 1E-12,       'name'  => 'pico'       ),
                                                                                                        'f'     => array(       'multiplier'    => 1E-15,       'name'  => 'femto'      ),
                                                                                                        'a'     => array(       'multiplier'    => 1E-18,       'name'  => 'atto'       ),
                                                                                                        'z'     => array(       'multiplier'    => 1E-21,       'name'  => 'zepto'      ),
                                                                                                        'y'     => array(       'multiplier'    => 1E-24,       'name'  => 'yocto'      )
                                                                                                 )

Definition at line 127 of file Engineering.php.

◆ $_conversionUnits

PHPExcel_Calculation_Engineering::$_conversionUnits

staticprivate

Definition at line 57 of file Engineering.php.

◆ $_one_sqrtpi

PHPExcel_Calculation_Engineering::$_one_sqrtpi = 0.564189583547756287

staticprivate

Definition at line 2287 of file Engineering.php.

◆ $_two_sqrtpi

PHPExcel_Calculation_Engineering::$_two_sqrtpi = 1.128379167095512574

staticprivate

Definition at line 2226 of file Engineering.php.

◆ $_unitConversions

PHPExcel_Calculation_Engineering::$_unitConversions

staticprivate

Definition at line 154 of file Engineering.php.

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

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

Static Public Member Functions

Static Private Member Functions

Static Private Attributes

Detailed Description

Member Function Documentation

◆ _Besselk0()

◆ _Besselk1()

◆ _Bessely0()

◆ _Bessely1()

◆ _cleanComplex()

◆ _erfcVal()

◆ _erfVal()

◆ _nbrConversionFormat()

◆ _parseComplex()

◆ BESSELI()

◆ BESSELJ()

◆ BESSELK()

◆ BESSELY()

◆ BINTODEC()

◆ BINTOHEX()

◆ BINTOOCT()

◆ COMPLEX()

◆ CONVERTUOM()

◆ DECTOBIN()

◆ DECTOHEX()

◆ DECTOOCT()

◆ DELTA()

◆ ERF()

◆ ERFC()

◆ GESTEP()

◆ getConversionGroups()

◆ getConversionGroupUnitDetails()

◆ getConversionGroupUnits()

◆ getConversionMultipliers()

◆ HEXTOBIN()

◆ HEXTODEC()

◆ HEXTOOCT()

◆ IMABS()

◆ IMAGINARY()

◆ IMARGUMENT()

◆ IMCONJUGATE()

◆ IMCOS()

◆ IMDIV()

◆ IMEXP()

◆ IMLN()

◆ IMLOG10()

◆ IMLOG2()

◆ IMPOWER()

◆ IMPRODUCT()

◆ IMREAL()

◆ IMSIN()

◆ IMSQRT()

◆ IMSUB()

◆ IMSUM()

◆ OCTTOBIN()

◆ OCTTODEC()

◆ OCTTOHEX()

Field Documentation

◆ $_conversionMultipliers

◆ $_conversionUnits

◆ $_one_sqrtpi

◆ $_two_sqrtpi

◆ $_unitConversions