reginaldojunior / winners

app/Vendor/PHPExcel/PHPExcel/Calculation.php

Doc Comments +32 added lines, -3 removed lines

@@ -1852,7 +1852,7 @@ 
 	/**
 	 * Set calculation cache expiration time
 	 *
-	 * @param float $pValue
+	 * @param integer $pValue
 	 */
 	public function setCalculationCacheExpirationTime($pValue = 15) {
 		self::$_calculationCacheExpirationTime = $pValue;
@@ -1966,6 +1966,10 @@ 
 		return $formula;
 	}
 
+	/**
+	 * @param string $fromSeparator
+	 * @param string $toSeparator
+	 */
 	private static function _translateFormula($from,$to,$formula,$fromSeparator,$toSeparator) {
 		//	Convert any Excel function names to the required language
 		if (self::$_localeLanguage !== 'en_us') {
@@ -2386,7 +2390,7 @@ 
 	 * Read the dimensions of a matrix, and re-index it with straight numeric keys starting from row 0, column 0
 	 *
 	 * @param	mixed		&$matrix		matrix operand
-	 * @return	array		An array comprising the number of rows, and number of columns
+	 * @return	integer[]		An array comprising the number of rows, and number of columns
 	 */
 	public static function _getMatrixDimensions(&$matrix) {
 		$matrixRows = count($matrix);
@@ -2409,6 +2413,10 @@ 
 	 *
 	 * @param	mixed		&$matrix1	First matrix operand
 	 * @param	mixed		&$matrix2	Second matrix operand
+	 * @param integer $matrix1Rows
+	 * @param integer $matrix1Columns
+	 * @param integer $matrix2Rows
+	 * @param integer $matrix2Columns
 	 */
 	private static function _resizeMatricesShrink(&$matrix1,&$matrix2,$matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns) {
 		if (($matrix2Columns < $matrix1Columns) || ($matrix2Rows < $matrix1Rows)) {
@@ -2448,6 +2456,10 @@ 
 	 *
 	 * @param	mixed		&$matrix1	First matrix operand
 	 * @param	mixed		&$matrix2	Second matrix operand
+	 * @param integer $matrix1Rows
+	 * @param integer $matrix1Columns
+	 * @param integer $matrix2Rows
+	 * @param integer $matrix2Columns
 	 */
 	private static function _resizeMatricesExtend(&$matrix1,&$matrix2,$matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns) {
 		if (($matrix2Columns < $matrix1Columns) || ($matrix2Rows < $matrix1Rows)) {
@@ -2525,7 +2537,7 @@ 
 	 * Format type and details of an operand for display in the log (based on operand type)
 	 *
 	 * @param	mixed		$value	First matrix operand
-	 * @return	mixed
+	 * @return	string|null
 	 */
 	private function _showTypeDetails($value) {
 		if ($this->writeDebugLog) {
@@ -2558,6 +2570,9 @@ 
 	}	//	function _showTypeDetails()
 
 
+	/**
+	 * @param string $formula
+	 */
 	private static function _convertMatrixReferences($formula) {
 		static $matrixReplaceFrom = array('{',';','}');
 		static $matrixReplaceTo = array('MKMATRIX(MKMATRIX(','),MKMATRIX(','))');
@@ -2615,6 +2630,10 @@ 
 
 
 	// Convert infix to postfix notation
+
+	/**
+	 * @param string $formula
+	 */
 	private function _parseFormula($formula, PHPExcel_Cell $pCell = null) {
 		if (($formula = self::_convertMatrixReferences(trim($formula))) === false) {
 			return FALSE;
@@ -3001,6 +3020,10 @@ 
 	}
 
 	// evaluate postfix notation
+
+	/**
+	 * @param string $cellID
+	 */
 	private function _processTokenStack($tokens, $cellID = null, PHPExcel_Cell $pCell = null) {
 		if ($tokens == false) return false;
 
@@ -3500,6 +3523,9 @@ 
 	}	//	function _executeBinaryComparisonOperation()
 
 
+	/**
+	 * @param string $matrixFunction
+	 */
 	private function _executeNumericBinaryOperation($cellID,$operand1,$operand2,$operation,$matrixFunction,&$stack) {
 		//	Validate the two operands
 		if (!$this->_validateBinaryOperand($cellID,$operand1,$stack)) return false;
@@ -3580,6 +3606,9 @@ 
 	}	//	function _executeNumericBinaryOperation()
 
 
+	/**
+	 * @param string $message
+	 */
 	private function _writeDebug($message) {
 		//	Only write the debug log if logging is enabled
 		if ($this->writeDebugLog) {

Spacing +292 added lines, -292 removed lines

@@ -27,27 +27,27 @@ 
 
 
 /** PHPExcel root directory */
-if (!defined('PHPEXCEL_ROOT')) {
+if ( ! defined('PHPEXCEL_ROOT')) {
 	/**
 	 * @ignore
 	 */
-	define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../');
-	require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	define('PHPEXCEL_ROOT', dirname(__FILE__).'/../');
+	require(PHPEXCEL_ROOT.'PHPExcel/Autoloader.php');
 }
 
 
-if (!defined('CALCULATION_REGEXP_CELLREF')) {
+if ( ! defined('CALCULATION_REGEXP_CELLREF')) {
 	//	Test for support of \P (multibyte options) in PCRE
-	if(defined('PREG_BAD_UTF8_ERROR')) {
+	if (defined('PREG_BAD_UTF8_ERROR')) {
 		//	Cell reference (cell or range of cells, with or without a sheet reference)
-		define('CALCULATION_REGEXP_CELLREF','((([^\s,!&%^\/\*\+<>=-]*)|(\'[^\']*\')|(\"[^\"]*\"))!)?\$?([a-z]{1,3})\$?(\d{1,7})');
+		define('CALCULATION_REGEXP_CELLREF', '((([^\s,!&%^\/\*\+<>=-]*)|(\'[^\']*\')|(\"[^\"]*\"))!)?\$?([a-z]{1,3})\$?(\d{1,7})');
 		//	Named Range of cells
-		define('CALCULATION_REGEXP_NAMEDRANGE','((([^\s,!&%^\/\*\+<>=-]*)|(\'[^\']*\')|(\"[^\"]*\"))!)?([_A-Z][_A-Z0-9\.]*)');
+		define('CALCULATION_REGEXP_NAMEDRANGE', '((([^\s,!&%^\/\*\+<>=-]*)|(\'[^\']*\')|(\"[^\"]*\"))!)?([_A-Z][_A-Z0-9\.]*)');
 	} else {
 		//	Cell reference (cell or range of cells, with or without a sheet reference)
-		define('CALCULATION_REGEXP_CELLREF','(((\w*)|(\'[^\']*\')|(\"[^\"]*\"))!)?\$?([a-z]{1,3})\$?(\d+)');
+		define('CALCULATION_REGEXP_CELLREF', '(((\w*)|(\'[^\']*\')|(\"[^\"]*\"))!)?\$?([a-z]{1,3})\$?(\d+)');
 		//	Named Range of cells
-		define('CALCULATION_REGEXP_NAMEDRANGE','(((\w*)|(\'.*\')|(\".*\"))!)?([_A-Z][_A-Z0-9\.]*)');
+		define('CALCULATION_REGEXP_NAMEDRANGE', '(((\w*)|(\'.*\')|(\".*\"))!)?([_A-Z][_A-Z0-9\.]*)');
 	}
 }
 
@@ -68,15 +68,15 @@ 
 	//	String operand
 	const CALCULATION_REGEXP_STRING		= '"(?:[^"]|"")*"';
 	//	Opening bracket
-	const CALCULATION_REGEXP_OPENBRACE	= '\(';
+	const CALCULATION_REGEXP_OPENBRACE = '\(';
 	//	Function (allow for the old @ symbol that could be used to prefix a function, but we'll ignore it)
-	const CALCULATION_REGEXP_FUNCTION	= '@?([A-Z][A-Z0-9\.]*)[\s]*\(';
+	const CALCULATION_REGEXP_FUNCTION = '@?([A-Z][A-Z0-9\.]*)[\s]*\(';
 	//	Cell reference (cell or range of cells, with or without a sheet reference)
-	const CALCULATION_REGEXP_CELLREF	= CALCULATION_REGEXP_CELLREF;
+	const CALCULATION_REGEXP_CELLREF = CALCULATION_REGEXP_CELLREF;
 	//	Named Range of cells
-	const CALCULATION_REGEXP_NAMEDRANGE	= CALCULATION_REGEXP_NAMEDRANGE;
+	const CALCULATION_REGEXP_NAMEDRANGE = CALCULATION_REGEXP_NAMEDRANGE;
 	//	Error
-	const CALCULATION_REGEXP_ERROR		= '\#[A-Z][A-Z0_\/]*[!\?]?';
+	const CALCULATION_REGEXP_ERROR = '\#[A-Z][A-Z0_\/]*[!\?]?';
 
 
 	/** constants */
@@ -84,7 +84,7 @@ 
 	const RETURN_ARRAY_AS_VALUE = 'value';
 	const RETURN_ARRAY_AS_ARRAY = 'array';
 
-	private static $returnArrayAsType	= self::RETURN_ARRAY_AS_VALUE;
+	private static $returnArrayAsType = self::RETURN_ARRAY_AS_VALUE;
 
 
 	/**
@@ -102,7 +102,7 @@ 
 	 * @access	private
 	 * @var array
 	 */
-	private static $_calculationCache = array ();
+	private static $_calculationCache = array();
 
 
 	/**
@@ -130,10 +130,10 @@ 
 	 * @access	private
 	 * @var array
 	 */
-	private static $_operators			= array('+' => true,	'-' => true,	'*' => true,	'/' => true,
-												'^' => true,	'&' => true,	'%' => false,	'~' => false,
-												'>' => true,	'<' => true,	'=' => true,	'>=' => true,
-												'<=' => true,	'<>' => true,	'|' => true,	':' => true
+	private static $_operators = array('+' => true, '-' => true, '*' => true, '/' => true,
+												'^' => true, '&' => true, '%' => false, '~' => false,
+												'>' => true, '<' => true, '=' => true, '>=' => true,
+												'<=' => true, '<>' => true, '|' => true, ':' => true
 											   );
 
 
@@ -143,10 +143,10 @@ 
 	 * @access	private
 	 * @var array
 	 */
-	private static $_binaryOperators	= array('+' => true,	'-' => true,	'*' => true,	'/' => true,
-												'^' => true,	'&' => true,	'>' => true,	'<' => true,
-												'=' => true,	'>=' => true,	'<=' => true,	'<>' => true,
-												'|' => true,	':' => true
+	private static $_binaryOperators = array('+' => true, '-' => true, '*' => true, '/' => true,
+												'^' => true, '&' => true, '>' => true, '<' => true,
+												'=' => true, '>=' => true, '<=' => true, '<>' => true,
+												'|' => true, ':' => true
 											   );
 
 	/**
@@ -215,15 +215,15 @@ 
 	public $cyclicFormulaCount = 0;
 
 
-	private $_savedPrecision	= 12;
+	private $_savedPrecision = 12;
 
 
-	private static $_localeLanguage = 'en_us';					//	US English	(default locale)
-	private static $_validLocaleLanguages = array(	'en'		//	English		(default language)
+	private static $_localeLanguage = 'en_us'; //	US English	(default locale)
+	private static $_validLocaleLanguages = array('en'		//	English		(default language)
 												 );
 	private static $_localeArgumentSeparator = ',';
 	private static $_localeFunctions = array();
-	public static $_localeBoolean = array(	'TRUE'	=> 'TRUE',
+	public static $_localeBoolean = array('TRUE'	=> 'TRUE',
 											'FALSE'	=> 'FALSE',
 											'NULL'	=> 'NULL'
 										  );
@@ -1682,8 +1682,8 @@ 
 
 	private function __construct() {
 		$localeFileDirectory = PHPEXCEL_ROOT.'PHPExcel/locale/';
-		foreach (glob($localeFileDirectory.'/*',GLOB_ONLYDIR) as $filename) {
-			$filename = substr($filename,strlen($localeFileDirectory)+1);
+		foreach (glob($localeFileDirectory.'/*', GLOB_ONLYDIR) as $filename) {
+			$filename = substr($filename, strlen($localeFileDirectory) + 1);
 			if ($filename != 'en') {
 				self::$_validLocaleLanguages[] = $filename;
 			}
@@ -1692,14 +1692,14 @@ 
 		$setPrecision = (PHP_INT_SIZE == 4) ? 12 : 16;
 		$this->_savedPrecision = ini_get('precision');
 		if ($this->_savedPrecision < $setPrecision) {
-			ini_set('precision',$setPrecision);
+			ini_set('precision', $setPrecision);
 		}
 	}	//	function __construct()
 
 
 	public function __destruct() {
 		if ($this->_savedPrecision != ini_get('precision')) {
-			ini_set('precision',$this->_savedPrecision);
+			ini_set('precision', $this->_savedPrecision);
 		}
 	}
 
@@ -1710,7 +1710,7 @@ 
 	 * @return PHPExcel_Calculation
 	 */
 	public static function getInstance() {
-		if (!isset(self::$_instance) || (self::$_instance === NULL)) {
+		if ( ! isset(self::$_instance) || (self::$_instance === NULL)) {
 			self::$_instance = new PHPExcel_Calculation();
 		}
 
@@ -1739,7 +1739,7 @@ 
 	 * @throws	Exception
 	 */
 	public final function __clone() {
-		throw new Exception ('Cloning a Singleton is not allowed!');
+		throw new Exception('Cloning a Singleton is not allowed!');
 	}	//	function __clone()
 
 
@@ -1876,15 +1876,15 @@ 
 	 *
 	 * @return boolean
 	 */
-	public function setLocale($locale='en_us') {
+	public function setLocale($locale = 'en_us') {
 		//	Identify our locale and language
 		$language = $locale = strtolower($locale);
-		if (strpos($locale,'_') !== false) {
-			list($language) = explode('_',$locale);
+		if (strpos($locale, '_') !== false) {
+			list($language) = explode('_', $locale);
 		}
 
 		//	Test whether we have any language data for this language (any locale)
-		if (in_array($language,self::$_validLocaleLanguages)) {
+		if (in_array($language, self::$_validLocaleLanguages)) {
 			//	initialise language/locale settings
 			self::$_localeFunctions = array();
 			self::$_localeArgumentSeparator = ',';
@@ -1892,20 +1892,20 @@ 
 			//	Default is English, if user isn't requesting english, then read the necessary data from the locale files
 			if ($locale != 'en_us') {
 				//	Search for a file with a list of function names for locale
-				$functionNamesFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.str_replace('_',DIRECTORY_SEPARATOR,$locale).DIRECTORY_SEPARATOR.'functions';
-				if (!file_exists($functionNamesFile)) {
+				$functionNamesFile = PHPEXCEL_ROOT.'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.str_replace('_', DIRECTORY_SEPARATOR, $locale).DIRECTORY_SEPARATOR.'functions';
+				if ( ! file_exists($functionNamesFile)) {
 					//	If there isn't a locale specific function file, look for a language specific function file
-					$functionNamesFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.$language.DIRECTORY_SEPARATOR.'functions';
-					if (!file_exists($functionNamesFile)) {
+					$functionNamesFile = PHPEXCEL_ROOT.'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.$language.DIRECTORY_SEPARATOR.'functions';
+					if ( ! file_exists($functionNamesFile)) {
 						return false;
 					}
 				}
 				//	Retrieve the list of locale or language specific function names
-				$localeFunctions = file($functionNamesFile,FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
+				$localeFunctions = file($functionNamesFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
 				foreach ($localeFunctions as $localeFunction) {
-					list($localeFunction) = explode('##',$localeFunction);	//	Strip out comments
-					if (strpos($localeFunction,'=') !== false) {
-						list($fName,$lfName) = explode('=',$localeFunction);
+					list($localeFunction) = explode('##', $localeFunction); //	Strip out comments
+					if (strpos($localeFunction, '=') !== false) {
+						list($fName, $lfName) = explode('=', $localeFunction);
 						$fName = trim($fName);
 						$lfName = trim($lfName);
 						if ((isset(self::$_PHPExcelFunctions[$fName])) && ($lfName != '') && ($fName != $lfName)) {
@@ -1917,16 +1917,16 @@ 
 				if (isset(self::$_localeFunctions['TRUE'])) { self::$_localeBoolean['TRUE'] = self::$_localeFunctions['TRUE']; }
 				if (isset(self::$_localeFunctions['FALSE'])) { self::$_localeBoolean['FALSE'] = self::$_localeFunctions['FALSE']; }
 
-				$configFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.str_replace('_',DIRECTORY_SEPARATOR,$locale).DIRECTORY_SEPARATOR.'config';
-				if (!file_exists($configFile)) {
-					$configFile = PHPEXCEL_ROOT . 'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.$language.DIRECTORY_SEPARATOR.'config';
+				$configFile = PHPEXCEL_ROOT.'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.str_replace('_', DIRECTORY_SEPARATOR, $locale).DIRECTORY_SEPARATOR.'config';
+				if ( ! file_exists($configFile)) {
+					$configFile = PHPEXCEL_ROOT.'PHPExcel'.DIRECTORY_SEPARATOR.'locale'.DIRECTORY_SEPARATOR.$language.DIRECTORY_SEPARATOR.'config';
 				}
 				if (file_exists($configFile)) {
-					$localeSettings = file($configFile,FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
+					$localeSettings = file($configFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
 					foreach ($localeSettings as $localeSetting) {
-						list($localeSetting) = explode('##',$localeSetting);	//	Strip out comments
-						if (strpos($localeSetting,'=') !== false) {
-							list($settingName,$settingValue) = explode('=',$localeSetting);
+						list($localeSetting) = explode('##', $localeSetting); //	Strip out comments
+						if (strpos($localeSetting, '=') !== false) {
+							list($settingName, $settingValue) = explode('=', $localeSetting);
 							$settingName = strtoupper(trim($settingName));
 							switch ($settingName) {
 								case 'ARGUMENTSEPARATOR' :
@@ -1948,48 +1948,48 @@ 
 
 
 
-	public static function _translateSeparator($fromSeparator,$toSeparator,$formula,&$inBraces) {
+	public static function _translateSeparator($fromSeparator, $toSeparator, $formula, &$inBraces) {
 		$strlen = mb_strlen($formula);
 		for ($i = 0; $i < $strlen; ++$i) {
-			$chr = mb_substr($formula,$i,1);
+			$chr = mb_substr($formula, $i, 1);
 			switch ($chr) {
 				case '{' :	$inBraces = true;
 							break;
 				case '}' :	$inBraces = false;
 							break;
 				case $fromSeparator :
-							if (!$inBraces) {
-								$formula = mb_substr($formula,0,$i).$toSeparator.mb_substr($formula,$i+1);
+							if ( ! $inBraces) {
+								$formula = mb_substr($formula, 0, $i).$toSeparator.mb_substr($formula, $i + 1);
 							}
 			}
 		}
 		return $formula;
 	}
 
-	private static function _translateFormula($from,$to,$formula,$fromSeparator,$toSeparator) {
+	private static function _translateFormula($from, $to, $formula, $fromSeparator, $toSeparator) {
 		//	Convert any Excel function names to the required language
 		if (self::$_localeLanguage !== 'en_us') {
 			$inBraces = false;
 			//	If there is the possibility of braces within a quoted string, then we don't treat those as matrix indicators
-			if (strpos($formula,'"') !== false) {
+			if (strpos($formula, '"') !== false) {
 				//	So instead we skip replacing in any quoted strings by only replacing in every other array element after we've exploded
 				//		the formula
-				$temp = explode('"',$formula);
+				$temp = explode('"', $formula);
 				$i = false;
-				foreach($temp as &$value) {
+				foreach ($temp as &$value) {
 					//	Only count/replace in alternating array entries
-					if ($i = !$i) {
-						$value = preg_replace($from,$to,$value);
-						$value = self::_translateSeparator($fromSeparator,$toSeparator,$value,$inBraces);
+					if ($i = ! $i) {
+						$value = preg_replace($from, $to, $value);
+						$value = self::_translateSeparator($fromSeparator, $toSeparator, $value, $inBraces);
 					}
 				}
 				unset($value);
 				//	Then rebuild the formula string
-				$formula = implode('"',$temp);
+				$formula = implode('"', $temp);
 			} else {
 				//	If there's no quoted strings, then we do a simple count/replace
-				$formula = preg_replace($from,$to,$formula);
-				$formula = self::_translateSeparator($fromSeparator,$toSeparator,$formula,$inBraces);
+				$formula = preg_replace($from, $to, $formula);
+				$formula = self::_translateSeparator($fromSeparator, $toSeparator, $formula, $inBraces);
 			}
 		}
 
@@ -2002,10 +2002,10 @@ 
 	public function _translateFormulaToLocale($formula) {
 		if (self::$functionReplaceFromExcel === NULL) {
 			self::$functionReplaceFromExcel = array();
-			foreach(array_keys(self::$_localeFunctions) as $excelFunctionName) {
+			foreach (array_keys(self::$_localeFunctions) as $excelFunctionName) {
 				self::$functionReplaceFromExcel[] = '/(@?[^\w\.])'.preg_quote($excelFunctionName).'([\s]*\()/Ui';
 			}
-			foreach(array_keys(self::$_localeBoolean) as $excelBoolean) {
+			foreach (array_keys(self::$_localeBoolean) as $excelBoolean) {
 				self::$functionReplaceFromExcel[] = '/(@?[^\w\.])'.preg_quote($excelBoolean).'([^\w\.])/Ui';
 			}
 
@@ -2013,49 +2013,49 @@ 
 
 		if (self::$functionReplaceToLocale === NULL) {
 			self::$functionReplaceToLocale = array();
-			foreach(array_values(self::$_localeFunctions) as $localeFunctionName) {
+			foreach (array_values(self::$_localeFunctions) as $localeFunctionName) {
 				self::$functionReplaceToLocale[] = '$1'.trim($localeFunctionName).'$2';
 			}
-			foreach(array_values(self::$_localeBoolean) as $localeBoolean) {
+			foreach (array_values(self::$_localeBoolean) as $localeBoolean) {
 				self::$functionReplaceToLocale[] = '$1'.trim($localeBoolean).'$2';
 			}
 		}
 
-		return self::_translateFormula(self::$functionReplaceFromExcel,self::$functionReplaceToLocale,$formula,',',self::$_localeArgumentSeparator);
+		return self::_translateFormula(self::$functionReplaceFromExcel, self::$functionReplaceToLocale, $formula, ',', self::$_localeArgumentSeparator);
 	}	//	function _translateFormulaToLocale()
 
 
-	private static $functionReplaceFromLocale	= null;
-	private static $functionReplaceToExcel		= null;
+	private static $functionReplaceFromLocale = null;
+	private static $functionReplaceToExcel = null;
 
 	public function _translateFormulaToEnglish($formula) {
 		if (self::$functionReplaceFromLocale === NULL) {
 			self::$functionReplaceFromLocale = array();
-			foreach(array_values(self::$_localeFunctions) as $localeFunctionName) {
+			foreach (array_values(self::$_localeFunctions) as $localeFunctionName) {
 				self::$functionReplaceFromLocale[] = '/(@?[^\w\.])'.preg_quote($localeFunctionName).'([\s]*\()/Ui';
 			}
-			foreach(array_values(self::$_localeBoolean) as $excelBoolean) {
+			foreach (array_values(self::$_localeBoolean) as $excelBoolean) {
 				self::$functionReplaceFromLocale[] = '/(@?[^\w\.])'.preg_quote($excelBoolean).'([^\w\.])/Ui';
 			}
 		}
 
 		if (self::$functionReplaceToExcel === NULL) {
 			self::$functionReplaceToExcel = array();
-			foreach(array_keys(self::$_localeFunctions) as $excelFunctionName) {
+			foreach (array_keys(self::$_localeFunctions) as $excelFunctionName) {
 				self::$functionReplaceToExcel[] = '$1'.trim($excelFunctionName).'$2';
 			}
-			foreach(array_keys(self::$_localeBoolean) as $excelBoolean) {
+			foreach (array_keys(self::$_localeBoolean) as $excelBoolean) {
 				self::$functionReplaceToExcel[] = '$1'.trim($excelBoolean).'$2';
 			}
 		}
 
-		return self::_translateFormula(self::$functionReplaceFromLocale,self::$functionReplaceToExcel,$formula,self::$_localeArgumentSeparator,',');
+		return self::_translateFormula(self::$functionReplaceFromLocale, self::$functionReplaceToExcel, $formula, self::$_localeArgumentSeparator, ',');
 	}	//	function _translateFormulaToEnglish()
 
 
 	public static function _localeFunc($function) {
 		if (self::$_localeLanguage !== 'en_us') {
-			$functionName = trim($function,'(');
+			$functionName = trim($function, '(');
 			if (isset(self::$_localeFunctions[$functionName])) {
 				$brace = ($functionName != $function);
 				$function = self::$_localeFunctions[$functionName];
@@ -2084,7 +2084,7 @@ 
 			//	Return strings wrapped in quotes
 			return '"'.$value.'"';
 		//	Convert numeric errors to NaN error
-		} else if((is_float($value)) && ((is_nan($value)) || (is_infinite($value)))) {
+		} else if ((is_float($value)) && ((is_nan($value)) || (is_infinite($value)))) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
 
@@ -2100,11 +2100,11 @@ 
 	 */
 	public static function _unwrapResult($value) {
 		if (is_string($value)) {
-			if ((isset($value{0})) && ($value{0} == '"') && (substr($value,-1) == '"')) {
-				return substr($value,1,-1);
+			if ((isset($value{0})) && ($value{0} == '"') && (substr($value, -1) == '"')) {
+				return substr($value, 1, -1);
 			}
 		//	Convert numeric errors to NaN error
-		} else if((is_float($value)) && ((is_nan($value)) || (is_infinite($value)))) {
+		} else if ((is_float($value)) && ((is_nan($value)) || (is_infinite($value)))) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
 		return $value;
@@ -2176,11 +2176,11 @@ 
 				//	If keys are numeric, then it's a matrix result rather than a cell range result, so we permit it
 				$r = array_keys($result);
 				$r = array_shift($r);
-				if (!is_numeric($r)) { return PHPExcel_Calculation_Functions::VALUE(); }
+				if ( ! is_numeric($r)) { return PHPExcel_Calculation_Functions::VALUE(); }
 				if (is_array($result[$r])) {
 					$c = array_keys($result[$r]);
 					$c = array_shift($c);
-					if (!is_numeric($c)) {
+					if ( ! is_numeric($c)) {
 						return PHPExcel_Calculation_Functions::VALUE();
 					}
 				}
@@ -2190,7 +2190,7 @@ 
 
 		if ($result === NULL) {
 			return 0;
-		} elseif((is_float($result)) && ((is_nan($result)) || (is_infinite($result)))) {
+		} elseif ((is_float($result)) && ((is_nan($result)) || (is_infinite($result)))) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
 		return $result;
@@ -2208,9 +2208,9 @@ 
 		//	Basic validation that this is indeed a formula
 		//	We return an empty array if not
 		$formula = trim($formula);
-		if ((!isset($formula{0})) || ($formula{0} != '=')) return array();
-		$formula = ltrim(substr($formula,1));
-		if (!isset($formula{0})) return array();
+		if (( ! isset($formula{0})) || ($formula{0} != '=')) return array();
+		$formula = ltrim(substr($formula, 1));
+		if ( ! isset($formula{0})) return array();
 
 		//	Parse the formula and return the token stack
 		return $this->_parseFormula($formula);
@@ -2224,7 +2224,7 @@ 
 	 * @return	mixed
 	 * @throws	Exception
 	 */
-	public function calculateFormula($formula, $cellID=null, PHPExcel_Cell $pCell = null) {
+	public function calculateFormula($formula, $cellID = null, PHPExcel_Cell $pCell = null) {
 		//	Initialise the logging settings
 		$this->formulaError = null;
 		$this->debugLog = $this->debugLogStack = array();
@@ -2256,7 +2256,7 @@ 
 	 * @return	mixed
 	 * @throws	Exception
 	 */
-	public function _calculateFormulaValue($formula, $cellID=null, PHPExcel_Cell $pCell = null) {
+	public function _calculateFormulaValue($formula, $cellID = null, PHPExcel_Cell $pCell = null) {
 //		echo '<b>'.$cellID.'</b><br />';
 		$cellValue = '';
 
@@ -2264,8 +2264,8 @@ 
 		//	We simply return the "cell value" (formula) if not
 		$formula = trim($formula);
 		if ($formula{0} != '=') return self::_wrapResult($formula);
-		$formula = ltrim(substr($formula,1));
-		if (!isset($formula{0})) return self::_wrapResult($formula);
+		$formula = ltrim(substr($formula, 1));
+		if ( ! isset($formula{0})) return self::_wrapResult($formula);
 
 		$wsTitle = "\x00Wrk";
 		if ($pCell !== NULL) {
@@ -2304,7 +2304,7 @@ 
 			}
 		}
 
-		if ((in_array($wsTitle.'!'.$cellID,$this->debugLogStack)) && ($wsTitle != "\x00Wrk")) {
+		if ((in_array($wsTitle.'!'.$cellID, $this->debugLogStack)) && ($wsTitle != "\x00Wrk")) {
 			if ($this->cyclicFormulaCount <= 0) {
 				return $this->_raiseFormulaError('Cyclic Reference in Formula');
 			} elseif (($this->_cyclicFormulaCount >= $this->cyclicFormulaCount) &&
@@ -2352,33 +2352,33 @@ 
 	 *											1 = shrink to fit
 	 *											2 = extend to fit
 	 */
-	private static function _checkMatrixOperands(&$operand1,&$operand2,$resize = 1) {
+	private static function _checkMatrixOperands(&$operand1, &$operand2, $resize = 1) {
 		//	Examine each of the two operands, and turn them into an array if they aren't one already
 		//	Note that this function should only be called if one or both of the operand is already an array
-		if (!is_array($operand1)) {
-			list($matrixRows,$matrixColumns) = self::_getMatrixDimensions($operand2);
-			$operand1 = array_fill(0,$matrixRows,array_fill(0,$matrixColumns,$operand1));
+		if ( ! is_array($operand1)) {
+			list($matrixRows, $matrixColumns) = self::_getMatrixDimensions($operand2);
+			$operand1 = array_fill(0, $matrixRows, array_fill(0, $matrixColumns, $operand1));
 			$resize = 0;
-		} elseif (!is_array($operand2)) {
-			list($matrixRows,$matrixColumns) = self::_getMatrixDimensions($operand1);
-			$operand2 = array_fill(0,$matrixRows,array_fill(0,$matrixColumns,$operand2));
+		} elseif ( ! is_array($operand2)) {
+			list($matrixRows, $matrixColumns) = self::_getMatrixDimensions($operand1);
+			$operand2 = array_fill(0, $matrixRows, array_fill(0, $matrixColumns, $operand2));
 			$resize = 0;
 		}
 
-		list($matrix1Rows,$matrix1Columns) = self::_getMatrixDimensions($operand1);
-		list($matrix2Rows,$matrix2Columns) = self::_getMatrixDimensions($operand2);
+		list($matrix1Rows, $matrix1Columns) = self::_getMatrixDimensions($operand1);
+		list($matrix2Rows, $matrix2Columns) = self::_getMatrixDimensions($operand2);
 		if (($matrix1Rows == $matrix2Columns) && ($matrix2Rows == $matrix1Columns)) {
 			$resize = 1;
 		}
 
 		if ($resize == 2) {
 			//	Given two matrices of (potentially) unequal size, convert the smaller in each dimension to match the larger
-			self::_resizeMatricesExtend($operand1,$operand2,$matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns);
+			self::_resizeMatricesExtend($operand1, $operand2, $matrix1Rows, $matrix1Columns, $matrix2Rows, $matrix2Columns);
 		} elseif ($resize == 1) {
 			//	Given two matrices of (potentially) unequal size, convert the larger in each dimension to match the smaller
-			self::_resizeMatricesShrink($operand1,$operand2,$matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns);
+			self::_resizeMatricesShrink($operand1, $operand2, $matrix1Rows, $matrix1Columns, $matrix2Rows, $matrix2Columns);
 		}
-		return array( $matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns);
+		return array($matrix1Rows, $matrix1Columns, $matrix2Rows, $matrix2Columns);
 	}	//	function _checkMatrixOperands()
 
 
@@ -2391,16 +2391,16 @@ 
 	public static function _getMatrixDimensions(&$matrix) {
 		$matrixRows = count($matrix);
 		$matrixColumns = 0;
-		foreach($matrix as $rowKey => $rowValue) {
-			$matrixColumns = max(count($rowValue),$matrixColumns);
-			if (!is_array($rowValue)) {
+		foreach ($matrix as $rowKey => $rowValue) {
+			$matrixColumns = max(count($rowValue), $matrixColumns);
+			if ( ! is_array($rowValue)) {
 				$matrix[$rowKey] = array($rowValue);
 			} else {
 				$matrix[$rowKey] = array_values($rowValue);
 			}
 		}
 		$matrix = array_values($matrix);
-		return array($matrixRows,$matrixColumns);
+		return array($matrixRows, $matrixColumns);
 	}	//	function _getMatrixDimensions()
 
 
@@ -2410,7 +2410,7 @@ 
 	 * @param	mixed		&$matrix1	First matrix operand
 	 * @param	mixed		&$matrix2	Second matrix operand
 	 */
-	private static function _resizeMatricesShrink(&$matrix1,&$matrix2,$matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns) {
+	private static function _resizeMatricesShrink(&$matrix1, &$matrix2, $matrix1Rows, $matrix1Columns, $matrix2Rows, $matrix2Columns) {
 		if (($matrix2Columns < $matrix1Columns) || ($matrix2Rows < $matrix1Rows)) {
 			if ($matrix2Columns < $matrix1Columns) {
 				for ($i = 0; $i < $matrix1Rows; ++$i) {
@@ -2449,18 +2449,18 @@ 
 	 * @param	mixed		&$matrix1	First matrix operand
 	 * @param	mixed		&$matrix2	Second matrix operand
 	 */
-	private static function _resizeMatricesExtend(&$matrix1,&$matrix2,$matrix1Rows,$matrix1Columns,$matrix2Rows,$matrix2Columns) {
+	private static function _resizeMatricesExtend(&$matrix1, &$matrix2, $matrix1Rows, $matrix1Columns, $matrix2Rows, $matrix2Columns) {
 		if (($matrix2Columns < $matrix1Columns) || ($matrix2Rows < $matrix1Rows)) {
 			if ($matrix2Columns < $matrix1Columns) {
 				for ($i = 0; $i < $matrix2Rows; ++$i) {
-					$x = $matrix2[$i][$matrix2Columns-1];
+					$x = $matrix2[$i][$matrix2Columns - 1];
 					for ($j = $matrix2Columns; $j < $matrix1Columns; ++$j) {
 						$matrix2[$i][$j] = $x;
 					}
 				}
 			}
 			if ($matrix2Rows < $matrix1Rows) {
-				$x = $matrix2[$matrix2Rows-1];
+				$x = $matrix2[$matrix2Rows - 1];
 				for ($i = 0; $i < $matrix1Rows; ++$i) {
 					$matrix2[$i] = $x;
 				}
@@ -2470,14 +2470,14 @@ 
 		if (($matrix1Columns < $matrix2Columns) || ($matrix1Rows < $matrix2Rows)) {
 			if ($matrix1Columns < $matrix2Columns) {
 				for ($i = 0; $i < $matrix1Rows; ++$i) {
-					$x = $matrix1[$i][$matrix1Columns-1];
+					$x = $matrix1[$i][$matrix1Columns - 1];
 					for ($j = $matrix1Columns; $j < $matrix2Columns; ++$j) {
 						$matrix1[$i][$j] = $x;
 					}
 				}
 			}
 			if ($matrix1Rows < $matrix2Rows) {
-				$x = $matrix1[$matrix1Rows-1];
+				$x = $matrix1[$matrix1Rows - 1];
 				for ($i = 0; $i < $matrix2Rows; ++$i) {
 					$matrix1[$i] = $x;
 				}
@@ -2502,18 +2502,18 @@ 
 			if (is_array($value)) {
 				$returnMatrix = array();
 				$pad = $rpad = ', ';
-				foreach($value as $row) {
+				foreach ($value as $row) {
 					if (is_array($row)) {
-						$returnMatrix[] = implode($pad,array_map(array($this,'_showValue'),$row));
+						$returnMatrix[] = implode($pad, array_map(array($this, '_showValue'), $row));
 						$rpad = '; ';
 					} else {
 						$returnMatrix[] = $this->_showValue($row);
 					}
 				}
-				return '{ '.implode($rpad,$returnMatrix).' }';
-			} elseif(is_string($value) && (trim($value,'"') == $value)) {
+				return '{ '.implode($rpad, $returnMatrix).' }';
+			} elseif (is_string($value) && (trim($value, '"') == $value)) {
 				return '"'.$value.'"';
-			} elseif(is_bool($value)) {
+			} elseif (is_bool($value)) {
 				return ($value) ? self::$_localeBoolean['TRUE'] : self::$_localeBoolean['FALSE'];
 			}
 		}
@@ -2538,11 +2538,11 @@ 
 				return 'a NULL value';
 			} elseif (is_float($value)) {
 				$typeString = 'a floating point number';
-			} elseif(is_int($value)) {
+			} elseif (is_int($value)) {
 				$typeString = 'an integer number';
-			} elseif(is_bool($value)) {
+			} elseif (is_bool($value)) {
 				$typeString = 'a boolean';
-			} elseif(is_array($value)) {
+			} elseif (is_array($value)) {
 				$typeString = 'a matrix';
 			} else {
 				if ($value == '') {
@@ -2559,35 +2559,35 @@ 
 
 
 	private static function _convertMatrixReferences($formula) {
-		static $matrixReplaceFrom = array('{',';','}');
-		static $matrixReplaceTo = array('MKMATRIX(MKMATRIX(','),MKMATRIX(','))');
+		static $matrixReplaceFrom = array('{', ';', '}');
+		static $matrixReplaceTo = array('MKMATRIX(MKMATRIX(', '),MKMATRIX(', '))');
 
 		//	Convert any Excel matrix references to the MKMATRIX() function
-		if (strpos($formula,'{') !== false) {
+		if (strpos($formula, '{') !== false) {
 			//	If there is the possibility of braces within a quoted string, then we don't treat those as matrix indicators
-			if (strpos($formula,'"') !== false) {
+			if (strpos($formula, '"') !== false) {
 				//	So instead we skip replacing in any quoted strings by only replacing in every other array element after we've exploded
 				//		the formula
-				$temp = explode('"',$formula);
+				$temp = explode('"', $formula);
 				//	Open and Closed counts used for trapping mismatched braces in the formula
 				$openCount = $closeCount = 0;
 				$i = false;
-				foreach($temp as &$value) {
+				foreach ($temp as &$value) {
 					//	Only count/replace in alternating array entries
-					if ($i = !$i) {
-						$openCount += substr_count($value,'{');
-						$closeCount += substr_count($value,'}');
-						$value = str_replace($matrixReplaceFrom,$matrixReplaceTo,$value);
+					if ($i = ! $i) {
+						$openCount += substr_count($value, '{');
+						$closeCount += substr_count($value, '}');
+						$value = str_replace($matrixReplaceFrom, $matrixReplaceTo, $value);
 					}
 				}
 				unset($value);
 				//	Then rebuild the formula string
-				$formula = implode('"',$temp);
+				$formula = implode('"', $temp);
 			} else {
 				//	If there's no quoted strings, then we do a simple count/replace
-				$openCount = substr_count($formula,'{');
-				$closeCount = substr_count($formula,'}');
-				$formula = str_replace($matrixReplaceFrom,$matrixReplaceTo,$formula);
+				$openCount = substr_count($formula, '{');
+				$closeCount = substr_count($formula, '}');
+				$formula = str_replace($matrixReplaceFrom, $matrixReplaceTo, $formula);
 			}
 			//	Trap for mismatched braces and trigger an appropriate error
 			if ($openCount < $closeCount) {
@@ -2627,28 +2627,28 @@ 
 		//	Binary Operators
 		//	These operators always work on two values
 		//	Array key is the operator, the value indicates whether this is a left or right associative operator
-		$operatorAssociativity	= array('^' => 0,															//	Exponentiation
-										'*' => 0, '/' => 0, 												//	Multiplication and Division
-										'+' => 0, '-' => 0,													//	Addition and Subtraction
-										'&' => 0,															//	Concatenation
-										'|' => 0, ':' => 0,													//	Intersect and Range
+		$operatorAssociativity = array('^' => 0, //	Exponentiation
+										'*' => 0, '/' => 0, //	Multiplication and Division
+										'+' => 0, '-' => 0, //	Addition and Subtraction
+										'&' => 0, //	Concatenation
+										'|' => 0, ':' => 0, //	Intersect and Range
 										'>' => 0, '<' => 0, '=' => 0, '>=' => 0, '<=' => 0, '<>' => 0		//	Comparison
 								 	  );
 		//	Comparison (Boolean) Operators
 		//	These operators work on two values, but always return a boolean result
-		$comparisonOperators	= array('>' => true, '<' => true, '=' => true, '>=' => true, '<=' => true, '<>' => true);
+		$comparisonOperators = array('>' => true, '<' => true, '=' => true, '>=' => true, '<=' => true, '<>' => true);
 
 		//	Operator Precedence
 		//	This list includes all valid operators, whether binary (including boolean) or unary (such as %)
 		//	Array key is the operator, the value is its precedence
-		$operatorPrecedence	= array(':' => 8,																//	Range
-									'|' => 7,																//	Intersect
-									'~' => 6,																//	Negation
-									'%' => 5,																//	Percentage
-									'^' => 4,																//	Exponentiation
-									'*' => 3, '/' => 3, 													//	Multiplication and Division
-									'+' => 2, '-' => 2,														//	Addition and Subtraction
-									'&' => 1,																//	Concatenation
+		$operatorPrecedence = array(':' => 8, //	Range
+									'|' => 7, //	Intersect
+									'~' => 6, //	Negation
+									'%' => 5, //	Percentage
+									'^' => 4, //	Exponentiation
+									'*' => 3, '/' => 3, //	Multiplication and Division
+									'+' => 2, '-' => 2, //	Addition and Subtraction
+									'&' => 1, //	Concatenation
 									'>' => 0, '<' => 0, '=' => 0, '>=' => 0, '<=' => 0, '<>' => 0			//	Comparison
 								   );
 
@@ -2665,17 +2665,17 @@ 
 		$index = 0;
 		$stack = new PHPExcel_Token_Stack;
 		$output = array();
-		$expectingOperator = false;					//	We use this test in syntax-checking the expression to determine when a
+		$expectingOperator = false; //	We use this test in syntax-checking the expression to determine when a
 													//		- is a negation or + is a positive operator rather than an operation
-		$expectingOperand = false;					//	We use this test in syntax-checking the expression to determine whether an operand
+		$expectingOperand = false; //	We use this test in syntax-checking the expression to determine whether an operand
 													//		should be null in a function call
 		//	The guts of the lexical parser
 		//	Loop through the formula extracting each operator and operand in turn
-		while(true) {
+		while (true) {
 //			echo 'Assessing Expression <b>'.substr($formula, $index).'</b><br />';
 			$opCharacter = $formula{$index};	//	Get the first character of the value at the current index position
 //			echo 'Initial character of expression block is '.$opCharacter.'<br />';
-			if ((isset($comparisonOperators[$opCharacter])) && (strlen($formula) > $index) && (isset($comparisonOperators[$formula{$index+1}]))) {
+			if ((isset($comparisonOperators[$opCharacter])) && (strlen($formula) > $index) && (isset($comparisonOperators[$formula{$index + 1}]))) {
 				$opCharacter .= $formula{++$index};
 //				echo 'Initial character of expression block is comparison operator '.$opCharacter.'<br />';
 			}
@@ -2685,29 +2685,29 @@ 
 //			echo '$isOperandOrFunction is '.(($isOperandOrFunction) ? 'True' : 'False').'<br />';
 //			var_dump($match);
 
-			if ($opCharacter == '-' && !$expectingOperator) {				//	Is it a negation instead of a minus?
+			if ($opCharacter == '-' && ! $expectingOperator) {				//	Is it a negation instead of a minus?
 //				echo 'Element is a Negation operator<br />';
-				$stack->push('Unary Operator','~');							//	Put a negation on the stack
-				++$index;													//		and drop the negation symbol
+				$stack->push('Unary Operator', '~'); //	Put a negation on the stack
+				++$index; //		and drop the negation symbol
 			} elseif ($opCharacter == '%' && $expectingOperator) {
 //				echo 'Element is a Percentage operator<br />';
-				$stack->push('Unary Operator','%');							//	Put a percentage on the stack
+				$stack->push('Unary Operator', '%'); //	Put a percentage on the stack
 				++$index;
-			} elseif ($opCharacter == '+' && !$expectingOperator) {			//	Positive (unary plus rather than binary operator plus) can be discarded?
+			} elseif ($opCharacter == '+' && ! $expectingOperator) {			//	Positive (unary plus rather than binary operator plus) can be discarded?
 //				echo 'Element is a Positive number, not Plus operator<br />';
-				++$index;													//	Drop the redundant plus symbol
-			} elseif ((($opCharacter == '~') || ($opCharacter == '|')) && (!$isOperandOrFunction)) {	//	We have to explicitly deny a tilde or pipe, because they are legal
-				return $this->_raiseFormulaError("Formula Error: Illegal character '~'");				//		on the stack but not in the input expression
+				++$index; //	Drop the redundant plus symbol
+			} elseif ((($opCharacter == '~') || ($opCharacter == '|')) && ( ! $isOperandOrFunction)) {	//	We have to explicitly deny a tilde or pipe, because they are legal
+				return $this->_raiseFormulaError("Formula Error: Illegal character '~'"); //		on the stack but not in the input expression
 
 			} elseif ((isset(self::$_operators[$opCharacter]) or $isOperandOrFunction) && $expectingOperator) {	//	Are we putting an operator on the stack?
 //				echo 'Element with value '.$opCharacter.' is an Operator<br />';
-				while($stack->count() > 0 &&
+				while ($stack->count() > 0 &&
 					($o2 = $stack->last()) &&
 					isset(self::$_operators[$o2['value']]) &&
 					@($operatorAssociativity[$opCharacter] ? $operatorPrecedence[$opCharacter] < $operatorPrecedence[$o2['value']] : $operatorPrecedence[$opCharacter] <= $operatorPrecedence[$o2['value']])) {
-					$output[] = $stack->pop();								//	Swap operands and higher precedence operators from the stack to the output
+					$output[] = $stack->pop(); //	Swap operands and higher precedence operators from the stack to the output
 				}
-				$stack->push('Binary Operator',$opCharacter);	//	Finally put our current operator onto the stack
+				$stack->push('Binary Operator', $opCharacter); //	Finally put our current operator onto the stack
 				++$index;
 				$expectingOperator = false;
 
@@ -2720,10 +2720,10 @@ 
 				}
 				$d = $stack->last(2);
 				if (preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $d['value'], $matches)) {	//	Did this parenthesis just close a function?
-					$functionName = $matches[1];										//	Get the function name
+					$functionName = $matches[1]; //	Get the function name
 //					echo 'Closed Function is '.$functionName.'<br />';
 					$d = $stack->pop();
-					$argumentCount = $d['value'];		//	See how many arguments there were (argument count is the next value stored on the stack)
+					$argumentCount = $d['value']; //	See how many arguments there were (argument count is the next value stored on the stack)
 //					if ($argumentCount == 0) {
 //						echo 'With no arguments<br />';
 //					} elseif ($argumentCount == 1) {
@@ -2731,8 +2731,8 @@ 
 //					} else {
 //						echo 'With '.$argumentCount.' arguments<br />';
 //					}
-					$output[] = $d;						//	Dump the argument count on the output
-					$output[] = $stack->pop();			//	Pop the function and push onto the output
+					$output[] = $d; //	Dump the argument count on the output
+					$output[] = $stack->pop(); //	Pop the function and push onto the output
 					if (isset(self::$_controlFunctions[$functionName])) {
 //						echo 'Built-in function '.$functionName.'<br />';
 						$expectedArgumentCount = self::$_controlFunctions[$functionName]['argumentCount'];
@@ -2761,7 +2761,7 @@ 
 							}
 						}
 					} elseif ($expectedArgumentCount != '*') {
-						$isOperandOrFunction = preg_match('/(\d*)([-+,])(\d*)/',$expectedArgumentCount,$argMatch);
+						$isOperandOrFunction = preg_match('/(\d*)([-+,])(\d*)/', $expectedArgumentCount, $argMatch);
 //						print_r($argMatch);
 //						echo '<br />';
 						switch ($argMatch[2]) {
@@ -2795,30 +2795,30 @@ 
 //				echo 'Element is a Function argument separator<br />';
 				while (($o2 = $stack->pop()) && $o2['value'] != '(') {		//	Pop off the stack back to the last (
 					if ($o2 === NULL) return $this->_raiseFormulaError("Formula Error: Unexpected ,");
-					else $output[] = $o2;	// pop the argument expression stuff and push onto the output
+					else $output[] = $o2; // pop the argument expression stuff and push onto the output
 				}
 				//	If we've a comma when we're expecting an operand, then what we actually have is a null operand;
 				//		so push a null onto the stack
-				if (($expectingOperand) || (!$expectingOperator)) {
+				if (($expectingOperand) || ( ! $expectingOperator)) {
 					$output[] = array('type' => 'NULL Value', 'value' => self::$_ExcelConstants['NULL'], 'reference' => null);
 				}
 				// make sure there was a function
 				$d = $stack->last(2);
-				if (!preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $d['value'], $matches))
+				if ( ! preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $d['value'], $matches))
 					return $this->_raiseFormulaError("Formula Error: Unexpected ,");
 				$d = $stack->pop();
-				$stack->push($d['type'],++$d['value'],$d['reference']);	// increment the argument count
-				$stack->push('Brace', '(');	// put the ( back on, we'll need to pop back to it again
+				$stack->push($d['type'], ++$d['value'], $d['reference']); // increment the argument count
+				$stack->push('Brace', '('); // put the ( back on, we'll need to pop back to it again
 				$expectingOperator = false;
 				$expectingOperand = true;
 				++$index;
 
-			} elseif ($opCharacter == '(' && !$expectingOperator) {
+			} elseif ($opCharacter == '(' && ! $expectingOperator) {
 //				echo 'Element is an Opening Bracket<br />';
 				$stack->push('Brace', '(');
 				++$index;
 
-			} elseif ($isOperandOrFunction && !$expectingOperator) {	// do we now have a function/variable/number?
+			} elseif ($isOperandOrFunction && ! $expectingOperator) {	// do we now have a function/variable/number?
 				$expectingOperator = true;
 				$expectingOperand = false;
 				$val = $match[1];
@@ -2826,11 +2826,11 @@ 
 //				echo 'Element with value '.$val.' is an Operand, Variable, Constant, String, Number, Cell Reference or Function<br />';
 
 				if (preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $val, $matches)) {
-					$val = preg_replace('/\s/','',$val);
+					$val = preg_replace('/\s/', '', $val);
 //					echo 'Element '.$val.' is a Function<br />';
 					if (isset(self::$_PHPExcelFunctions[strtoupper($matches[1])]) || isset(self::$_controlFunctions[strtoupper($matches[1])])) {	// it's a function
 						$stack->push('Function', strtoupper($val));
-						$ax = preg_match('/^\s*(\s*\))/i', substr($formula, $index+$length), $amatch);
+						$ax = preg_match('/^\s*(\s*\))/i', substr($formula, $index + $length), $amatch);
 						if ($ax) {
 							$stack->push('Operand Count for Function '.strtoupper($val).')', 0);
 							$expectingOperator = true;
@@ -2854,7 +2854,7 @@ 
 						if ($matches[2] == '') {
 							//	Otherwise, we 'inherit' the worksheet reference from the start cell reference
 							//	The start of the cell range reference should be the last entry in $output
-							$startCellRef = $output[count($output)-1]['value'];
+							$startCellRef = $output[count($output) - 1]['value'];
 							preg_match('/^'.self::CALCULATION_REGEXP_CELLREF.'$/i', $startCellRef, $startMatches);
 							if ($startMatches[2] > '') {
 								$val = $startMatches[2].'!'.$val;
@@ -2871,28 +2871,28 @@ 
 					//	If the last entry on the stack was a : operator, then we may have a row or column range reference
 					$testPrevOp = $stack->last(1);
 					if ($testPrevOp['value'] == ':') {
-						$startRowColRef = $output[count($output)-1]['value'];
+						$startRowColRef = $output[count($output) - 1]['value'];
 						$rangeWS1 = '';
-						if (strpos('!',$startRowColRef) !== false) {
-							list($rangeWS1,$startRowColRef) = explode('!',$startRowColRef);
+						if (strpos('!', $startRowColRef) !== false) {
+							list($rangeWS1, $startRowColRef) = explode('!', $startRowColRef);
 						}
 						if ($rangeWS1 != '') $rangeWS1 .= '!';
 						$rangeWS2 = $rangeWS1;
-						if (strpos('!',$val) !== false) {
-							list($rangeWS2,$val) = explode('!',$val);
+						if (strpos('!', $val) !== false) {
+							list($rangeWS2, $val) = explode('!', $val);
 						}
 						if ($rangeWS2 != '') $rangeWS2 .= '!';
 						if ((is_integer($startRowColRef)) && (ctype_digit($val)) &&
 							($startRowColRef <= 1048576) && ($val <= 1048576)) {
 							//	Row range
-							$endRowColRef = ($pCellParent !== NULL) ? $pCellParent->getHighestColumn() : 'XFD';	//	Max 16,384 columns for Excel2007
-							$output[count($output)-1]['value'] = $rangeWS1.'A'.$startRowColRef;
+							$endRowColRef = ($pCellParent !== NULL) ? $pCellParent->getHighestColumn() : 'XFD'; //	Max 16,384 columns for Excel2007
+							$output[count($output) - 1]['value'] = $rangeWS1.'A'.$startRowColRef;
 							$val = $rangeWS2.$endRowColRef.$val;
 						} elseif ((ctype_alpha($startRowColRef)) && (ctype_alpha($val)) &&
 							(strlen($startRowColRef) <= 3) && (strlen($val) <= 3)) {
 							//	Column range
-							$endRowColRef = ($pCellParent !== NULL) ? $pCellParent->getHighestRow() : 1048576;		//	Max 1,048,576 rows for Excel2007
-							$output[count($output)-1]['value'] = $rangeWS1.strtoupper($startRowColRef).'1';
+							$endRowColRef = ($pCellParent !== NULL) ? $pCellParent->getHighestRow() : 1048576; //	Max 1,048,576 rows for Excel2007
+							$output[count($output) - 1]['value'] = $rangeWS1.strtoupper($startRowColRef).'1';
 							$val = $rangeWS2.$val.$endRowColRef;
 						}
 					}
@@ -2901,10 +2901,10 @@ 
 					if ($opCharacter == '"') {
 //						echo 'Element is a String<br />';
 						//	UnEscape any quotes within the string
-						$val = self::_wrapResult(str_replace('""','"',self::_unwrapResult($val)));
+						$val = self::_wrapResult(str_replace('""', '"', self::_unwrapResult($val)));
 					} elseif (is_numeric($val)) {
 //						echo 'Element is a Number<br />';
-						if ((strpos($val,'.') !== false) || (stripos($val,'e') !== false) || ($val > PHP_INT_MAX) || ($val < -PHP_INT_MAX)) {
+						if ((strpos($val, '.') !== false) || (stripos($val, 'e') !== false) || ($val > PHP_INT_MAX) || ($val < -PHP_INT_MAX)) {
 //							echo 'Casting '.$val.' to float<br />';
 							$val = (float) $val;
 						} else {
@@ -2935,7 +2935,7 @@ 
 				} else {
 					return $this->_raiseFormulaError("Formula Error: Unexpected ')'");
 				}
-			} elseif (isset(self::$_operators[$opCharacter]) && !$expectingOperator) {
+			} elseif (isset(self::$_operators[$opCharacter]) && ! $expectingOperator) {
 				return $this->_raiseFormulaError("Formula Error: Unexpected operator '$opCharacter'");
 			} else {	// I don't even want to know what you did to get here
 				return $this->_raiseFormulaError("Formula Error: An unexpected error occured");
@@ -2962,15 +2962,15 @@ 
 				//		Cell References) then we have an INTERSECTION operator
 //				echo 'Possible Intersect Operator<br />';
 				if (($expectingOperator) && (preg_match('/^'.self::CALCULATION_REGEXP_CELLREF.'.*/Ui', substr($formula, $index), $match)) &&
-					($output[count($output)-1]['type'] == 'Cell Reference')) {
+					($output[count($output) - 1]['type'] == 'Cell Reference')) {
 //					echo 'Element is an Intersect Operator<br />';
-					while($stack->count() > 0 &&
+					while ($stack->count() > 0 &&
 						($o2 = $stack->last()) &&
 						isset(self::$_operators[$o2['value']]) &&
 						@($operatorAssociativity[$opCharacter] ? $operatorPrecedence[$opCharacter] < $operatorPrecedence[$o2['value']] : $operatorPrecedence[$opCharacter] <= $operatorPrecedence[$o2['value']])) {
-						$output[] = $stack->pop();								//	Swap operands and higher precedence operators from the stack to the output
+						$output[] = $stack->pop(); //	Swap operands and higher precedence operators from the stack to the output
 					}
-					$stack->push('Binary Operator','|');	//	Put an Intersect Operator on the stack
+					$stack->push('Binary Operator', '|'); //	Put an Intersect Operator on the stack
 					$expectingOperator = false;
 				}
 			}
@@ -2978,7 +2978,7 @@ 
 
 		while (($op = $stack->pop()) !== NULL) {	// pop everything off the stack and push onto output
 			if ((is_array($opCharacter) && $opCharacter['value'] == '(') || ($opCharacter === '('))
-				return $this->_raiseFormulaError("Formula Error: Expecting ')'");	// if there are any opening braces on the stack, then braces were unbalanced
+				return $this->_raiseFormulaError("Formula Error: Expecting ')'"); // if there are any opening braces on the stack, then braces were unbalanced
 			$output[] = $op;
 		}
 		return $output;
@@ -3041,18 +3041,18 @@ 
 					case '<='	:			//	Less than or Equal to
 					case '='	:			//	Equality
 					case '<>'	:			//	Inequality
-						$this->_executeBinaryComparisonOperation($cellID,$operand1,$operand2,$token,$stack);
+						$this->_executeBinaryComparisonOperation($cellID, $operand1, $operand2, $token, $stack);
 						break;
 					//	Binary Operators
 					case ':'	:			//	Range
 						$sheet1 = $sheet2 = '';
-						if (strpos($operand1Data['reference'],'!') !== false) {
-							list($sheet1,$operand1Data['reference']) = explode('!',$operand1Data['reference']);
+						if (strpos($operand1Data['reference'], '!') !== false) {
+							list($sheet1, $operand1Data['reference']) = explode('!', $operand1Data['reference']);
 						} else {
 							$sheet1 = ($pCellParent !== NULL) ? $pCellParent->getTitle() : '';
 						}
-						if (strpos($operand2Data['reference'],'!') !== false) {
-							list($sheet2,$operand2Data['reference']) = explode('!',$operand2Data['reference']);
+						if (strpos($operand2Data['reference'], '!') !== false) {
+							list($sheet2, $operand2Data['reference']) = explode('!', $operand2Data['reference']);
 						} else {
 							$sheet2 = $sheet1;
 						}
@@ -3076,9 +3076,9 @@ 
 								}
 							}
 
-							$oData = array_merge(explode(':',$operand1Data['reference']),explode(':',$operand2Data['reference']));
+							$oData = array_merge(explode(':', $operand1Data['reference']), explode(':', $operand2Data['reference']));
 							$oCol = $oRow = array();
-							foreach($oData as $oDatum) {
+							foreach ($oData as $oDatum) {
 								$oCR = PHPExcel_Cell::coordinateFromString($oDatum);
 								$oCol[] = PHPExcel_Cell::columnIndexFromString($oCR[0]) - 1;
 								$oRow[] = $oCR[1];
@@ -3089,26 +3089,26 @@ 
 							} else {
 								return $this->_raiseFormulaError('Unable to access Cell Reference');
 							}
-							$stack->push('Cell Reference',$cellValue,$cellRef);
+							$stack->push('Cell Reference', $cellValue, $cellRef);
 						} else {
-							$stack->push('Error',PHPExcel_Calculation_Functions::REF(),null);
+							$stack->push('Error', PHPExcel_Calculation_Functions::REF(), null);
 						}
 
 						break;
 					case '+'	:			//	Addition
-						$this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'plusEquals',$stack);
+						$this->_executeNumericBinaryOperation($cellID, $operand1, $operand2, $token, 'plusEquals', $stack);
 						break;
 					case '-'	:			//	Subtraction
-						$this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'minusEquals',$stack);
+						$this->_executeNumericBinaryOperation($cellID, $operand1, $operand2, $token, 'minusEquals', $stack);
 						break;
 					case '*'	:			//	Multiplication
-						$this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'arrayTimesEquals',$stack);
+						$this->_executeNumericBinaryOperation($cellID, $operand1, $operand2, $token, 'arrayTimesEquals', $stack);
 						break;
 					case '/'	:			//	Division
-						$this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'arrayRightDivide',$stack);
+						$this->_executeNumericBinaryOperation($cellID, $operand1, $operand2, $token, 'arrayRightDivide', $stack);
 						break;
 					case '^'	:			//	Exponential
-						$this->_executeNumericBinaryOperation($cellID,$operand1,$operand2,$token,'power',$stack);
+						$this->_executeNumericBinaryOperation($cellID, $operand1, $operand2, $token, 'power', $stack);
 						break;
 					case '&'	:			//	Concatenation
 						//	If either of the operands is a matrix, we need to treat them both as matrices
@@ -3122,7 +3122,7 @@ 
 						}
 						if ((is_array($operand1)) || (is_array($operand2))) {
 							//	Ensure that both operands are arrays/matrices
-							self::_checkMatrixOperands($operand1,$operand2,2);
+							self::_checkMatrixOperands($operand1, $operand2, 2);
 							try {
 								//	Convert operand 1 from a PHP array to a matrix
 								$matrix = new PHPExcel_Shared_JAMA_Matrix($operand1);
@@ -3134,24 +3134,24 @@ 
 								$result = '#VALUE!';
 							}
 						} else {
-							$result = '"'.str_replace('""','"',self::_unwrapResult($operand1,'"').self::_unwrapResult($operand2,'"')).'"';
+							$result = '"'.str_replace('""', '"', self::_unwrapResult($operand1, '"').self::_unwrapResult($operand2, '"')).'"';
 						}
 						$this->_writeDebug('Evaluation Result is '.$this->_showTypeDetails($result));
-						$stack->push('Value',$result);
+						$stack->push('Value', $result);
 						break;
 					case '|'	:			//	Intersect
-						$rowIntersect = array_intersect_key($operand1,$operand2);
+						$rowIntersect = array_intersect_key($operand1, $operand2);
 						$cellIntersect = $oCol = $oRow = array();
-						foreach(array_keys($rowIntersect) as $row) {
+						foreach (array_keys($rowIntersect) as $row) {
 							$oRow[] = $row;
-							foreach($rowIntersect[$row] as $col => $data) {
+							foreach ($rowIntersect[$row] as $col => $data) {
 								$oCol[] = PHPExcel_Cell::columnIndexFromString($col) - 1;
-								$cellIntersect[$row] = array_intersect_key($operand1[$row],$operand2[$row]);
+								$cellIntersect[$row] = array_intersect_key($operand1[$row], $operand2[$row]);
 							}
 						}
 						$cellRef = PHPExcel_Cell::stringFromColumnIndex(min($oCol)).min($oRow).':'.PHPExcel_Cell::stringFromColumnIndex(max($oCol)).max($oRow);
 						$this->_writeDebug('Evaluation Result is '.$this->_showTypeDetails($cellIntersect));
-						$stack->push('Value',$cellIntersect,$cellRef);
+						$stack->push('Value', $cellIntersect, $cellRef);
 						break;
 				}
 
@@ -3170,7 +3170,7 @@ 
 					$multiplier = 0.01;
 				}
 				if (is_array($arg)) {
-					self::_checkMatrixOperands($arg,$multiplier,2);
+					self::_checkMatrixOperands($arg, $multiplier, 2);
 					try {
 						$matrix1 = new PHPExcel_Shared_JAMA_Matrix($arg);
 						$matrixResult = $matrix1->arrayTimesEquals($multiplier);
@@ -3180,9 +3180,9 @@ 
 						$result = '#VALUE!';
 					}
 					$this->_writeDebug('Evaluation Result is '.$this->_showTypeDetails($result));
-					$stack->push('Value',$result);
+					$stack->push('Value', $result);
 				} else {
-					$this->_executeNumericBinaryOperation($cellID,$multiplier,$arg,'*','arrayTimesEquals',$stack);
+					$this->_executeNumericBinaryOperation($cellID, $multiplier, $arg, '*', 'arrayTimesEquals', $stack);
 				}
 
 			} elseif (preg_match('/^'.self::CALCULATION_REGEXP_CELLREF.'$/i', $token, $matches)) {
@@ -3196,12 +3196,12 @@ 
 					} else {
 						$cellRef = $matches[6].$matches[7].':'.$matches[9].$matches[10];
 						if ($matches[2] > '') {
-							$matches[2] = trim($matches[2],"\"'");
-							if ((strpos($matches[2],'[') !== false) || (strpos($matches[2],']') !== false)) {
+							$matches[2] = trim($matches[2], "\"'");
+							if ((strpos($matches[2], '[') !== false) || (strpos($matches[2], ']') !== false)) {
 								//	It's a Reference to an external workbook (not currently supported)
 								return $this->_raiseFormulaError('Unable to access External Workbook');
 							}
-							$matches[2] = trim($matches[2],"\"'");
+							$matches[2] = trim($matches[2], "\"'");
 //							echo '$cellRef='.$cellRef.' in worksheet '.$matches[2].'<br />';
 							$this->_writeDebug('Evaluating Cell Range '.$cellRef.' in worksheet '.$matches[2]);
 							if ($pCellParent !== NULL) {
@@ -3230,8 +3230,8 @@ 
 					} else {
 						$cellRef = $matches[6].$matches[7];
 						if ($matches[2] > '') {
-							$matches[2] = trim($matches[2],"\"'");
-							if ((strpos($matches[2],'[') !== false) || (strpos($matches[2],']') !== false)) {
+							$matches[2] = trim($matches[2], "\"'");
+							if ((strpos($matches[2], '[') !== false) || (strpos($matches[2], ']') !== false)) {
 								//	It's a Reference to an external workbook (not currently supported)
 								return $this->_raiseFormulaError('Unable to access External Workbook');
 							}
@@ -3262,7 +3262,7 @@ 
 						}
 					}
 				}
-				$stack->push('Value',$cellValue,$cellRef);
+				$stack->push('Value', $cellValue, $cellRef);
 
 			// if the token is a function, pop arguments off the stack, hand them to the function, and push the result back on
 			} elseif (preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $token, $matches)) {
@@ -3316,7 +3316,7 @@ 
 					if ($functionName != 'MKMATRIX') {
 						if ($this->writeDebugLog) {
 							krsort($argArrayVals);
-							$this->_writeDebug('Evaluating '. self::_localeFunc($functionName).'( '.implode(self::$_localeArgumentSeparator.' ',PHPExcel_Calculation_Functions::flattenArray($argArrayVals)).' )');
+							$this->_writeDebug('Evaluating '.self::_localeFunc($functionName).'( '.implode(self::$_localeArgumentSeparator.' ', PHPExcel_Calculation_Functions::flattenArray($argArrayVals)).' )');
 						}
 					}
 					//	Process each argument in turn, building the return value as an array
@@ -3346,20 +3346,20 @@ 
 						if ($passCellReference) {
 							$args[] = $pCell;
 						}
-						if (strpos($functionCall,'::') !== false) {
-							$result = call_user_func_array(explode('::',$functionCall),$args);
+						if (strpos($functionCall, '::') !== false) {
+							$result = call_user_func_array(explode('::', $functionCall), $args);
 						} else {
-							foreach($args as &$arg) {
+							foreach ($args as &$arg) {
 								$arg = PHPExcel_Calculation_Functions::flattenSingleValue($arg);
 							}
 							unset($arg);
-							$result = call_user_func_array($functionCall,$args);
+							$result = call_user_func_array($functionCall, $args);
 						}
 //					}
 					if ($functionName != 'MKMATRIX') {
 						$this->_writeDebug('Evaluation Result for '.self::_localeFunc($functionName).'() function call is '.$this->_showTypeDetails($result));
 					}
-					$stack->push('Value',self::_wrapResult($result));
+					$stack->push('Value', self::_wrapResult($result));
 				}
 
 			} else {
@@ -3367,11 +3367,11 @@ 
 				if (isset(self::$_ExcelConstants[strtoupper($token)])) {
 					$excelConstant = strtoupper($token);
 //					echo 'Token is a PHPExcel constant: '.$excelConstant.'<br />';
-					$stack->push('Constant Value',self::$_ExcelConstants[$excelConstant]);
+					$stack->push('Constant Value', self::$_ExcelConstants[$excelConstant]);
 					$this->_writeDebug('Evaluating Constant '.$excelConstant.' as '.$this->_showTypeDetails(self::$_ExcelConstants[$excelConstant]));
 				} elseif ((is_numeric($token)) || ($token === NULL) || (is_bool($token)) || ($token == '') || ($token{0} == '"') || ($token{0} == '#')) {
 //					echo 'Token is a number, boolean, string, null or an Excel error<br />';
-					$stack->push('Value',$token);
+					$stack->push('Value', $token);
 				// if the token is a named range, push the named range name onto the stack
 				} elseif (preg_match('/^'.self::CALCULATION_REGEXP_NAMEDRANGE.'$/i', $token, $matches)) {
 //					echo 'Token is a named range<br />';
@@ -3381,7 +3381,7 @@ 
 					$cellValue = $this->extractNamedRange($namedRange, ((null !== $pCell) ? $pCellParent : null), false);
 					$pCell->attach($pCellParent);
 					$this->_writeDebug('Evaluation Result for named range '.$namedRange.' is '.$this->_showTypeDetails($cellValue));
-					$stack->push('Named Range',$cellValue,$namedRange);
+					$stack->push('Named Range', $cellValue, $namedRange);
 				} else {
 					return $this->_raiseFormulaError("undefined variable '$token'");
 				}
@@ -3399,20 +3399,20 @@ 
 	}	//	function _processTokenStack()
 
 
-	private function _validateBinaryOperand($cellID,&$operand,&$stack) {
+	private function _validateBinaryOperand($cellID, &$operand, &$stack) {
 		//	Numbers, matrices and booleans can pass straight through, as they're already valid
 		if (is_string($operand)) {
 			//	We only need special validations for the operand if it is a string
 			//	Start by stripping off the quotation marks we use to identify true excel string values internally
 			if ($operand > '' && $operand{0} == '"') { $operand = self::_unwrapResult($operand); }
 			//	If the string is a numeric value, we treat it as a numeric, so no further testing
-			if (!is_numeric($operand)) {
+			if ( ! is_numeric($operand)) {
 				//	If not a numeric, test to see if the value is an Excel error, and so can't be used in normal binary operations
 				if ($operand > '' && $operand{0} == '#') {
 					$stack->push('Value', $operand);
 					$this->_writeDebug('Evaluation Result is '.$this->_showTypeDetails($operand));
 					return false;
-				} elseif (!PHPExcel_Shared_String::convertToNumberIfFraction($operand)) {
+				} elseif ( ! PHPExcel_Shared_String::convertToNumberIfFraction($operand)) {
 					//	If not a numeric or a fraction, then it's a text string, and so can't be used in mathematical binary operations
 					$stack->push('Value', '#VALUE!');
 					$this->_writeDebug('Evaluation Result is a '.$this->_showTypeDetails('#VALUE!'));
@@ -3426,29 +3426,29 @@ 
 	}	//	function _validateBinaryOperand()
 
 
-	private function _executeBinaryComparisonOperation($cellID,$operand1,$operand2,$operation,&$stack,$recursingArrays=false) {
+	private function _executeBinaryComparisonOperation($cellID, $operand1, $operand2, $operation, &$stack, $recursingArrays = false) {
 		//	If we're dealing with matrix operations, we want a matrix result
 		if ((is_array($operand1)) || (is_array($operand2))) {
 			$result = array();
-			if ((is_array($operand1)) && (!is_array($operand2))) {
-				foreach($operand1 as $x => $operandData) {
+			if ((is_array($operand1)) && ( ! is_array($operand2))) {
+				foreach ($operand1 as $x => $operandData) {
 					$this->_writeDebug('Evaluating Comparison '.$this->_showValue($operandData).' '.$operation.' '.$this->_showValue($operand2));
-					$this->_executeBinaryComparisonOperation($cellID,$operandData,$operand2,$operation,$stack);
+					$this->_executeBinaryComparisonOperation($cellID, $operandData, $operand2, $operation, $stack);
 					$r = $stack->pop();
 					$result[$x] = $r['value'];
 				}
-			} elseif ((!is_array($operand1)) && (is_array($operand2))) {
-				foreach($operand2 as $x => $operandData) {
+			} elseif (( ! is_array($operand1)) && (is_array($operand2))) {
+				foreach ($operand2 as $x => $operandData) {
 					$this->_writeDebug('Evaluating Comparison '.$this->_showValue($operand1).' '.$operation.' '.$this->_showValue($operandData));
-					$this->_executeBinaryComparisonOperation($cellID,$operand1,$operandData,$operation,$stack);
+					$this->_executeBinaryComparisonOperation($cellID, $operand1, $operandData, $operation, $stack);
 					$r = $stack->pop();
 					$result[$x] = $r['value'];
 				}
 			} else {
-				if (!$recursingArrays) { self::_checkMatrixOperands($operand1,$operand2,2); }
-				foreach($operand1 as $x => $operandData) {
+				if ( ! $recursingArrays) { self::_checkMatrixOperands($operand1, $operand2, 2); }
+				foreach ($operand1 as $x => $operandData) {
 					$this->_writeDebug('Evaluating Comparison '.$this->_showValue($operandData).' '.$operation.' '.$this->_showValue($operand2[$x]));
-					$this->_executeBinaryComparisonOperation($cellID,$operandData,$operand2[$x],$operation,$stack,true);
+					$this->_executeBinaryComparisonOperation($cellID, $operandData, $operand2[$x], $operation, $stack, true);
 					$r = $stack->pop();
 					$result[$x] = $r['value'];
 				}
@@ -3456,7 +3456,7 @@ 
 			//	Log the result details
 			$this->_writeDebug('Comparison Evaluation Result is '.$this->_showTypeDetails($result));
 			//	And push the result onto the stack
-			$stack->push('Array',$result);
+			$stack->push('Array', $result);
 			return true;
 		}
 
@@ -3495,15 +3495,15 @@ 
 		//	Log the result details
 		$this->_writeDebug('Evaluation Result is '.$this->_showTypeDetails($result));
 		//	And push the result onto the stack
-		$stack->push('Value',$result);
+		$stack->push('Value', $result);
 		return true;
 	}	//	function _executeBinaryComparisonOperation()
 
 
-	private function _executeNumericBinaryOperation($cellID,$operand1,$operand2,$operation,$matrixFunction,&$stack) {
+	private function _executeNumericBinaryOperation($cellID, $operand1, $operand2, $operation, $matrixFunction, &$stack) {
 		//	Validate the two operands
-		if (!$this->_validateBinaryOperand($cellID,$operand1,$stack)) return false;
-		if (!$this->_validateBinaryOperand($cellID,$operand2,$stack)) return false;
+		if ( ! $this->_validateBinaryOperand($cellID, $operand1, $stack)) return false;
+		if ( ! $this->_validateBinaryOperand($cellID, $operand2, $stack)) return false;
 
 		$executeMatrixOperation = false;
 		//	If either of the operands is a matrix, we need to treat them both as matrices
@@ -3513,7 +3513,7 @@ 
 			//	Ensure that both operands are arrays/matrices
 			$executeMatrixOperation = true;
 			$mSize = array();
-			list($mSize[],$mSize[],$mSize[],$mSize[]) = self::_checkMatrixOperands($operand1,$operand2,2);
+			list($mSize[], $mSize[], $mSize[], $mSize[]) = self::_checkMatrixOperands($operand1, $operand2, 2);
 
 			//	But if they're both single cell matrices, then we can treat them as simple values
 			if (array_sum($mSize) == 4) {
@@ -3536,37 +3536,37 @@ 
 			}
 		} else {
 			if ((PHPExcel_Calculation_Functions::getCompatibilityMode() != PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) &&
-				((is_string($operand1) && !is_numeric($operand1)) || (is_string($operand2) && !is_numeric($operand2)))) {
+				((is_string($operand1) && ! is_numeric($operand1)) || (is_string($operand2) && ! is_numeric($operand2)))) {
 				$result = PHPExcel_Calculation_Functions::VALUE();
 			} else {
 				//	If we're dealing with non-matrix operations, execute the necessary operation
 				switch ($operation) {
 					//	Addition
 					case '+':
-						$result = $operand1+$operand2;
+						$result = $operand1 + $operand2;
 						break;
 					//	Subtraction
 					case '-':
-						$result = $operand1-$operand2;
+						$result = $operand1 - $operand2;
 						break;
 					//	Multiplication
 					case '*':
-						$result = $operand1*$operand2;
+						$result = $operand1 * $operand2;
 						break;
 					//	Division
 					case '/':
 						if ($operand2 == 0) {
 							//	Trap for Divide by Zero error
-							$stack->push('Value','#DIV/0!');
+							$stack->push('Value', '#DIV/0!');
 							$this->_writeDebug('Evaluation Result is '.$this->_showTypeDetails('#DIV/0!'));
 							return false;
 						} else {
-							$result = $operand1/$operand2;
+							$result = $operand1 / $operand2;
 						}
 						break;
 					//	Power
 					case '^':
-						$result = pow($operand1,$operand2);
+						$result = pow($operand1, $operand2);
 						break;
 				}
 			}
@@ -3575,7 +3575,7 @@ 
 		//	Log the result details
 		$this->_writeDebug('Evaluation Result is '.$this->_showTypeDetails($result));
 		//	And push the result onto the stack
-		$stack->push('Value',$result);
+		$stack->push('Value', $result);
 		return true;
 	}	//	function _executeNumericBinaryOperation()
 
@@ -3584,9 +3584,9 @@ 
 		//	Only write the debug log if logging is enabled
 		if ($this->writeDebugLog) {
 			if ($this->echoDebugLog) {
-				echo implode(' -> ',$this->debugLogStack).' -> '.$message,'<br />';
+				echo implode(' -> ', $this->debugLogStack).' -> '.$message, '<br />';
 			}
-			$this->debugLog[] = implode(' -> ',$this->debugLogStack).' -> '.$message;
+			$this->debugLog[] = implode(' -> ', $this->debugLogStack).' -> '.$message;
 		}
 	}	//	function _writeDebug()
 
@@ -3595,7 +3595,7 @@ 
 	protected function _raiseFormulaError($errorMessage) {
 		$this->formulaError = $errorMessage;
 		$this->debugLogStack = array();
-		if (!$this->suppressFormulaErrors) throw new Exception($errorMessage);
+		if ( ! $this->suppressFormulaErrors) throw new Exception($errorMessage);
 		trigger_error($errorMessage, E_USER_ERROR);
 	}	//	function _raiseFormulaError()
 
@@ -3608,15 +3608,15 @@ 
 	 * @return  mixed				Array of values in range if range contains more than one element. Otherwise, a single value is returned.
 	 * @throws	Exception
 	 */
-	public function extractCellRange(&$pRange = 'A1', PHPExcel_Worksheet $pSheet = null, $resetLog=true) {
+	public function extractCellRange(&$pRange = 'A1', PHPExcel_Worksheet $pSheet = null, $resetLog = true) {
 		// Return value
-		$returnValue = array ();
+		$returnValue = array();
 
 //		echo 'extractCellRange('.$pRange.')<br />';
 		if ($pSheet !== NULL) {
 //			echo 'Passed sheet name is '.$pSheet->getTitle().'<br />';
 //			echo 'Range reference is '.$pRange.'<br />';
-			if (strpos ($pRange, '!') !== false) {
+			if (strpos($pRange, '!') !== false) {
 //				echo '$pRange reference includes sheet reference<br />';
 				$worksheetReference = PHPExcel_Worksheet::extractSheetTitle($pRange, true);
 				$pSheet = $pSheet->getParent()->getSheetByName($worksheetReference[0]);
@@ -3628,9 +3628,9 @@ 
 			// Extract range
 			$aReferences = PHPExcel_Cell::extractAllCellReferencesInRange($pRange);
 			$pRange = $pSheet->getTitle().'!'.$pRange;
-			if (!isset($aReferences[1])) {
+			if ( ! isset($aReferences[1])) {
 				//	Single cell in range
-				list($currentCol,$currentRow) = sscanf($aReferences[0],'%[A-Z]%d');
+				list($currentCol, $currentRow) = sscanf($aReferences[0], '%[A-Z]%d');
 				if ($pSheet->cellExists($aReferences[0])) {
 					$returnValue[$currentRow][$currentCol] = $pSheet->getCell($aReferences[0])->getCalculatedValue($resetLog);
 				} else {
@@ -3640,7 +3640,7 @@ 
 				// Extract cell data for all cells in the range
 				foreach ($aReferences as $reference) {
 					// Extract range
-					list($currentCol,$currentRow) = sscanf($reference,'%[A-Z]%d');
+					list($currentCol, $currentRow) = sscanf($reference, '%[A-Z]%d');
 
 					if ($pSheet->cellExists($reference)) {
 						$returnValue[$currentRow][$currentCol] = $pSheet->getCell($reference)->getCalculatedValue($resetLog);
@@ -3664,15 +3664,15 @@ 
 	 * @return  mixed				Array of values in range if range contains more than one element. Otherwise, a single value is returned.
 	 * @throws	Exception
 	 */
-	public function extractNamedRange(&$pRange = 'A1', PHPExcel_Worksheet $pSheet = null, $resetLog=true) {
+	public function extractNamedRange(&$pRange = 'A1', PHPExcel_Worksheet $pSheet = null, $resetLog = true) {
 		// Return value
-		$returnValue = array ();
+		$returnValue = array();
 
 //		echo 'extractNamedRange('.$pRange.')<br />';
 		if ($pSheet !== NULL) {
 //			echo 'Current sheet name is '.$pSheet->getTitle().'<br />';
 //			echo 'Range reference is '.$pRange.'<br />';
-			if (strpos ($pRange, '!') !== false) {
+			if (strpos($pRange, '!') !== false) {
 //				echo '$pRange reference includes sheet reference<br />';
 				$worksheetReference = PHPExcel_Worksheet::extractSheetTitle($pRange, true);
 				$pSheet = $pSheet->getParent()->getSheetByName($worksheetReference[0]);
@@ -3690,9 +3690,9 @@ 
 				$splitRange = PHPExcel_Cell::splitRange($pRange);
 				//	Convert row and column references
 				if (ctype_alpha($splitRange[0][0])) {
-					$pRange = $splitRange[0][0] . '1:' . $splitRange[0][1] . $namedRange->getWorksheet()->getHighestRow();
-				} elseif(ctype_digit($splitRange[0][0])) {
-					$pRange = 'A' . $splitRange[0][0] . ':' . $namedRange->getWorksheet()->getHighestColumn() . $splitRange[0][1];
+					$pRange = $splitRange[0][0].'1:'.$splitRange[0][1].$namedRange->getWorksheet()->getHighestRow();
+				} elseif (ctype_digit($splitRange[0][0])) {
+					$pRange = 'A'.$splitRange[0][0].':'.$namedRange->getWorksheet()->getHighestColumn().$splitRange[0][1];
 				}
 //				echo $pRange.') is in sheet '.$namedRange->getWorksheet()->getTitle().'<br />';
 
@@ -3710,9 +3710,9 @@ 
 			// Extract range
 			$aReferences = PHPExcel_Cell::extractAllCellReferencesInRange($pRange);
 //			var_dump($aReferences);
-			if (!isset($aReferences[1])) {
+			if ( ! isset($aReferences[1])) {
 				//	Single cell (or single column or row) in range
-				list($currentCol,$currentRow) = PHPExcel_Cell::coordinateFromString($aReferences[0]);
+				list($currentCol, $currentRow) = PHPExcel_Cell::coordinateFromString($aReferences[0]);
 				if ($pSheet->cellExists($aReferences[0])) {
 					$returnValue[$currentRow][$currentCol] = $pSheet->getCell($aReferences[0])->getCalculatedValue($resetLog);
 				} else {
@@ -3722,7 +3722,7 @@ 
 				// Extract cell data for all cells in the range
 				foreach ($aReferences as $reference) {
 					// Extract range
-					list($currentCol,$currentRow) = PHPExcel_Cell::coordinateFromString($reference);
+					list($currentCol, $currentRow) = PHPExcel_Cell::coordinateFromString($reference);
 //					echo 'NAMED RANGE: $currentCol='.$currentCol.' $currentRow='.$currentRow.'<br />';
 					if ($pSheet->cellExists($reference)) {
 						$returnValue[$currentRow][$currentCol] = $pSheet->getCell($reference)->getCalculatedValue($resetLog);
@@ -3747,7 +3747,7 @@ 
 	 * @return	boolean
 	 */
 	public function isImplemented($pFunction = '') {
-		$pFunction = strtoupper ($pFunction);
+		$pFunction = strtoupper($pFunction);
 		if (isset(self::$_PHPExcelFunctions[$pFunction])) {
 			return (self::$_PHPExcelFunctions[$pFunction]['functionCall'] != 'PHPExcel_Calculation_Functions::DUMMY');
 		} else {
@@ -3765,7 +3765,7 @@ 
 		// Return value
 		$returnValue = array();
 		// Loop functions
-		foreach(self::$_PHPExcelFunctions as $functionName => $function) {
+		foreach (self::$_PHPExcelFunctions as $functionName => $function) {
 			if ($function['functionCall'] != 'PHPExcel_Calculation_Functions::DUMMY') {
 				$returnValue[$functionName] = new PHPExcel_Calculation_Function($function['category'],
 																				$functionName,
@@ -3797,7 +3797,7 @@ 
 		// Return value
 		$returnValue = array();
 		// Loop functions
-		foreach(self::$_PHPExcelFunctions as $functionName => $function) {
+		foreach (self::$_PHPExcelFunctions as $functionName => $function) {
 			if ($function['functionCall'] != 'PHPExcel_Calculation_Functions::DUMMY') {
 				$returnValue[] = $functionName;
 			}
@@ -3824,7 +3824,7 @@ 
 	}	//	function count()
 
 
-	public function push($type,$value,$reference=null) {
+	public function push($type, $value, $reference = null) {
 		$this->_stack[$this->_count++] = array('type'		=> $type,
 											   'value'		=> $value,
 											   'reference'	=> $reference
@@ -3846,11 +3846,11 @@ 
 	}	//	function pop()
 
 
-	public function last($n=1) {
-		if ($this->_count-$n < 0) {
+	public function last($n = 1) {
+		if ($this->_count - $n < 0) {
 			return null;
 		}
-		return $this->_stack[$this->_count-$n];
+		return $this->_stack[$this->_count - $n];
 	}	//	function last()
 
 

Braces +60 added lines, -22 removed lines

@@ -2208,9 +2208,13 @@ 
 		//	Basic validation that this is indeed a formula
 		//	We return an empty array if not
 		$formula = trim($formula);
-		if ((!isset($formula{0})) || ($formula{0} != '=')) return array();
+		if ((!isset($formula{0})) || ($formula{0} != '=')) {
+			return array();
+		}
 		$formula = ltrim(substr($formula,1));
-		if (!isset($formula{0})) return array();
+		if (!isset($formula{0})) {
+			return array();
+		}
 
 		//	Parse the formula and return the token stack
 		return $this->_parseFormula($formula);
@@ -2263,9 +2267,13 @@ 
 		//	Basic validation that this is indeed a formula
 		//	We simply return the "cell value" (formula) if not
 		$formula = trim($formula);
-		if ($formula{0} != '=') return self::_wrapResult($formula);
+		if ($formula{0} != '=') {
+			return self::_wrapResult($formula);
+		}
 		$formula = ltrim(substr($formula,1));
-		if (!isset($formula{0})) return self::_wrapResult($formula);
+		if (!isset($formula{0})) {
+			return self::_wrapResult($formula);
+		}
 
 		$wsTitle = "\x00Wrk";
 		if ($pCell !== NULL) {
@@ -2715,8 +2723,11 @@ 
 //				echo 'Element is a Closing bracket<br />';
 				$expectingOperand = false;
 				while (($o2 = $stack->pop()) && $o2['value'] != '(') {		//	Pop off the stack back to the last (
-					if ($o2 === NULL) return $this->_raiseFormulaError('Formula Error: Unexpected closing brace ")"');
-					else $output[] = $o2;
+					if ($o2 === NULL) {
+						return $this->_raiseFormulaError('Formula Error: Unexpected closing brace ")"');
+					} else {
+						$output[] = $o2;
+					}
 				}
 				$d = $stack->last(2);
 				if (preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $d['value'], $matches)) {	//	Did this parenthesis just close a function?
@@ -2794,8 +2805,12 @@ 
 			} elseif ($opCharacter == ',') {			//	Is this the separator for function arguments?
 //				echo 'Element is a Function argument separator<br />';
 				while (($o2 = $stack->pop()) && $o2['value'] != '(') {		//	Pop off the stack back to the last (
-					if ($o2 === NULL) return $this->_raiseFormulaError("Formula Error: Unexpected ,");
-					else $output[] = $o2;	// pop the argument expression stuff and push onto the output
+					if ($o2 === NULL) {
+						return $this->_raiseFormulaError("Formula Error: Unexpected ,");
+					} else {
+						$output[] = $o2;
+					}
+					// pop the argument expression stuff and push onto the output
 				}
 				//	If we've a comma when we're expecting an operand, then what we actually have is a null operand;
 				//		so push a null onto the stack
@@ -2804,8 +2819,9 @@ 
 				}
 				// make sure there was a function
 				$d = $stack->last(2);
-				if (!preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $d['value'], $matches))
-					return $this->_raiseFormulaError("Formula Error: Unexpected ,");
+				if (!preg_match('/^'.self::CALCULATION_REGEXP_FUNCTION.'$/i', $d['value'], $matches)) {
+									return $this->_raiseFormulaError("Formula Error: Unexpected ,");
+				}
 				$d = $stack->pop();
 				$stack->push($d['type'],++$d['value'],$d['reference']);	// increment the argument count
 				$stack->push('Brace', '(');	// put the ( back on, we'll need to pop back to it again
@@ -2876,12 +2892,16 @@ 
 						if (strpos('!',$startRowColRef) !== false) {
 							list($rangeWS1,$startRowColRef) = explode('!',$startRowColRef);
 						}
-						if ($rangeWS1 != '') $rangeWS1 .= '!';
+						if ($rangeWS1 != '') {
+							$rangeWS1 .= '!';
+						}
 						$rangeWS2 = $rangeWS1;
 						if (strpos('!',$val) !== false) {
 							list($rangeWS2,$val) = explode('!',$val);
 						}
-						if ($rangeWS2 != '') $rangeWS2 .= '!';
+						if ($rangeWS2 != '') {
+							$rangeWS2 .= '!';
+						}
 						if ((is_integer($startRowColRef)) && (ctype_digit($val)) &&
 							($startRowColRef <= 1048576) && ($val <= 1048576)) {
 							//	Row range
@@ -2977,8 +2997,10 @@ 
 		}
 
 		while (($op = $stack->pop()) !== NULL) {	// pop everything off the stack and push onto output
-			if ((is_array($opCharacter) && $opCharacter['value'] == '(') || ($opCharacter === '('))
-				return $this->_raiseFormulaError("Formula Error: Expecting ')'");	// if there are any opening braces on the stack, then braces were unbalanced
+			if ((is_array($opCharacter) && $opCharacter['value'] == '(') || ($opCharacter === '(')) {
+							return $this->_raiseFormulaError("Formula Error: Expecting ')'");
+			}
+			// if there are any opening braces on the stack, then braces were unbalanced
 			$output[] = $op;
 		}
 		return $output;
@@ -3002,7 +3024,9 @@ 
 
 	// evaluate postfix notation
 	private function _processTokenStack($tokens, $cellID = null, PHPExcel_Cell $pCell = null) {
-		if ($tokens == false) return false;
+		if ($tokens == false) {
+			return false;
+		}
 
 		//	If we're using cell caching, then $pCell may well be flushed back to the cache (which detaches the parent worksheet),
 		//		so we store the parent worksheet so that we can re-attach it when necessary
@@ -3019,8 +3043,12 @@ 
 			if (isset(self::$_binaryOperators[$token])) {
 //				echo 'Token is a binary operator<br />';
 				//	We must have two operands, error if we don't
-				if (($operand2Data = $stack->pop()) === NULL) return $this->_raiseFormulaError('Internal error - Operand value missing from stack');
-				if (($operand1Data = $stack->pop()) === NULL) return $this->_raiseFormulaError('Internal error - Operand value missing from stack');
+				if (($operand2Data = $stack->pop()) === NULL) {
+					return $this->_raiseFormulaError('Internal error - Operand value missing from stack');
+				}
+				if (($operand1Data = $stack->pop()) === NULL) {
+					return $this->_raiseFormulaError('Internal error - Operand value missing from stack');
+				}
 
 				$operand1 = self::_dataTestReference($operand1Data);
 				$operand2 = self::_dataTestReference($operand2Data);
@@ -3158,7 +3186,9 @@ 
 			// if the token is a unary operator, pop one value off the stack, do the operation, and push it back on
 			} elseif (($token === '~') || ($token === '%')) {
 //				echo 'Token is a unary operator<br />';
-				if (($arg = $stack->pop()) === NULL) return $this->_raiseFormulaError('Internal error - Operand value missing from stack');
+				if (($arg = $stack->pop()) === NULL) {
+					return $this->_raiseFormulaError('Internal error - Operand value missing from stack');
+				}
 				$arg = $arg['value'];
 				if ($token === '~') {
 //					echo 'Token is a negation operator<br />';
@@ -3388,7 +3418,9 @@ 
 			}
 		}
 		// when we're out of tokens, the stack should have a single element, the final result
-		if ($stack->count() != 1) return $this->_raiseFormulaError("internal error");
+		if ($stack->count() != 1) {
+			return $this->_raiseFormulaError("internal error");
+		}
 		$output = $stack->pop();
 		$output = $output['value'];
 
@@ -3502,8 +3534,12 @@ 
 
 	private function _executeNumericBinaryOperation($cellID,$operand1,$operand2,$operation,$matrixFunction,&$stack) {
 		//	Validate the two operands
-		if (!$this->_validateBinaryOperand($cellID,$operand1,$stack)) return false;
-		if (!$this->_validateBinaryOperand($cellID,$operand2,$stack)) return false;
+		if (!$this->_validateBinaryOperand($cellID,$operand1,$stack)) {
+			return false;
+		}
+		if (!$this->_validateBinaryOperand($cellID,$operand2,$stack)) {
+			return false;
+		}
 
 		$executeMatrixOperation = false;
 		//	If either of the operands is a matrix, we need to treat them both as matrices
@@ -3595,7 +3631,9 @@ 
 	protected function _raiseFormulaError($errorMessage) {
 		$this->formulaError = $errorMessage;
 		$this->debugLogStack = array();
-		if (!$this->suppressFormulaErrors) throw new Exception($errorMessage);
+		if (!$this->suppressFormulaErrors) {
+			throw new Exception($errorMessage);
+		}
 		trigger_error($errorMessage, E_USER_ERROR);
 	}	//	function _raiseFormulaError()
 

app/Vendor/PHPExcel/PHPExcel/Calculation/DateTime.php

Doc Comments +21 added lines, -26 removed lines

@@ -56,6 +56,9 @@ 
 	}	//	function _isLeapYear()
 
 
+	/**
+	 * @param boolean $methodUS
+	 */
 	private static function _dateDiff360($startDay, $startMonth, $startYear, $endDay, $endMonth, $endYear, $methodUS) {
 		if ($startDay == 31) {
 			--$startDay;
@@ -443,7 +446,7 @@ 
 	 *
 	 * @access	public
 	 * @category Date/Time Functions
-	 * @param	string	$dateValue		Text that represents a date in a Microsoft Excel date format.
+	 * @param	integer	$dateValue		Text that represents a date in a Microsoft Excel date format.
 	 *									For example, "1/30/2008" or "30-Jan-2008" are text strings within
 	 *									quotation marks that represent dates. Using the default date
 	 *									system in Excel for Windows, date_text must represent a date from
@@ -584,9 +587,9 @@ 
 	/**
 	 * DATEDIF
 	 *
-	 * @param	mixed	$startDate		Excel date serial value, PHP date/time stamp, PHP DateTime object
+	 * @param	integer	$startDate		Excel date serial value, PHP date/time stamp, PHP DateTime object
 	 *									or a standard date string
-	 * @param	mixed	$endDate		Excel date serial value, PHP date/time stamp, PHP DateTime object
+	 * @param	integer	$endDate		Excel date serial value, PHP date/time stamp, PHP DateTime object
 	 *									or a standard date string
 	 * @param	string	$unit
 	 * @return	integer	Interval between the dates
@@ -692,9 +695,9 @@ 
 	 *
 	 * @access	public
 	 * @category Date/Time Functions
-	 * @param	mixed		$startDate		Excel date serial value (float), PHP date timestamp (integer),
+	 * @param	integer		$startDate		Excel date serial value (float), PHP date timestamp (integer),
 	 *										PHP DateTime object, or a standard date string
-	 * @param	mixed		$endDate		Excel date serial value (float), PHP date timestamp (integer),
+	 * @param	integer		$endDate		Excel date serial value (float), PHP date timestamp (integer),
 	 *										PHP DateTime object, or a standard date string
 	 * @param	boolean		$method			US or European Method
 	 *										FALSE or omitted: U.S. (NASD) method. If the starting date is
@@ -748,9 +751,9 @@ 
 	 *
 	 * @access	public
 	 * @category Date/Time Functions
-	 * @param	mixed	$startDate		Excel date serial value (float), PHP date timestamp (integer),
+	 * @param	integer	$startDate		Excel date serial value (float), PHP date timestamp (integer),
 	 *									PHP DateTime object, or a standard date string
-	 * @param	mixed	$endDate		Excel date serial value (float), PHP date timestamp (integer),
+	 * @param	integer	$endDate		Excel date serial value (float), PHP date timestamp (integer),
 	 *									PHP DateTime object, or a standard date string
 	 * @param	integer	$method			Method used for the calculation
 	 *										0 or omitted	US (NASD) 30/360
@@ -849,10 +852,6 @@ 
 	 *											PHP DateTime object, or a standard date string
 	 * @param	mixed			$endDate		Excel date serial value (float), PHP date timestamp (integer),
 	 *											PHP DateTime object, or a standard date string
-	 * @param	mixed			$holidays,...	Optional series of Excel date serial value (float), PHP date
-	 *											timestamp (integer), PHP DateTime object, or a standard date
-	 *											strings that will be excluded from the working calendar, such
-	 *											as state and federal holidays and floating holidays.
 	 * @return	integer			Interval between the dates
 	 */
 	public static function NETWORKDAYS($startDate,$endDate) {
@@ -930,10 +929,6 @@ 
 	 * @param	integer		$endDays		The number of nonweekend and nonholiday days before or after
 	 *										startDate. A positive value for days yields a future date; a
 	 *										negative value yields a past date.
-	 * @param	mixed		$holidays,...	Optional series of Excel date serial value (float), PHP date
-	 *										timestamp (integer), PHP DateTime object, or a standard date
-	 *										strings that will be excluded from the working calendar, such
-	 *										as state and federal holidays and floating holidays.
 	 * @return	mixed	Excel date/time serial value, PHP date/time serial value or PHP date/time object,
 	 *						depending on the value of the ReturnDateType flag
 	 */
@@ -1036,7 +1031,7 @@ 
 	 * Excel Function:
 	 *		DAY(dateValue)
 	 *
-	 * @param	mixed	$dateValue		Excel date serial value (float), PHP date timestamp (integer),
+	 * @param	integer	$dateValue		Excel date serial value (float), PHP date timestamp (integer),
 	 *									PHP DateTime object, or a standard date string
 	 * @return	int		Day of the month
 	 */
@@ -1067,7 +1062,7 @@ 
 	 * Excel Function:
 	 *		WEEKDAY(dateValue[,style])
 	 *
-	 * @param	mixed	$dateValue		Excel date serial value (float), PHP date timestamp (integer),
+	 * @param	integer	$dateValue		Excel date serial value (float), PHP date timestamp (integer),
 	 *									PHP DateTime object, or a standard date string
 	 * @param	int		$style			A number that determines the type of return value
 	 *										1 or omitted	Numbers 1 (Sunday) through 7 (Saturday).
@@ -1134,9 +1129,9 @@ 
 	 * Excel Function:
 	 *		WEEKNUM(dateValue[,style])
 	 *
-	 * @param	mixed	$dateValue		Excel date serial value (float), PHP date timestamp (integer),
+	 * @param	integer	$dateValue		Excel date serial value (float), PHP date timestamp (integer),
 	 *									PHP DateTime object, or a standard date string
-	 * @param	boolean	$method			Week begins on Sunday or Monday
+	 * @param	integer	$method			Week begins on Sunday or Monday
 	 *										1 or omitted	Week begins on Sunday.
 	 *										2				Week begins on Monday.
 	 * @return	int		Week Number
@@ -1181,7 +1176,7 @@ 
 	 * Excel Function:
 	 *		MONTH(dateValue)
 	 *
-	 * @param	mixed	$dateValue		Excel date serial value (float), PHP date timestamp (integer),
+	 * @param	integer	$dateValue		Excel date serial value (float), PHP date timestamp (integer),
 	 *									PHP DateTime object, or a standard date string
 	 * @return	int		Month of the year
 	 */
@@ -1210,7 +1205,7 @@ 
 	 * Excel Function:
 	 *		YEAR(dateValue)
 	 *
-	 * @param	mixed	$dateValue		Excel date serial value (float), PHP date timestamp (integer),
+	 * @param	integer	$dateValue		Excel date serial value (float), PHP date timestamp (integer),
 	 *									PHP DateTime object, or a standard date string
 	 * @return	int		Year
 	 */
@@ -1239,7 +1234,7 @@ 
 	 * Excel Function:
 	 *		HOUR(timeValue)
 	 *
-	 * @param	mixed	$timeValue		Excel date serial value (float), PHP date timestamp (integer),
+	 * @param	integer	$timeValue		Excel date serial value (float), PHP date timestamp (integer),
 	 *									PHP DateTime object, or a standard time string
 	 * @return	int		Hour
 	 */
@@ -1279,7 +1274,7 @@ 
 	 * Excel Function:
 	 *		MINUTE(timeValue)
 	 *
-	 * @param	mixed	$timeValue		Excel date serial value (float), PHP date timestamp (integer),
+	 * @param	integer	$timeValue		Excel date serial value (float), PHP date timestamp (integer),
 	 *									PHP DateTime object, or a standard time string
 	 * @return	int		Minute
 	 */
@@ -1319,7 +1314,7 @@ 
 	 * Excel Function:
 	 *		SECOND(timeValue)
 	 *
-	 * @param	mixed	$timeValue		Excel date serial value (float), PHP date timestamp (integer),
+	 * @param	integer	$timeValue		Excel date serial value (float), PHP date timestamp (integer),
 	 *									PHP DateTime object, or a standard time string
 	 * @return	int		Second
 	 */
@@ -1361,7 +1356,7 @@ 
 	 * Excel Function:
 	 *		EDATE(dateValue,adjustmentMonths)
 	 *
-	 * @param	mixed	$dateValue			Excel date serial value (float), PHP date timestamp (integer),
+	 * @param	integer	$dateValue			Excel date serial value (float), PHP date timestamp (integer),
 	 *										PHP DateTime object, or a standard date string
 	 * @param	int		$adjustmentMonths	The number of months before or after start_date.
 	 *										A positive value for months yields a future date;
@@ -1406,7 +1401,7 @@ 
 	 * Excel Function:
 	 *		EOMONTH(dateValue,adjustmentMonths)
 	 *
-	 * @param	mixed	$dateValue			Excel date serial value (float), PHP date timestamp (integer),
+	 * @param	integer	$dateValue			Excel date serial value (float), PHP date timestamp (integer),
 	 *										PHP DateTime object, or a standard date string
 	 * @param	int		$adjustmentMonths	The number of months before or after start_date.
 	 *										A positive value for months yields a future date;

Indentation +1 added lines, -1 removed lines

@@ -789,7 +789,7 @@
 							$endDay = self::DAYOFMONTH($endDate);
 							if (($startMonth < 3) ||
 								(($endMonth * 100 + $endDay) >= (2 * 100 + 29))) {
-				     			$leapDays += 1;
+					 			$leapDays += 1;
 							}
 						}
 					} else {

Spacing +113 added lines, -113 removed lines

@@ -27,12 +27,12 @@ 
 
 
 /** PHPExcel root directory */
-if (!defined('PHPEXCEL_ROOT')) {
+if ( ! defined('PHPEXCEL_ROOT')) {
 	/**
 	 * @ignore
 	 */
-	define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
-	require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	define('PHPEXCEL_ROOT', dirname(__FILE__).'/../../');
+	require(PHPEXCEL_ROOT.'PHPExcel/Autoloader.php');
 }
 
 
@@ -59,7 +59,7 @@ 
 	private static function _dateDiff360($startDay, $startMonth, $startYear, $endDay, $endMonth, $endYear, $methodUS) {
 		if ($startDay == 31) {
 			--$startDay;
-		} elseif ($methodUS && ($startMonth == 2 && ($startDay == 29 || ($startDay == 28 && !self::_isLeapYear($startYear))))) {
+		} elseif ($methodUS && ($startMonth == 2 && ($startDay == 29 || ($startDay == 28 && ! self::_isLeapYear($startYear))))) {
 			$startDay = 30;
 		}
 		if ($endDay == 31) {
@@ -87,7 +87,7 @@ 
 	 * @return	mixed	Excel date/time serial value, or string if error
 	 */
 	public static function _getDateValue($dateValue) {
-		if (!is_numeric($dateValue)) {
+		if ( ! is_numeric($dateValue)) {
 			if ((is_string($dateValue)) &&
 				(PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC)) {
 				return PHPExcel_Calculation_Functions::VALUE();
@@ -274,32 +274,32 @@ 
 	 *						depending on the value of the ReturnDateType flag
 	 */
 	public static function DATE($year = 0, $month = 1, $day = 1) {
-		$year	= PHPExcel_Calculation_Functions::flattenSingleValue($year);
-		$month	= PHPExcel_Calculation_Functions::flattenSingleValue($month);
-		$day	= PHPExcel_Calculation_Functions::flattenSingleValue($day);
-
-		$year	= ($year !== NULL)	? PHPExcel_Shared_String::testStringAsNumeric($year) : 0;
-		$month	= ($month !== NULL)	? PHPExcel_Shared_String::testStringAsNumeric($month) : 0;
-		$day	= ($day !== NULL)	? PHPExcel_Shared_String::testStringAsNumeric($day) : 0;
-		if ((!is_numeric($year)) ||
-			(!is_numeric($month)) ||
-			(!is_numeric($day))) {
+		$year = PHPExcel_Calculation_Functions::flattenSingleValue($year);
+		$month = PHPExcel_Calculation_Functions::flattenSingleValue($month);
+		$day = PHPExcel_Calculation_Functions::flattenSingleValue($day);
+
+		$year = ($year !== NULL) ? PHPExcel_Shared_String::testStringAsNumeric($year) : 0;
+		$month = ($month !== NULL) ? PHPExcel_Shared_String::testStringAsNumeric($month) : 0;
+		$day = ($day !== NULL) ? PHPExcel_Shared_String::testStringAsNumeric($day) : 0;
+		if (( ! is_numeric($year)) ||
+			( ! is_numeric($month)) ||
+			( ! is_numeric($day))) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
-		$year	= (integer) $year;
-		$month	= (integer) $month;
-		$day	= (integer) $day;
+		$year = (integer) $year;
+		$month = (integer) $month;
+		$day = (integer) $day;
 
 		$baseYear = PHPExcel_Shared_Date::getExcelCalendar();
 		// Validate parameters
-		if ($year < ($baseYear-1900)) {
+		if ($year < ($baseYear - 1900)) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
-		if ((($baseYear-1900) != 0) && ($year < $baseYear) && ($year >= 1900)) {
+		if ((($baseYear - 1900) != 0) && ($year < $baseYear) && ($year >= 1900)) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
 
-		if (($year < $baseYear) && ($year >= ($baseYear-1900))) {
+		if (($year < $baseYear) && ($year >= ($baseYear - 1900))) {
 			$year += 1900;
 		}
 
@@ -360,7 +360,7 @@ 
 	 *						depending on the value of the ReturnDateType flag
 	 */
 	public static function TIME($hour = 0, $minute = 0, $second = 0) {
-		$hour	= PHPExcel_Calculation_Functions::flattenSingleValue($hour);
+		$hour = PHPExcel_Calculation_Functions::flattenSingleValue($hour);
 		$minute	= PHPExcel_Calculation_Functions::flattenSingleValue($minute);
 		$second	= PHPExcel_Calculation_Functions::flattenSingleValue($second);
 
@@ -368,10 +368,10 @@ 
 		if ($minute == '') { $minute = 0; }
 		if ($second == '') { $second = 0; }
 
-		if ((!is_numeric($hour)) || (!is_numeric($minute)) || (!is_numeric($second))) {
+		if (( ! is_numeric($hour)) || ( ! is_numeric($minute)) || ( ! is_numeric($second))) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
-		$hour	= (integer) $hour;
+		$hour = (integer) $hour;
 		$minute	= (integer) $minute;
 		$second	= (integer) $second;
 
@@ -408,7 +408,7 @@ 
 					}
 					return (float) PHPExcel_Shared_Date::FormattedPHPToExcel($calendar, 1, $date, $hour, $minute, $second);
 			case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC :
-					return (integer) PHPExcel_Shared_Date::ExcelToPHP(PHPExcel_Shared_Date::FormattedPHPToExcel(1970, 1, 1, $hour, $minute, $second));	// -2147468400; //	-2147472000 + 3600
+					return (integer) PHPExcel_Shared_Date::ExcelToPHP(PHPExcel_Shared_Date::FormattedPHPToExcel(1970, 1, 1, $hour, $minute, $second)); // -2147468400; //	-2147472000 + 3600
 			case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT :
 					$dayAdjust = 0;
 					if ($hour < 0) {
@@ -455,15 +455,15 @@ 
 	 *						depending on the value of the ReturnDateType flag
 	 */
 	public static function DATEVALUE($dateValue = 1) {
-		$dateValue = trim(PHPExcel_Calculation_Functions::flattenSingleValue($dateValue),'"');
+		$dateValue = trim(PHPExcel_Calculation_Functions::flattenSingleValue($dateValue), '"');
 		//	Strip any ordinals because they're allowed in Excel (English only)
-		$dateValue = preg_replace('/(\d)(st|nd|rd|th)([ -\/])/Ui','$1$3',$dateValue);
+		$dateValue = preg_replace('/(\d)(st|nd|rd|th)([ -\/])/Ui', '$1$3', $dateValue);
 		//	Convert separators (/ . or space) to hyphens (should also handle dot used for ordinals in some countries, e.g. Denmark, Germany)
-		$dateValue	= str_replace(array('/','.','-','  '),array(' ',' ',' ',' '),$dateValue);
+		$dateValue	= str_replace(array('/', '.', '-', '  '), array(' ', ' ', ' ', ' '), $dateValue);
 
 		$yearFound = false;
-		$t1 = explode(' ',$dateValue);
-		foreach($t1 as &$t) {
+		$t1 = explode(' ', $dateValue);
+		foreach ($t1 as &$t) {
 			if ((is_numeric($t)) && ($t > 31)) {
 				if ($yearFound) {
 					return PHPExcel_Calculation_Functions::VALUE();
@@ -473,23 +473,23 @@ 
 				}
 			}
 		}
-		if ((count($t1) == 1) && (strpos($t,':') != false)) {
+		if ((count($t1) == 1) && (strpos($t, ':') != false)) {
 			//	We've been fed a time value without any date
 			return 0.0;
 		} elseif (count($t1) == 2) {
 			//	We only have two parts of the date: either day/month or month/year
 			if ($yearFound) {
-				array_unshift($t1,1);
+				array_unshift($t1, 1);
 			} else {
-				array_push($t1,date('Y'));
+				array_push($t1, date('Y'));
 			}
 		}
 		unset($t);
-		$dateValue = implode(' ',$t1);
+		$dateValue = implode(' ', $t1);
 
 		$PHPDateArray = date_parse($dateValue);
 		if (($PHPDateArray === False) || ($PHPDateArray['error_count'] > 0)) {
-			$testVal1 = strtok($dateValue,'- ');
+			$testVal1 = strtok($dateValue, '- ');
 			if ($testVal1 !== False) {
 				$testVal2 = strtok('- ');
 				if ($testVal2 !== False) {
@@ -514,12 +514,12 @@ 
 
 		if (($PHPDateArray !== False) && ($PHPDateArray['error_count'] == 0)) {
 			// Execute function
-			if ($PHPDateArray['year'] == '')	{ $PHPDateArray['year'] = strftime('%Y'); }
+			if ($PHPDateArray['year'] == '') { $PHPDateArray['year'] = strftime('%Y'); }
 			if ($PHPDateArray['year'] < 1900)
 				return PHPExcel_Calculation_Functions::VALUE();
-			if ($PHPDateArray['month'] == '')	{ $PHPDateArray['month'] = strftime('%m'); }
-			if ($PHPDateArray['day'] == '')		{ $PHPDateArray['day'] = strftime('%d'); }
-			$excelDateValue = floor(PHPExcel_Shared_Date::FormattedPHPToExcel($PHPDateArray['year'],$PHPDateArray['month'],$PHPDateArray['day'],$PHPDateArray['hour'],$PHPDateArray['minute'],$PHPDateArray['second']));
+			if ($PHPDateArray['month'] == '') { $PHPDateArray['month'] = strftime('%m'); }
+			if ($PHPDateArray['day'] == '') { $PHPDateArray['day'] = strftime('%d'); }
+			$excelDateValue = floor(PHPExcel_Shared_Date::FormattedPHPToExcel($PHPDateArray['year'], $PHPDateArray['month'], $PHPDateArray['day'], $PHPDateArray['hour'], $PHPDateArray['minute'], $PHPDateArray['second']));
 
 			switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
 				case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL :
@@ -557,22 +557,22 @@ 
 	 *						depending on the value of the ReturnDateType flag
 	 */
 	public static function TIMEVALUE($timeValue) {
-		$timeValue = trim(PHPExcel_Calculation_Functions::flattenSingleValue($timeValue),'"');
-		$timeValue	= str_replace(array('/','.'),array('-','-'),$timeValue);
+		$timeValue = trim(PHPExcel_Calculation_Functions::flattenSingleValue($timeValue), '"');
+		$timeValue	= str_replace(array('/', '.'), array('-', '-'), $timeValue);
 
 		$PHPDateArray = date_parse($timeValue);
 		if (($PHPDateArray !== False) && ($PHPDateArray['error_count'] == 0)) {
 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
-				$excelDateValue = PHPExcel_Shared_Date::FormattedPHPToExcel($PHPDateArray['year'],$PHPDateArray['month'],$PHPDateArray['day'],$PHPDateArray['hour'],$PHPDateArray['minute'],$PHPDateArray['second']);
+				$excelDateValue = PHPExcel_Shared_Date::FormattedPHPToExcel($PHPDateArray['year'], $PHPDateArray['month'], $PHPDateArray['day'], $PHPDateArray['hour'], $PHPDateArray['minute'], $PHPDateArray['second']);
 			} else {
-				$excelDateValue = PHPExcel_Shared_Date::FormattedPHPToExcel(1900,1,1,$PHPDateArray['hour'],$PHPDateArray['minute'],$PHPDateArray['second']) - 1;
+				$excelDateValue = PHPExcel_Shared_Date::FormattedPHPToExcel(1900, 1, 1, $PHPDateArray['hour'], $PHPDateArray['minute'], $PHPDateArray['second']) - 1;
 			}
 
 			switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
 				case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL :
 						return (float) $excelDateValue;
 				case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC :
-						return (integer) $phpDateValue = PHPExcel_Shared_Date::ExcelToPHP($excelDateValue+25569) - 3600;;
+						return (integer) $phpDateValue = PHPExcel_Shared_Date::ExcelToPHP($excelDateValue + 25569) - 3600; ;
 				case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT :
 						return new DateTime('1900-01-01 '.$PHPDateArray['hour'].':'.$PHPDateArray['minute'].':'.$PHPDateArray['second']);
 			}
@@ -592,9 +592,9 @@ 
 	 * @return	integer	Interval between the dates
 	 */
 	public static function DATEDIF($startDate = 0, $endDate = 0, $unit = 'D') {
-		$startDate	= PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
-		$endDate	= PHPExcel_Calculation_Functions::flattenSingleValue($endDate);
-		$unit		= strtoupper(PHPExcel_Calculation_Functions::flattenSingleValue($unit));
+		$startDate = PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
+		$endDate = PHPExcel_Calculation_Functions::flattenSingleValue($endDate);
+		$unit = strtoupper(PHPExcel_Calculation_Functions::flattenSingleValue($unit));
 
 		if (is_string($startDate = self::_getDateValue($startDate))) {
 			return PHPExcel_Calculation_Functions::VALUE();
@@ -710,8 +710,8 @@ 
 	 * @return	integer		Number of days between start date and end date
 	 */
 	public static function DAYS360($startDate = 0, $endDate = 0, $method = false) {
-		$startDate	= PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
-		$endDate	= PHPExcel_Calculation_Functions::flattenSingleValue($endDate);
+		$startDate = PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
+		$endDate = PHPExcel_Calculation_Functions::flattenSingleValue($endDate);
 
 		if (is_string($startDate = self::_getDateValue($startDate))) {
 			return PHPExcel_Calculation_Functions::VALUE();
@@ -731,7 +731,7 @@ 
 		$endMonth = $PHPEndDateObject->format('n');
 		$endYear = $PHPEndDateObject->format('Y');
 
-		return self::_dateDiff360($startDay, $startMonth, $startYear, $endDay, $endMonth, $endYear, !$method);
+		return self::_dateDiff360($startDay, $startMonth, $startYear, $endDay, $endMonth, $endYear, ! $method);
 	}	//	function DAYS360()
 
 
@@ -761,7 +761,7 @@ 
 	 * @return	float	fraction of the year
 	 */
 	public static function YEARFRAC($startDate = 0, $endDate = 0, $method = 0) {
-		$startDate	= PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
+		$startDate = PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
 		$endDate	= PHPExcel_Calculation_Functions::flattenSingleValue($endDate);
 		$method		= PHPExcel_Calculation_Functions::flattenSingleValue($method);
 
@@ -772,12 +772,12 @@ 
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 
-		if (((is_numeric($method)) && (!is_string($method))) || ($method == '')) {
-			switch($method) {
+		if (((is_numeric($method)) && ( ! is_string($method))) || ($method == '')) {
+			switch ($method) {
 				case 0	:
-					return self::DAYS360($startDate,$endDate) / 360;
+					return self::DAYS360($startDate, $endDate) / 360;
 				case 1	:
-					$days = self::DATEDIF($startDate,$endDate);
+					$days = self::DATEDIF($startDate, $endDate);
 					$startYear = self::YEAR($startDate);
 					$endYear = self::YEAR($endDate);
 					$years = $endYear - $startYear + 1;
@@ -793,14 +793,14 @@ 
 							}
 						}
 					} else {
-						for($year = $startYear; $year <= $endYear; ++$year) {
+						for ($year = $startYear; $year <= $endYear; ++$year) {
 							if ($year == $startYear) {
 								$startMonth = self::MONTHOFYEAR($startDate);
 								$startDay = self::DAYOFMONTH($startDate);
 								if ($startMonth < 3) {
 									$leapDays += (self::_isLeapYear($year)) ? 1 : 0;
 								}
-							} elseif($year == $endYear) {
+							} elseif ($year == $endYear) {
 								$endMonth = self::MONTHOFYEAR($endDate);
 								$endDay = self::DAYOFMONTH($endDate);
 								if (($endMonth * 100 + $endDay) >= (2 * 100 + 29)) {
@@ -821,11 +821,11 @@ 
 					}
 					return $days / (365 + $leapDays);
 				case 2	:
-					return self::DATEDIF($startDate,$endDate) / 360;
+					return self::DATEDIF($startDate, $endDate) / 360;
 				case 3	:
-					return self::DATEDIF($startDate,$endDate) / 365;
+					return self::DATEDIF($startDate, $endDate) / 365;
 				case 4	:
-					return self::DAYS360($startDate,$endDate,True) / 360;
+					return self::DAYS360($startDate, $endDate, True) / 360;
 			}
 		}
 		return PHPExcel_Calculation_Functions::VALUE();
@@ -855,10 +855,10 @@ 
 	 *											as state and federal holidays and floating holidays.
 	 * @return	integer			Interval between the dates
 	 */
-	public static function NETWORKDAYS($startDate,$endDate) {
+	public static function NETWORKDAYS($startDate, $endDate) {
 		//	Retrieve the mandatory start and end date that are referenced in the function definition
-		$startDate	= PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
-		$endDate	= PHPExcel_Calculation_Functions::flattenSingleValue($endDate);
+		$startDate = PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
+		$endDate = PHPExcel_Calculation_Functions::flattenSingleValue($endDate);
 		//	Flush the mandatory start and end date that are referenced in the function definition, and get the optional days
 		$dateArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
 		array_shift($dateArgs);
@@ -880,9 +880,9 @@ 
 		}
 
 		// Execute function
-		$startDoW = 6 - self::DAYOFWEEK($startDate,2);
+		$startDoW = 6 - self::DAYOFWEEK($startDate, 2);
 		if ($startDoW < 0) { $startDoW = 0; }
-		$endDoW = self::DAYOFWEEK($endDate,2);
+		$endDoW = self::DAYOFWEEK($endDate, 2);
 		if ($endDoW >= 6) { $endDoW = 0; }
 
 		$wholeWeekDays = floor(($endDate - $startDate) / 7) * 5;
@@ -898,7 +898,7 @@ 
 				return PHPExcel_Calculation_Functions::VALUE();
 			}
 			if (($holidayDate >= $startDate) && ($holidayDate <= $endDate)) {
-				if ((self::DAYOFWEEK($holidayDate,2) < 6) && (!in_array($holidayDate,$holidayCountedArray))) {
+				if ((self::DAYOFWEEK($holidayDate, 2) < 6) && ( ! in_array($holidayDate, $holidayCountedArray))) {
 					--$partWeekDays;
 					$holidayCountedArray[] = $holidayDate;
 				}
@@ -937,16 +937,16 @@ 
 	 * @return	mixed	Excel date/time serial value, PHP date/time serial value or PHP date/time object,
 	 *						depending on the value of the ReturnDateType flag
 	 */
-	public static function WORKDAY($startDate,$endDays) {
+	public static function WORKDAY($startDate, $endDays) {
 		//	Retrieve the mandatory start date and days that are referenced in the function definition
-		$startDate	= PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
-		$endDays	= PHPExcel_Calculation_Functions::flattenSingleValue($endDays);
+		$startDate = PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
+		$endDays = PHPExcel_Calculation_Functions::flattenSingleValue($endDays);
 		//	Flush the mandatory start date and days that are referenced in the function definition, and get the optional days
 		$dateArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
 		array_shift($dateArgs);
 		array_shift($dateArgs);
 
-		if ((is_string($startDate = self::_getDateValue($startDate))) || (!is_numeric($endDays))) {
+		if ((is_string($startDate = self::_getDateValue($startDate))) || ( ! is_numeric($endDays))) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 		$startDate = (float) floor($startDate);
@@ -958,9 +958,9 @@ 
 
 		//	Adjust the start date if it falls over a weekend
 
-		$startDoW = self::DAYOFWEEK($startDate,3);
-		if (self::DAYOFWEEK($startDate,3) >= 5) {
-			$startDate += ($decrementing) ? -$startDoW + 4: 7 - $startDoW;
+		$startDoW = self::DAYOFWEEK($startDate, 3);
+		if (self::DAYOFWEEK($startDate, 3) >= 5) {
+			$startDate += ($decrementing) ? -$startDoW + 4 : 7 - $startDoW;
 			($decrementing) ? $endDays++ : $endDays--;
 		}
 
@@ -968,20 +968,20 @@ 
 		$endDate = (float) $startDate + (intval($endDays / 5) * 7) + ($endDays % 5);
 
 		//	Adjust the calculated end date if it falls over a weekend
-		$endDoW = self::DAYOFWEEK($endDate,3);
+		$endDoW = self::DAYOFWEEK($endDate, 3);
 		if ($endDoW >= 5) {
-			$endDate += ($decrementing) ? -$endDoW + 4: 7 - $endDoW;
+			$endDate += ($decrementing) ? -$endDoW + 4 : 7 - $endDoW;
 		}
 
 		//	Test any extra holiday parameters
-		if (!empty($dateArgs)) {
+		if ( ! empty($dateArgs)) {
 			$holidayCountedArray = $holidayDates = array();
 			foreach ($dateArgs as $holidayDate) {
 				if (($holidayDate !== NULL) && (trim($holidayDate) > '')) {
 					if (is_string($holidayDate = self::_getDateValue($holidayDate))) {
 						return PHPExcel_Calculation_Functions::VALUE();
 					}
-					if (self::DAYOFWEEK($holidayDate,3) < 5) {
+					if (self::DAYOFWEEK($holidayDate, 3) < 5) {
 						$holidayDates[] = $holidayDate;
 					}
 				}
@@ -994,23 +994,23 @@ 
 			foreach ($holidayDates as $holidayDate) {
 				if ($decrementing) {
 					if (($holidayDate <= $startDate) && ($holidayDate >= $endDate)) {
-						if (!in_array($holidayDate,$holidayCountedArray)) {
+						if ( ! in_array($holidayDate, $holidayCountedArray)) {
 							--$endDate;
 							$holidayCountedArray[] = $holidayDate;
 						}
 					}
 				} else {
 					if (($holidayDate >= $startDate) && ($holidayDate <= $endDate)) {
-						if (!in_array($holidayDate,$holidayCountedArray)) {
+						if ( ! in_array($holidayDate, $holidayCountedArray)) {
 							++$endDate;
 							$holidayCountedArray[] = $holidayDate;
 						}
 					}
 				}
 				//	Adjust the calculated end date if it falls over a weekend
-				$endDoW = self::DAYOFWEEK($endDate,3);
+				$endDoW = self::DAYOFWEEK($endDate, 3);
 				if ($endDoW >= 5) {
-					$endDate += ($decrementing) ? -$endDoW + 4: 7 - $endDoW;
+					$endDate += ($decrementing) ? -$endDoW + 4 : 7 - $endDoW;
 				}
 
 			}
@@ -1041,7 +1041,7 @@ 
 	 * @return	int		Day of the month
 	 */
 	public static function DAYOFMONTH($dateValue = 1) {
-		$dateValue	= PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
+		$dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
 
 		if (is_string($dateValue = self::_getDateValue($dateValue))) {
 			return PHPExcel_Calculation_Functions::VALUE();
@@ -1076,10 +1076,10 @@ 
 	 * @return	int		Day of the week value
 	 */
 	public static function DAYOFWEEK($dateValue = 1, $style = 1) {
-		$dateValue	= PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
-		$style		= PHPExcel_Calculation_Functions::flattenSingleValue($style);
+		$dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
+		$style = PHPExcel_Calculation_Functions::flattenSingleValue($style);
 
-		if (!is_numeric($style)) {
+		if ( ! is_numeric($style)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		} elseif (($style < 1) || ($style > 3)) {
 			return PHPExcel_Calculation_Functions::NaN();
@@ -1142,10 +1142,10 @@ 
 	 * @return	int		Week Number
 	 */
 	public static function WEEKOFYEAR($dateValue = 1, $method = 1) {
-		$dateValue	= PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
-		$method		= PHPExcel_Calculation_Functions::flattenSingleValue($method);
+		$dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
+		$method = PHPExcel_Calculation_Functions::flattenSingleValue($method);
 
-		if (!is_numeric($method)) {
+		if ( ! is_numeric($method)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		} elseif (($method < 1) || ($method > 2)) {
 			return PHPExcel_Calculation_Functions::NaN();
@@ -1186,7 +1186,7 @@ 
 	 * @return	int		Month of the year
 	 */
 	public static function MONTHOFYEAR($dateValue = 1) {
-		$dateValue	= PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
+		$dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
 
 		if (is_string($dateValue = self::_getDateValue($dateValue))) {
 			return PHPExcel_Calculation_Functions::VALUE();
@@ -1215,7 +1215,7 @@ 
 	 * @return	int		Year
 	 */
 	public static function YEAR($dateValue = 1) {
-		$dateValue	= PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
+		$dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
 
 		if (is_string($dateValue = self::_getDateValue($dateValue))) {
 			return PHPExcel_Calculation_Functions::VALUE();
@@ -1244,11 +1244,11 @@ 
 	 * @return	int		Hour
 	 */
 	public static function HOUROFDAY($timeValue = 0) {
-		$timeValue	= PHPExcel_Calculation_Functions::flattenSingleValue($timeValue);
+		$timeValue = PHPExcel_Calculation_Functions::flattenSingleValue($timeValue);
 
-		if (!is_numeric($timeValue)) {
+		if ( ! is_numeric($timeValue)) {
 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
-				$testVal = strtok($timeValue,'/-: ');
+				$testVal = strtok($timeValue, '/-: ');
 				if (strlen($testVal) < strlen($timeValue)) {
 					return PHPExcel_Calculation_Functions::VALUE();
 				}
@@ -1260,13 +1260,13 @@ 
 		}
 		// Execute function
 		if ($timeValue >= 1) {
-			$timeValue = fmod($timeValue,1);
+			$timeValue = fmod($timeValue, 1);
 		} elseif ($timeValue < 0.0) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
 		$timeValue = PHPExcel_Shared_Date::ExcelToPHP($timeValue);
 
-		return (int) gmdate('G',$timeValue);
+		return (int) gmdate('G', $timeValue);
 	}	//	function HOUROFDAY()
 
 
@@ -1284,11 +1284,11 @@ 
 	 * @return	int		Minute
 	 */
 	public static function MINUTEOFHOUR($timeValue = 0) {
-		$timeValue = $timeTester	= PHPExcel_Calculation_Functions::flattenSingleValue($timeValue);
+		$timeValue = $timeTester = PHPExcel_Calculation_Functions::flattenSingleValue($timeValue);
 
-		if (!is_numeric($timeValue)) {
+		if ( ! is_numeric($timeValue)) {
 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
-				$testVal = strtok($timeValue,'/-: ');
+				$testVal = strtok($timeValue, '/-: ');
 				if (strlen($testVal) < strlen($timeValue)) {
 					return PHPExcel_Calculation_Functions::VALUE();
 				}
@@ -1300,13 +1300,13 @@ 
 		}
 		// Execute function
 		if ($timeValue >= 1) {
-			$timeValue = fmod($timeValue,1);
+			$timeValue = fmod($timeValue, 1);
 		} elseif ($timeValue < 0.0) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
 		$timeValue = PHPExcel_Shared_Date::ExcelToPHP($timeValue);
 
-		return (int) gmdate('i',$timeValue);
+		return (int) gmdate('i', $timeValue);
 	}	//	function MINUTEOFHOUR()
 
 
@@ -1324,11 +1324,11 @@ 
 	 * @return	int		Second
 	 */
 	public static function SECONDOFMINUTE($timeValue = 0) {
-		$timeValue	= PHPExcel_Calculation_Functions::flattenSingleValue($timeValue);
+		$timeValue = PHPExcel_Calculation_Functions::flattenSingleValue($timeValue);
 
-		if (!is_numeric($timeValue)) {
+		if ( ! is_numeric($timeValue)) {
 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
-				$testVal = strtok($timeValue,'/-: ');
+				$testVal = strtok($timeValue, '/-: ');
 				if (strlen($testVal) < strlen($timeValue)) {
 					return PHPExcel_Calculation_Functions::VALUE();
 				}
@@ -1340,13 +1340,13 @@ 
 		}
 		// Execute function
 		if ($timeValue >= 1) {
-			$timeValue = fmod($timeValue,1);
+			$timeValue = fmod($timeValue, 1);
 		} elseif ($timeValue < 0.0) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
 		$timeValue = PHPExcel_Shared_Date::ExcelToPHP($timeValue);
 
-		return (int) gmdate('s',$timeValue);
+		return (int) gmdate('s', $timeValue);
 	}	//	function SECONDOFMINUTE()
 
 
@@ -1370,10 +1370,10 @@ 
 	 *						depending on the value of the ReturnDateType flag
 	 */
 	public static function EDATE($dateValue = 1, $adjustmentMonths = 0) {
-		$dateValue			= PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
-		$adjustmentMonths	= PHPExcel_Calculation_Functions::flattenSingleValue($adjustmentMonths);
+		$dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
+		$adjustmentMonths = PHPExcel_Calculation_Functions::flattenSingleValue($adjustmentMonths);
 
-		if (!is_numeric($adjustmentMonths)) {
+		if ( ! is_numeric($adjustmentMonths)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 		$adjustmentMonths = floor($adjustmentMonths);
@@ -1383,7 +1383,7 @@ 
 		}
 
 		// Execute function
-		$PHPDateObject = self::_adjustDateByMonths($dateValue,$adjustmentMonths);
+		$PHPDateObject = self::_adjustDateByMonths($dateValue, $adjustmentMonths);
 
 		switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
 			case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL :
@@ -1415,10 +1415,10 @@ 
 	 *						depending on the value of the ReturnDateType flag
 	 */
 	public static function EOMONTH($dateValue = 1, $adjustmentMonths = 0) {
-		$dateValue			= PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
-		$adjustmentMonths	= PHPExcel_Calculation_Functions::flattenSingleValue($adjustmentMonths);
+		$dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
+		$adjustmentMonths = PHPExcel_Calculation_Functions::flattenSingleValue($adjustmentMonths);
 
-		if (!is_numeric($adjustmentMonths)) {
+		if ( ! is_numeric($adjustmentMonths)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 		$adjustmentMonths = floor($adjustmentMonths);
@@ -1428,7 +1428,7 @@ 
 		}
 
 		// Execute function
-		$PHPDateObject = self::_adjustDateByMonths($dateValue,$adjustmentMonths+1);
+		$PHPDateObject = self::_adjustDateByMonths($dateValue, $adjustmentMonths + 1);
 		$adjustDays = (int) $PHPDateObject->format('d');
 		$adjustDaysString = '-'.$adjustDays.' days';
 		$PHPDateObject->modify($adjustDaysString);

Braces +6 added lines, -3 removed lines

@@ -515,8 +515,9 @@ 
 		if (($PHPDateArray !== False) && ($PHPDateArray['error_count'] == 0)) {
 			// Execute function
 			if ($PHPDateArray['year'] == '')	{ $PHPDateArray['year'] = strftime('%Y'); }
-			if ($PHPDateArray['year'] < 1900)
-				return PHPExcel_Calculation_Functions::VALUE();
+			if ($PHPDateArray['year'] < 1900) {
+							return PHPExcel_Calculation_Functions::VALUE();
+			}
 			if ($PHPDateArray['month'] == '')	{ $PHPDateArray['month'] = strftime('%m'); }
 			if ($PHPDateArray['day'] == '')		{ $PHPDateArray['day'] = strftime('%d'); }
 			$excelDateValue = floor(PHPExcel_Shared_Date::FormattedPHPToExcel($PHPDateArray['year'],$PHPDateArray['month'],$PHPDateArray['day'],$PHPDateArray['hour'],$PHPDateArray['minute'],$PHPDateArray['second']));
@@ -656,7 +657,9 @@ 
 				break;
 			case 'YM':
 				$retVal = intval($endMonths - $startMonths);
-				if ($retVal < 0) $retVal = 12 + $retVal;
+				if ($retVal < 0) {
+					$retVal = 12 + $retVal;
+				}
 				//	We're only interested in full months
 				if ($endDays < $startDays) {
 					--$retVal;

app/Vendor/PHPExcel/PHPExcel/Calculation/Engineering.php

Doc Comments +6 added lines, -5 removed lines

@@ -757,6 +757,9 @@ 
 	}
 
 
+	/**
+	 * @param string $xVal
+	 */
 	private static function _nbrConversionFormat($xVal,$places) {
 		if (!is_null($places)) {
 			if (strlen($xVal) <= $places) {
@@ -1716,7 +1719,7 @@ 
 	 * @access	public
 	 * @category Engineering Functions
 	 * @param	string		$complexNumber	The complex number for which you want the real coefficient.
-	 * @return	float
+	 * @return	string
 	 */
 	public static function IMREAL($complexNumber) {
 		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
@@ -2121,7 +2124,6 @@ 
 	 * Excel Function:
 	 *		IMSUM(complexNumber[,complexNumber[,...]])
 	 *
-	 * @param	string		$complexNumber,...	Series of complex numbers to add
 	 * @return	string
 	 */
 	public static function IMSUM() {
@@ -2157,7 +2159,6 @@ 
 	 * Excel Function:
 	 *		IMPRODUCT(complexNumber[,complexNumber[,...]])
 	 *
-	 * @param	string		$complexNumber,...	Series of complex numbers to multiply
 	 * @return	string
 	 */
 	public static function IMPRODUCT() {
@@ -2197,7 +2198,7 @@ 
 	 *		DELTA(a[,b])
 	 *
 	 * @param	float		$a	The first number.
-	 * @param	float		$b	The second number. If omitted, b is assumed to be zero.
+	 * @param	integer		$b	The second number. If omitted, b is assumed to be zero.
 	 * @return	int
 	 */
 	public static function DELTA($a, $b=0) {
@@ -2219,7 +2220,7 @@ 
 	 * functions you calculate the count of values that exceed a threshold.
 	 *
 	 * @param	float		$number		The value to test against step.
-	 * @param	float		$step		The threshold value.
+	 * @param	integer		$step		The threshold value.
 	 *									If you omit a value for step, GESTEP uses zero.
 	 * @return	int
 	 */

Spacing +285 added lines, -285 removed lines

@@ -27,12 +27,12 @@ 
 
 
 /** PHPExcel root directory */
-if (!defined('PHPEXCEL_ROOT')) {
+if ( ! defined('PHPEXCEL_ROOT')) {
 	/**
 	 * @ignore
 	 */
-	define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
-	require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	define('PHPEXCEL_ROOT', dirname(__FILE__).'/../../');
+	require(PHPEXCEL_ROOT.'PHPExcel/Autoloader.php');
 }
 
 
@@ -54,69 +54,69 @@ 
 	 *
 	 * @var mixed[]
 	 */
-	private static $_conversionUnits = array( 'g'		=> array(	'Group'	=> 'Mass',			'Unit Name'	=> 'Gram',						'AllowPrefix'	=> True		),
-											  'sg'		=> array(	'Group'	=> 'Mass',			'Unit Name'	=> 'Slug',						'AllowPrefix'	=> False	),
-											  'lbm'		=> array(	'Group'	=> 'Mass',			'Unit Name'	=> 'Pound mass (avoirdupois)',	'AllowPrefix'	=> False	),
-											  'u'		=> array(	'Group'	=> 'Mass',			'Unit Name'	=> 'U (atomic mass unit)',		'AllowPrefix'	=> True		),
-											  'ozm'		=> array(	'Group'	=> 'Mass',			'Unit Name'	=> 'Ounce mass (avoirdupois)',	'AllowPrefix'	=> False	),
-											  'm'		=> array(	'Group'	=> 'Distance',		'Unit Name'	=> 'Meter',						'AllowPrefix'	=> True		),
-											  'mi'		=> array(	'Group'	=> 'Distance',		'Unit Name'	=> 'Statute mile',				'AllowPrefix'	=> False	),
-											  'Nmi'		=> array(	'Group'	=> 'Distance',		'Unit Name'	=> 'Nautical mile',				'AllowPrefix'	=> False	),
-											  'in'		=> array(	'Group'	=> 'Distance',		'Unit Name'	=> 'Inch',						'AllowPrefix'	=> False	),
-											  'ft'		=> array(	'Group'	=> 'Distance',		'Unit Name'	=> 'Foot',						'AllowPrefix'	=> False	),
-											  'yd'		=> array(	'Group'	=> 'Distance',		'Unit Name'	=> 'Yard',						'AllowPrefix'	=> False	),
-											  'ang'		=> array(	'Group'	=> 'Distance',		'Unit Name'	=> 'Angstrom',					'AllowPrefix'	=> True		),
-											  'Pica'	=> array(	'Group'	=> 'Distance',		'Unit Name'	=> 'Pica (1/72 in)',			'AllowPrefix'	=> False	),
-											  'yr'		=> array(	'Group'	=> 'Time',			'Unit Name'	=> 'Year',						'AllowPrefix'	=> False	),
-											  'day'		=> array(	'Group'	=> 'Time',			'Unit Name'	=> 'Day',						'AllowPrefix'	=> False	),
-											  'hr'		=> array(	'Group'	=> 'Time',			'Unit Name'	=> 'Hour',						'AllowPrefix'	=> False	),
-											  'mn'		=> array(	'Group'	=> 'Time',			'Unit Name'	=> 'Minute',					'AllowPrefix'	=> False	),
-											  'sec'		=> array(	'Group'	=> 'Time',			'Unit Name'	=> 'Second',					'AllowPrefix'	=> True		),
-											  'Pa'		=> array(	'Group'	=> 'Pressure',		'Unit Name'	=> 'Pascal',					'AllowPrefix'	=> True		),
-											  'p'		=> array(	'Group'	=> 'Pressure',		'Unit Name'	=> 'Pascal',					'AllowPrefix'	=> True		),
-											  'atm'		=> array(	'Group'	=> 'Pressure',		'Unit Name'	=> 'Atmosphere',				'AllowPrefix'	=> True		),
-											  'at'		=> array(	'Group'	=> 'Pressure',		'Unit Name'	=> 'Atmosphere',				'AllowPrefix'	=> True		),
-											  'mmHg'	=> array(	'Group'	=> 'Pressure',		'Unit Name'	=> 'mm of Mercury',				'AllowPrefix'	=> True		),
-											  'N'		=> array(	'Group'	=> 'Force',			'Unit Name'	=> 'Newton',					'AllowPrefix'	=> True		),
-											  'dyn'		=> array(	'Group'	=> 'Force',			'Unit Name'	=> 'Dyne',						'AllowPrefix'	=> True		),
-											  'dy'		=> array(	'Group'	=> 'Force',			'Unit Name'	=> 'Dyne',						'AllowPrefix'	=> True		),
-											  'lbf'		=> array(	'Group'	=> 'Force',			'Unit Name'	=> 'Pound force',				'AllowPrefix'	=> False	),
-											  'J'		=> array(	'Group'	=> 'Energy',		'Unit Name'	=> 'Joule',						'AllowPrefix'	=> True		),
-											  'e'		=> array(	'Group'	=> 'Energy',		'Unit Name'	=> 'Erg',						'AllowPrefix'	=> True		),
-											  'c'		=> array(	'Group'	=> 'Energy',		'Unit Name'	=> 'Thermodynamic calorie',		'AllowPrefix'	=> True		),
-											  'cal'		=> array(	'Group'	=> 'Energy',		'Unit Name'	=> 'IT calorie',				'AllowPrefix'	=> True		),
-											  'eV'		=> array(	'Group'	=> 'Energy',		'Unit Name'	=> 'Electron volt',				'AllowPrefix'	=> True		),
-											  'ev'		=> array(	'Group'	=> 'Energy',		'Unit Name'	=> 'Electron volt',				'AllowPrefix'	=> True		),
-											  'HPh'		=> array(	'Group'	=> 'Energy',		'Unit Name'	=> 'Horsepower-hour',			'AllowPrefix'	=> False	),
-											  'hh'		=> array(	'Group'	=> 'Energy',		'Unit Name'	=> 'Horsepower-hour',			'AllowPrefix'	=> False	),
-											  'Wh'		=> array(	'Group'	=> 'Energy',		'Unit Name'	=> 'Watt-hour',					'AllowPrefix'	=> True		),
-											  'wh'		=> array(	'Group'	=> 'Energy',		'Unit Name'	=> 'Watt-hour',					'AllowPrefix'	=> True		),
-											  'flb'		=> array(	'Group'	=> 'Energy',		'Unit Name'	=> 'Foot-pound',				'AllowPrefix'	=> False	),
-											  'BTU'		=> array(	'Group'	=> 'Energy',		'Unit Name'	=> 'BTU',						'AllowPrefix'	=> False	),
-											  'btu'		=> array(	'Group'	=> 'Energy',		'Unit Name'	=> 'BTU',						'AllowPrefix'	=> False	),
-											  'HP'		=> array(	'Group'	=> 'Power',			'Unit Name'	=> 'Horsepower',				'AllowPrefix'	=> False	),
-											  'h'		=> array(	'Group'	=> 'Power',			'Unit Name'	=> 'Horsepower',				'AllowPrefix'	=> False	),
-											  'W'		=> array(	'Group'	=> 'Power',			'Unit Name'	=> 'Watt',						'AllowPrefix'	=> True		),
-											  'w'		=> array(	'Group'	=> 'Power',			'Unit Name'	=> 'Watt',						'AllowPrefix'	=> True		),
-											  'T'		=> array(	'Group'	=> 'Magnetism',		'Unit Name'	=> 'Tesla',						'AllowPrefix'	=> True		),
-											  'ga'		=> array(	'Group'	=> 'Magnetism',		'Unit Name'	=> 'Gauss',						'AllowPrefix'	=> True		),
-											  'C'		=> array(	'Group'	=> 'Temperature',	'Unit Name'	=> 'Celsius',					'AllowPrefix'	=> False	),
-											  'cel'		=> array(	'Group'	=> 'Temperature',	'Unit Name'	=> 'Celsius',					'AllowPrefix'	=> False	),
-											  'F'		=> array(	'Group'	=> 'Temperature',	'Unit Name'	=> 'Fahrenheit',				'AllowPrefix'	=> False	),
-											  'fah'		=> array(	'Group'	=> 'Temperature',	'Unit Name'	=> 'Fahrenheit',				'AllowPrefix'	=> False	),
-											  'K'		=> array(	'Group'	=> 'Temperature',	'Unit Name'	=> 'Kelvin',					'AllowPrefix'	=> False	),
-											  'kel'		=> array(	'Group'	=> 'Temperature',	'Unit Name'	=> 'Kelvin',					'AllowPrefix'	=> False	),
-											  'tsp'		=> array(	'Group'	=> 'Liquid',		'Unit Name'	=> 'Teaspoon',					'AllowPrefix'	=> False	),
-											  'tbs'		=> array(	'Group'	=> 'Liquid',		'Unit Name'	=> 'Tablespoon',				'AllowPrefix'	=> False	),
-											  'oz'		=> array(	'Group'	=> 'Liquid',		'Unit Name'	=> 'Fluid Ounce',				'AllowPrefix'	=> False	),
-											  'cup'		=> array(	'Group'	=> 'Liquid',		'Unit Name'	=> 'Cup',						'AllowPrefix'	=> False	),
-											  'pt'		=> array(	'Group'	=> 'Liquid',		'Unit Name'	=> 'U.S. Pint',					'AllowPrefix'	=> False	),
-											  'us_pt'	=> array(	'Group'	=> 'Liquid',		'Unit Name'	=> 'U.S. Pint',					'AllowPrefix'	=> False	),
-											  'uk_pt'	=> array(	'Group'	=> 'Liquid',		'Unit Name'	=> 'U.K. Pint',					'AllowPrefix'	=> False	),
-											  'qt'		=> array(	'Group'	=> 'Liquid',		'Unit Name'	=> 'Quart',						'AllowPrefix'	=> False	),
-											  'gal'		=> array(	'Group'	=> 'Liquid',		'Unit Name'	=> 'Gallon',					'AllowPrefix'	=> False	),
-											  'l'		=> array(	'Group'	=> 'Liquid',		'Unit Name'	=> 'Litre',						'AllowPrefix'	=> True		),
-											  'lt'		=> array(	'Group'	=> 'Liquid',		'Unit Name'	=> 'Litre',						'AllowPrefix'	=> True		)
+	private static $_conversionUnits = array('g'		=> array('Group'	=> 'Mass', 'Unit Name'	=> 'Gram', 'AllowPrefix'	=> True),
+											  'sg'		=> array('Group'	=> 'Mass', 'Unit Name'	=> 'Slug', 'AllowPrefix'	=> False),
+											  'lbm'		=> array('Group'	=> 'Mass', 'Unit Name'	=> 'Pound mass (avoirdupois)', 'AllowPrefix'	=> False),
+											  'u'		=> array('Group'	=> 'Mass', 'Unit Name'	=> 'U (atomic mass unit)', 'AllowPrefix'	=> True),
+											  'ozm'		=> array('Group'	=> 'Mass', 'Unit Name'	=> 'Ounce mass (avoirdupois)', 'AllowPrefix'	=> False),
+											  'm'		=> array('Group'	=> 'Distance', 'Unit Name'	=> 'Meter', 'AllowPrefix'	=> True),
+											  'mi'		=> array('Group'	=> 'Distance', 'Unit Name'	=> 'Statute mile', 'AllowPrefix'	=> False),
+											  'Nmi'		=> array('Group'	=> 'Distance', 'Unit Name'	=> 'Nautical mile', 'AllowPrefix'	=> False),
+											  'in'		=> array('Group'	=> 'Distance', 'Unit Name'	=> 'Inch', 'AllowPrefix'	=> False),
+											  'ft'		=> array('Group'	=> 'Distance', 'Unit Name'	=> 'Foot', 'AllowPrefix'	=> False),
+											  'yd'		=> array('Group'	=> 'Distance', 'Unit Name'	=> 'Yard', 'AllowPrefix'	=> False),
+											  'ang'		=> array('Group'	=> 'Distance', 'Unit Name'	=> 'Angstrom', 'AllowPrefix'	=> True),
+											  'Pica'	=> array('Group'	=> 'Distance', 'Unit Name'	=> 'Pica (1/72 in)', 'AllowPrefix'	=> False),
+											  'yr'		=> array('Group'	=> 'Time', 'Unit Name'	=> 'Year', 'AllowPrefix'	=> False),
+											  'day'		=> array('Group'	=> 'Time', 'Unit Name'	=> 'Day', 'AllowPrefix'	=> False),
+											  'hr'		=> array('Group'	=> 'Time', 'Unit Name'	=> 'Hour', 'AllowPrefix'	=> False),
+											  'mn'		=> array('Group'	=> 'Time', 'Unit Name'	=> 'Minute', 'AllowPrefix'	=> False),
+											  'sec'		=> array('Group'	=> 'Time', 'Unit Name'	=> 'Second', 'AllowPrefix'	=> True),
+											  'Pa'		=> array('Group'	=> 'Pressure', 'Unit Name'	=> 'Pascal', 'AllowPrefix'	=> True),
+											  'p'		=> array('Group'	=> 'Pressure', 'Unit Name'	=> 'Pascal', 'AllowPrefix'	=> True),
+											  'atm'		=> array('Group'	=> 'Pressure', 'Unit Name'	=> 'Atmosphere', 'AllowPrefix'	=> True),
+											  'at'		=> array('Group'	=> 'Pressure', 'Unit Name'	=> 'Atmosphere', 'AllowPrefix'	=> True),
+											  'mmHg'	=> array('Group'	=> 'Pressure', 'Unit Name'	=> 'mm of Mercury', 'AllowPrefix'	=> True),
+											  'N'		=> array('Group'	=> 'Force', 'Unit Name'	=> 'Newton', 'AllowPrefix'	=> True),
+											  'dyn'		=> array('Group'	=> 'Force', 'Unit Name'	=> 'Dyne', 'AllowPrefix'	=> True),
+											  'dy'		=> array('Group'	=> 'Force', 'Unit Name'	=> 'Dyne', 'AllowPrefix'	=> True),
+											  'lbf'		=> array('Group'	=> 'Force', 'Unit Name'	=> 'Pound force', 'AllowPrefix'	=> False),
+											  'J'		=> array('Group'	=> 'Energy', 'Unit Name'	=> 'Joule', 'AllowPrefix'	=> True),
+											  'e'		=> array('Group'	=> 'Energy', 'Unit Name'	=> 'Erg', 'AllowPrefix'	=> True),
+											  'c'		=> array('Group'	=> 'Energy', 'Unit Name'	=> 'Thermodynamic calorie', 'AllowPrefix'	=> True),
+											  'cal'		=> array('Group'	=> 'Energy', 'Unit Name'	=> 'IT calorie', 'AllowPrefix'	=> True),
+											  'eV'		=> array('Group'	=> 'Energy', 'Unit Name'	=> 'Electron volt', 'AllowPrefix'	=> True),
+											  'ev'		=> array('Group'	=> 'Energy', 'Unit Name'	=> 'Electron volt', 'AllowPrefix'	=> True),
+											  'HPh'		=> array('Group'	=> 'Energy', 'Unit Name'	=> 'Horsepower-hour', 'AllowPrefix'	=> False),
+											  'hh'		=> array('Group'	=> 'Energy', 'Unit Name'	=> 'Horsepower-hour', 'AllowPrefix'	=> False),
+											  'Wh'		=> array('Group'	=> 'Energy', 'Unit Name'	=> 'Watt-hour', 'AllowPrefix'	=> True),
+											  'wh'		=> array('Group'	=> 'Energy', 'Unit Name'	=> 'Watt-hour', 'AllowPrefix'	=> True),
+											  'flb'		=> array('Group'	=> 'Energy', 'Unit Name'	=> 'Foot-pound', 'AllowPrefix'	=> False),
+											  'BTU'		=> array('Group'	=> 'Energy', 'Unit Name'	=> 'BTU', 'AllowPrefix'	=> False),
+											  'btu'		=> array('Group'	=> 'Energy', 'Unit Name'	=> 'BTU', 'AllowPrefix'	=> False),
+											  'HP'		=> array('Group'	=> 'Power', 'Unit Name'	=> 'Horsepower', 'AllowPrefix'	=> False),
+											  'h'		=> array('Group'	=> 'Power', 'Unit Name'	=> 'Horsepower', 'AllowPrefix'	=> False),
+											  'W'		=> array('Group'	=> 'Power', 'Unit Name'	=> 'Watt', 'AllowPrefix'	=> True),
+											  'w'		=> array('Group'	=> 'Power', 'Unit Name'	=> 'Watt', 'AllowPrefix'	=> True),
+											  'T'		=> array('Group'	=> 'Magnetism', 'Unit Name'	=> 'Tesla', 'AllowPrefix'	=> True),
+											  'ga'		=> array('Group'	=> 'Magnetism', 'Unit Name'	=> 'Gauss', 'AllowPrefix'	=> True),
+											  'C'		=> array('Group'	=> 'Temperature', 'Unit Name'	=> 'Celsius', 'AllowPrefix'	=> False),
+											  'cel'		=> array('Group'	=> 'Temperature', 'Unit Name'	=> 'Celsius', 'AllowPrefix'	=> False),
+											  'F'		=> array('Group'	=> 'Temperature', 'Unit Name'	=> 'Fahrenheit', 'AllowPrefix'	=> False),
+											  'fah'		=> array('Group'	=> 'Temperature', 'Unit Name'	=> 'Fahrenheit', 'AllowPrefix'	=> False),
+											  'K'		=> array('Group'	=> 'Temperature', 'Unit Name'	=> 'Kelvin', 'AllowPrefix'	=> False),
+											  'kel'		=> array('Group'	=> 'Temperature', 'Unit Name'	=> 'Kelvin', 'AllowPrefix'	=> False),
+											  'tsp'		=> array('Group'	=> 'Liquid', 'Unit Name'	=> 'Teaspoon', 'AllowPrefix'	=> False),
+											  'tbs'		=> array('Group'	=> 'Liquid', 'Unit Name'	=> 'Tablespoon', 'AllowPrefix'	=> False),
+											  'oz'		=> array('Group'	=> 'Liquid', 'Unit Name'	=> 'Fluid Ounce', 'AllowPrefix'	=> False),
+											  'cup'		=> array('Group'	=> 'Liquid', 'Unit Name'	=> 'Cup', 'AllowPrefix'	=> False),
+											  'pt'		=> array('Group'	=> 'Liquid', 'Unit Name'	=> 'U.S. Pint', 'AllowPrefix'	=> False),
+											  'us_pt'	=> array('Group'	=> 'Liquid', 'Unit Name'	=> 'U.S. Pint', 'AllowPrefix'	=> False),
+											  'uk_pt'	=> array('Group'	=> 'Liquid', 'Unit Name'	=> 'U.K. Pint', 'AllowPrefix'	=> False),
+											  'qt'		=> array('Group'	=> 'Liquid', 'Unit Name'	=> 'Quart', 'AllowPrefix'	=> False),
+											  'gal'		=> array('Group'	=> 'Liquid', 'Unit Name'	=> 'Gallon', 'AllowPrefix'	=> False),
+											  'l'		=> array('Group'	=> 'Liquid', 'Unit Name'	=> 'Litre', 'AllowPrefix'	=> True),
+											  'lt'		=> array('Group'	=> 'Liquid', 'Unit Name'	=> 'Litre', 'AllowPrefix'	=> True)
 											);
 
 	/**
@@ -124,26 +124,26 @@ 
 	 *
 	 * @var mixed[]
 	 */
-	private static $_conversionMultipliers = array(	'Y'	=> array(	'multiplier'	=> 1E24,	'name'	=> 'yotta'	),
-													'Z'	=> array(	'multiplier'	=> 1E21,	'name'	=> 'zetta'	),
-													'E'	=> array(	'multiplier'	=> 1E18,	'name'	=> 'exa'	),
-													'P'	=> array(	'multiplier'	=> 1E15,	'name'	=> 'peta'	),
-													'T'	=> array(	'multiplier'	=> 1E12,	'name'	=> 'tera'	),
-													'G'	=> array(	'multiplier'	=> 1E9,		'name'	=> 'giga'	),
-													'M'	=> array(	'multiplier'	=> 1E6,		'name'	=> 'mega'	),
-													'k'	=> array(	'multiplier'	=> 1E3,		'name'	=> 'kilo'	),
-													'h'	=> array(	'multiplier'	=> 1E2,		'name'	=> 'hecto'	),
-													'e'	=> array(	'multiplier'	=> 1E1,		'name'	=> 'deka'	),
-													'd'	=> array(	'multiplier'	=> 1E-1,	'name'	=> 'deci'	),
-													'c'	=> array(	'multiplier'	=> 1E-2,	'name'	=> 'centi'	),
-													'm'	=> array(	'multiplier'	=> 1E-3,	'name'	=> 'milli'	),
-													'u'	=> array(	'multiplier'	=> 1E-6,	'name'	=> 'micro'	),
-													'n'	=> array(	'multiplier'	=> 1E-9,	'name'	=> 'nano'	),
-													'p'	=> array(	'multiplier'	=> 1E-12,	'name'	=> 'pico'	),
-													'f'	=> array(	'multiplier'	=> 1E-15,	'name'	=> 'femto'	),
-													'a'	=> array(	'multiplier'	=> 1E-18,	'name'	=> 'atto'	),
-													'z'	=> array(	'multiplier'	=> 1E-21,	'name'	=> 'zepto'	),
-													'y'	=> array(	'multiplier'	=> 1E-24,	'name'	=> 'yocto'	)
+	private static $_conversionMultipliers = array('Y'	=> array('multiplier'	=> 1E24, 'name'	=> 'yotta'),
+													'Z'	=> array('multiplier'	=> 1E21, 'name'	=> 'zetta'),
+													'E'	=> array('multiplier'	=> 1E18, 'name'	=> 'exa'),
+													'P'	=> array('multiplier'	=> 1E15, 'name'	=> 'peta'),
+													'T'	=> array('multiplier'	=> 1E12, 'name'	=> 'tera'),
+													'G'	=> array('multiplier'	=> 1E9, 'name'	=> 'giga'),
+													'M'	=> array('multiplier'	=> 1E6, 'name'	=> 'mega'),
+													'k'	=> array('multiplier'	=> 1E3, 'name'	=> 'kilo'),
+													'h'	=> array('multiplier'	=> 1E2, 'name'	=> 'hecto'),
+													'e'	=> array('multiplier'	=> 1E1, 'name'	=> 'deka'),
+													'd'	=> array('multiplier'	=> 1E-1, 'name'	=> 'deci'),
+													'c'	=> array('multiplier'	=> 1E-2, 'name'	=> 'centi'),
+													'm'	=> array('multiplier'	=> 1E-3, 'name'	=> 'milli'),
+													'u'	=> array('multiplier'	=> 1E-6, 'name'	=> 'micro'),
+													'n'	=> array('multiplier'	=> 1E-9, 'name'	=> 'nano'),
+													'p'	=> array('multiplier'	=> 1E-12, 'name'	=> 'pico'),
+													'f'	=> array('multiplier'	=> 1E-15, 'name'	=> 'femto'),
+													'a'	=> array('multiplier'	=> 1E-18, 'name'	=> 'atto'),
+													'z'	=> array('multiplier'	=> 1E-21, 'name'	=> 'zepto'),
+													'y'	=> array('multiplier'	=> 1E-24, 'name'	=> 'yocto')
 												 );
 
 	/**
@@ -151,38 +151,38 @@ 
 	 *
 	 * @var mixed[]
 	 */
-	private static $_unitConversions = array(	'Mass'		=> array(	'g'		=> array(	'g'		=> 1.0,
+	private static $_unitConversions = array('Mass'		=> array('g'		=> array('g'		=> 1.0,
 																							'sg'	=> 6.85220500053478E-05,
 																							'lbm'	=> 2.20462291469134E-03,
 																							'u'		=> 6.02217000000000E+23,
 																							'ozm'	=> 3.52739718003627E-02
 																						),
-																		'sg'	=> array(	'g'		=> 1.45938424189287E+04,
+																		'sg'	=> array('g'		=> 1.45938424189287E+04,
 																							'sg'	=> 1.0,
 																							'lbm'	=> 3.21739194101647E+01,
 																							'u'		=> 8.78866000000000E+27,
 																							'ozm'	=> 5.14782785944229E+02
 																						),
-																		'lbm'	=> array(	'g'		=> 4.5359230974881148E+02,
+																		'lbm'	=> array('g'		=> 4.5359230974881148E+02,
 																							'sg'	=> 3.10810749306493E-02,
 																							'lbm'	=> 1.0,
 																							'u'		=> 2.73161000000000E+26,
 																							'ozm'	=> 1.60000023429410E+01
 																						),
-																		'u'		=> array(	'g'		=> 1.66053100460465E-24,
+																		'u'		=> array('g'		=> 1.66053100460465E-24,
 																							'sg'	=> 1.13782988532950E-28,
 																							'lbm'	=> 3.66084470330684E-27,
 																							'u'		=> 1.0,
 																							'ozm'	=> 5.85735238300524E-26
 																						),
-																		'ozm'	=> array(	'g'		=> 2.83495152079732E+01,
+																		'ozm'	=> array('g'		=> 2.83495152079732E+01,
 																							'sg'	=> 1.94256689870811E-03,
 																							'lbm'	=> 6.24999908478882E-02,
 																							'u'		=> 1.70725600000000E+25,
 																							'ozm'	=> 1.0
 																						)
 																	),
-												'Distance'	=> array(	'm'		=> array(	'm'		=> 1.0,
+												'Distance'	=> array('m'		=> array('m'		=> 1.0,
 																							'mi'	=> 6.21371192237334E-04,
 																							'Nmi'	=> 5.39956803455724E-04,
 																							'in'	=> 3.93700787401575E+01,
@@ -191,7 +191,7 @@ 
 																							'ang'	=> 1.00000000000000E+10,
 																							'Pica'	=> 2.83464566929116E+03
 																						),
-																		'mi'	=> array(	'm'		=> 1.60934400000000E+03,
+																		'mi'	=> array('m'		=> 1.60934400000000E+03,
 																							'mi'	=> 1.0,
 																							'Nmi'	=> 8.68976241900648E-01,
 																							'in'	=> 6.33600000000000E+04,
@@ -200,7 +200,7 @@ 
 																							'ang'	=> 1.60934400000000E+13,
 																							'Pica'	=> 4.56191999999971E+06
 																						),
-																		'Nmi'	=> array(	'm'		=> 1.85200000000000E+03,
+																		'Nmi'	=> array('m'		=> 1.85200000000000E+03,
 																							'mi'	=> 1.15077944802354E+00,
 																							'Nmi'	=> 1.0,
 																							'in'	=> 7.29133858267717E+04,
@@ -209,7 +209,7 @@ 
 																							'ang'	=> 1.85200000000000E+13,
 																							'Pica'	=> 5.24976377952723E+06
 																						),
-																		'in'	=> array(	'm'		=> 2.54000000000000E-02,
+																		'in'	=> array('m'		=> 2.54000000000000E-02,
 																							'mi'	=> 1.57828282828283E-05,
 																							'Nmi'	=> 1.37149028077754E-05,
 																							'in'	=> 1.0,
@@ -218,7 +218,7 @@ 
 																							'ang'	=> 2.54000000000000E+08,
 																							'Pica'	=> 7.19999999999955E+01
 																						),
-																		'ft'	=> array(	'm'		=> 3.04800000000000E-01,
+																		'ft'	=> array('m'		=> 3.04800000000000E-01,
 																							'mi'	=> 1.89393939393939E-04,
 																							'Nmi'	=> 1.64578833693305E-04,
 																							'in'	=> 1.20000000000000E+01,
@@ -227,7 +227,7 @@ 
 																							'ang'	=> 3.04800000000000E+09,
 																							'Pica'	=> 8.63999999999946E+02
 																						),
-																		'yd'	=> array(	'm'		=> 9.14400000300000E-01,
+																		'yd'	=> array('m'		=> 9.14400000300000E-01,
 																							'mi'	=> 5.68181818368230E-04,
 																							'Nmi'	=> 4.93736501241901E-04,
 																							'in'	=> 3.60000000118110E+01,
@@ -236,7 +236,7 @@ 
 																							'ang'	=> 9.14400000300000E+09,
 																							'Pica'	=> 2.59200000085023E+03
 																						),
-																		'ang'	=> array(	'm'		=> 1.00000000000000E-10,
+																		'ang'	=> array('m'		=> 1.00000000000000E-10,
 																							'mi'	=> 6.21371192237334E-14,
 																							'Nmi'	=> 5.39956803455724E-14,
 																							'in'	=> 3.93700787401575E-09,
@@ -245,7 +245,7 @@ 
 																							'ang'	=> 1.0,
 																							'Pica'	=> 2.83464566929116E-07
 																						),
-																		'Pica'	=> array(	'm'		=> 3.52777777777800E-04,
+																		'Pica'	=> array('m'		=> 3.52777777777800E-04,
 																							'mi'	=> 2.19205948372629E-07,
 																							'Nmi'	=> 1.90484761219114E-07,
 																							'in'	=> 1.38888888888898E-02,
@@ -255,90 +255,90 @@ 
 																							'Pica'	=> 1.0
 																						)
 																	),
-												'Time'		=> array(	'yr'	=> array(	'yr'		=> 1.0,
+												'Time'		=> array('yr'	=> array('yr'		=> 1.0,
 																							'day'		=> 365.25,
 																							'hr'		=> 8766.0,
 																							'mn'		=> 525960.0,
 																							'sec'		=> 31557600.0
 																						),
-																		'day'	=> array(	'yr'		=> 2.73785078713210E-03,
+																		'day'	=> array('yr'		=> 2.73785078713210E-03,
 																							'day'		=> 1.0,
 																							'hr'		=> 24.0,
 																							'mn'		=> 1440.0,
 																							'sec'		=> 86400.0
 																						),
-																		'hr'	=> array(	'yr'		=> 1.14077116130504E-04,
+																		'hr'	=> array('yr'		=> 1.14077116130504E-04,
 																							'day'		=> 4.16666666666667E-02,
 																							'hr'		=> 1.0,
 																							'mn'		=> 60.0,
 																							'sec'		=> 3600.0
 																						),
-																		'mn'	=> array(	'yr'		=> 1.90128526884174E-06,
+																		'mn'	=> array('yr'		=> 1.90128526884174E-06,
 																							'day'		=> 6.94444444444444E-04,
 																							'hr'		=> 1.66666666666667E-02,
 																							'mn'		=> 1.0,
 																							'sec'		=> 60.0
 																						),
-																		'sec'	=> array(	'yr'		=> 3.16880878140289E-08,
+																		'sec'	=> array('yr'		=> 3.16880878140289E-08,
 																							'day'		=> 1.15740740740741E-05,
 																							'hr'		=> 2.77777777777778E-04,
 																							'mn'		=> 1.66666666666667E-02,
 																							'sec'		=> 1.0
 																						)
 																	),
-												'Pressure'	=> array(	'Pa'	=> array(	'Pa'		=> 1.0,
+												'Pressure'	=> array('Pa'	=> array('Pa'		=> 1.0,
 																							'p'			=> 1.0,
 																							'atm'		=> 9.86923299998193E-06,
 																							'at'		=> 9.86923299998193E-06,
 																							'mmHg'		=> 7.50061707998627E-03
 																						),
-																		'p'		=> array(	'Pa'		=> 1.0,
+																		'p'		=> array('Pa'		=> 1.0,
 																							'p'			=> 1.0,
 																							'atm'		=> 9.86923299998193E-06,
 																							'at'		=> 9.86923299998193E-06,
 																							'mmHg'		=> 7.50061707998627E-03
 																						),
-																		'atm'	=> array(	'Pa'		=> 1.01324996583000E+05,
+																		'atm'	=> array('Pa'		=> 1.01324996583000E+05,
 																							'p'			=> 1.01324996583000E+05,
 																							'atm'		=> 1.0,
 																							'at'		=> 1.0,
 																							'mmHg'		=> 760.0
 																						),
-																		'at'	=> array(	'Pa'		=> 1.01324996583000E+05,
+																		'at'	=> array('Pa'		=> 1.01324996583000E+05,
 																							'p'			=> 1.01324996583000E+05,
 																							'atm'		=> 1.0,
 																							'at'		=> 1.0,
 																							'mmHg'		=> 760.0
 																						),
-																		'mmHg'	=> array(	'Pa'		=> 1.33322363925000E+02,
+																		'mmHg'	=> array('Pa'		=> 1.33322363925000E+02,
 																							'p'			=> 1.33322363925000E+02,
 																							'atm'		=> 1.31578947368421E-03,
 																							'at'		=> 1.31578947368421E-03,
 																							'mmHg'		=> 1.0
 																						)
 																	),
-												'Force'		=> array(	'N'		=> array(	'N'			=> 1.0,
+												'Force'		=> array('N'		=> array('N'			=> 1.0,
 																							'dyn'		=> 1.0E+5,
 																							'dy'		=> 1.0E+5,
 																							'lbf'		=> 2.24808923655339E-01
 																						),
-																		'dyn'	=> array(	'N'			=> 1.0E-5,
+																		'dyn'	=> array('N'			=> 1.0E-5,
 																							'dyn'		=> 1.0,
 																							'dy'		=> 1.0,
 																							'lbf'		=> 2.24808923655339E-06
 																						),
-																		'dy'	=> array(	'N'			=> 1.0E-5,
+																		'dy'	=> array('N'			=> 1.0E-5,
 																							'dyn'		=> 1.0,
 																							'dy'		=> 1.0,
 																							'lbf'		=> 2.24808923655339E-06
 																						),
-																		'lbf'	=> array(	'N'			=> 4.448222,
+																		'lbf'	=> array('N'			=> 4.448222,
 																							'dyn'		=> 4.448222E+5,
 																							'dy'		=> 4.448222E+5,
 																							'lbf'		=> 1.0
 																						)
 																	),
-												'Energy'	=> array(	'J'		=> array(	'J'			=> 1.0,
+												'Energy'	=> array('J'		=> array('J'			=> 1.0,
 																							'e'			=> 9.99999519343231E+06,
 																							'c'			=> 2.39006249473467E-01,
 																							'cal'		=> 2.38846190642017E-01,
@@ -352,7 +352,7 @@ 
 																							'BTU'		=> 9.47815067349015E-04,
 																							'btu'		=> 9.47815067349015E-04
 																						),
-																		'e'		=> array(	'J'			=> 1.00000048065700E-07,
+																		'e'		=> array('J'			=> 1.00000048065700E-07,
 																							'e'			=> 1.0,
 																							'c'			=> 2.39006364353494E-08,
 																							'cal'		=> 2.38846305445111E-08,
@@ -366,7 +366,7 @@ 
 																							'BTU'		=> 9.47815522922962E-11,
 																							'btu'		=> 9.47815522922962E-11
 																						),
-																		'c'		=> array(	'J'			=> 4.18399101363672E+00,
+																		'c'		=> array('J'			=> 4.18399101363672E+00,
 																							'e'			=> 4.18398900257312E+07,
 																							'c'			=> 1.0,
 																							'cal'		=> 9.99330315287563E-01,
@@ -380,7 +380,7 @@ 
 																							'BTU'		=> 3.96564972437776E-03,
 																							'btu'		=> 3.96564972437776E-03
 																						),
-																		'cal'	=> array(	'J'			=> 4.18679484613929E+00,
+																		'cal'	=> array('J'			=> 4.18679484613929E+00,
 																							'e'			=> 4.18679283372801E+07,
 																							'c'			=> 1.00067013349059E+00,
 																							'cal'		=> 1.0,
@@ -394,7 +394,7 @@ 
 																							'BTU'		=> 3.96830723907002E-03,
 																							'btu'		=> 3.96830723907002E-03
 																						),
-																		'eV'	=> array(	'J'			=> 1.60219000146921E-19,
+																		'eV'	=> array('J'			=> 1.60219000146921E-19,
 																							'e'			=> 1.60218923136574E-12,
 																							'c'			=> 3.82933423195043E-20,
 																							'cal'		=> 3.82676978535648E-20,
@@ -408,7 +408,7 @@ 
 																							'BTU'		=> 1.51857982414846E-22,
 																							'btu'		=> 1.51857982414846E-22
 																						),
-																		'ev'	=> array(	'J'			=> 1.60219000146921E-19,
+																		'ev'	=> array('J'			=> 1.60219000146921E-19,
 																							'e'			=> 1.60218923136574E-12,
 																							'c'			=> 3.82933423195043E-20,
 																							'cal'		=> 3.82676978535648E-20,
@@ -422,7 +422,7 @@ 
 																							'BTU'		=> 1.51857982414846E-22,
 																							'btu'		=> 1.51857982414846E-22
 																						),
-																		'HPh'	=> array(	'J'			=> 2.68451741316170E+06,
+																		'HPh'	=> array('J'			=> 2.68451741316170E+06,
 																							'e'			=> 2.68451612283024E+13,
 																							'c'			=> 6.41616438565991E+05,
 																							'cal'		=> 6.41186757845835E+05,
@@ -436,7 +436,7 @@ 
 																							'BTU'		=> 2.54442605275546E+03,
 																							'btu'		=> 2.54442605275546E+03
 																						),
-																		'hh'	=> array(	'J'			=> 2.68451741316170E+06,
+																		'hh'	=> array('J'			=> 2.68451741316170E+06,
 																							'e'			=> 2.68451612283024E+13,
 																							'c'			=> 6.41616438565991E+05,
 																							'cal'		=> 6.41186757845835E+05,
@@ -450,7 +450,7 @@ 
 																							'BTU'		=> 2.54442605275546E+03,
 																							'btu'		=> 2.54442605275546E+03
 																						),
-																		'Wh'	=> array(	'J'			=> 3.59999820554720E+03,
+																		'Wh'	=> array('J'			=> 3.59999820554720E+03,
 																							'e'			=> 3.59999647518369E+10,
 																							'c'			=> 8.60422069219046E+02,
 																							'cal'		=> 8.59845857713046E+02,
@@ -464,7 +464,7 @@ 
 																							'BTU'		=> 3.41213254164705E+00,
 																							'btu'		=> 3.41213254164705E+00
 																						),
-																		'wh'	=> array(	'J'			=> 3.59999820554720E+03,
+																		'wh'	=> array('J'			=> 3.59999820554720E+03,
 																							'e'			=> 3.59999647518369E+10,
 																							'c'			=> 8.60422069219046E+02,
 																							'cal'		=> 8.59845857713046E+02,
@@ -478,7 +478,7 @@ 
 																							'BTU'		=> 3.41213254164705E+00,
 																							'btu'		=> 3.41213254164705E+00
 																						),
-																		'flb'	=> array(	'J'			=> 4.21400003236424E-02,
+																		'flb'	=> array('J'			=> 4.21400003236424E-02,
 																							'e'			=> 4.21399800687660E+05,
 																							'c'			=> 1.00717234301644E-02,
 																							'cal'		=> 1.00649785509554E-02,
@@ -492,7 +492,7 @@ 
 																							'BTU'		=> 3.99409272448406E-05,
 																							'btu'		=> 3.99409272448406E-05
 																						),
-																		'BTU'	=> array(	'J'			=> 1.05505813786749E+03,
+																		'BTU'	=> array('J'			=> 1.05505813786749E+03,
 																							'e'			=> 1.05505763074665E+10,
 																							'c'			=> 2.52165488508168E+02,
 																							'cal'		=> 2.51996617135510E+02,
@@ -506,7 +506,7 @@ 
 																							'BTU'		=> 1.0,
 																							'btu'		=> 1.0,
 																						),
-																		'btu'	=> array(	'J'			=> 1.05505813786749E+03,
+																		'btu'	=> array('J'			=> 1.05505813786749E+03,
 																							'e'			=> 1.05505763074665E+10,
 																							'c'			=> 2.52165488508168E+02,
 																							'cal'		=> 2.51996617135510E+02,
@@ -521,35 +521,35 @@ 
 																							'btu'		=> 1.0,
 																						)
 																	),
-												'Power'		=> array(	'HP'	=> array(	'HP'		=> 1.0,
+												'Power'		=> array('HP'	=> array('HP'		=> 1.0,
 																							'h'			=> 1.0,
 																							'W'			=> 7.45701000000000E+02,
 																							'w'			=> 7.45701000000000E+02
 																						),
-																		'h'		=> array(	'HP'		=> 1.0,
+																		'h'		=> array('HP'		=> 1.0,
 																							'h'			=> 1.0,
 																							'W'			=> 7.45701000000000E+02,
 																							'w'			=> 7.45701000000000E+02
 																						),
-																		'W'		=> array(	'HP'		=> 1.34102006031908E-03,
+																		'W'		=> array('HP'		=> 1.34102006031908E-03,
 																							'h'			=> 1.34102006031908E-03,
 																							'W'			=> 1.0,
 																							'w'			=> 1.0
 																						),
-																		'w'		=> array(	'HP'		=> 1.34102006031908E-03,
+																		'w'		=> array('HP'		=> 1.34102006031908E-03,
 																							'h'			=> 1.34102006031908E-03,
 																							'W'			=> 1.0,
 																							'w'			=> 1.0
 																						)
 																	),
-												'Magnetism'	=> array(	'T'		=> array(	'T'			=> 1.0,
+												'Magnetism'	=> array('T'		=> array('T'			=> 1.0,
 																							'ga'		=> 10000.0
 																						),
-																		'ga'	=> array(	'T'			=> 0.0001,
+																		'ga'	=> array('T'			=> 0.0001,
 																							'ga'		=> 1.0
 																						)
 																	),
-												'Liquid'	=> array(	'tsp'	=> array(	'tsp'		=> 1.0,
+												'Liquid'	=> array('tsp'	=> array('tsp'		=> 1.0,
 																							'tbs'		=> 3.33333333333333E-01,
 																							'oz'		=> 1.66666666666667E-01,
 																							'cup'		=> 2.08333333333333E-02,
@@ -561,7 +561,7 @@ 
 																							'l'			=> 4.92999408400710E-03,
 																							'lt'		=> 4.92999408400710E-03
 																						),
-																		'tbs'	=> array(	'tsp'		=> 3.00000000000000E+00,
+																		'tbs'	=> array('tsp'		=> 3.00000000000000E+00,
 																							'tbs'		=> 1.0,
 																							'oz'		=> 5.00000000000000E-01,
 																							'cup'		=> 6.25000000000000E-02,
@@ -573,7 +573,7 @@ 
 																							'l'			=> 1.47899822520213E-02,
 																							'lt'		=> 1.47899822520213E-02
 																						),
-																		'oz'	=> array(	'tsp'		=> 6.00000000000000E+00,
+																		'oz'	=> array('tsp'		=> 6.00000000000000E+00,
 																							'tbs'		=> 2.00000000000000E+00,
 																							'oz'		=> 1.0,
 																							'cup'		=> 1.25000000000000E-01,
@@ -585,7 +585,7 @@ 
 																							'l'			=> 2.95799645040426E-02,
 																							'lt'		=> 2.95799645040426E-02
 																						),
-																		'cup'	=> array(	'tsp'		=> 4.80000000000000E+01,
+																		'cup'	=> array('tsp'		=> 4.80000000000000E+01,
 																							'tbs'		=> 1.60000000000000E+01,
 																							'oz'		=> 8.00000000000000E+00,
 																							'cup'		=> 1.0,
@@ -597,7 +597,7 @@ 
 																							'l'			=> 2.36639716032341E-01,
 																							'lt'		=> 2.36639716032341E-01
 																						),
-																		'pt'	=> array(	'tsp'		=> 9.60000000000000E+01,
+																		'pt'	=> array('tsp'		=> 9.60000000000000E+01,
 																							'tbs'		=> 3.20000000000000E+01,
 																							'oz'		=> 1.60000000000000E+01,
 																							'cup'		=> 2.00000000000000E+00,
@@ -609,7 +609,7 @@ 
 																							'l'			=> 4.73279432064682E-01,
 																							'lt'		=> 4.73279432064682E-01
 																						),
-																		'us_pt'	=> array(	'tsp'		=> 9.60000000000000E+01,
+																		'us_pt'	=> array('tsp'		=> 9.60000000000000E+01,
 																							'tbs'		=> 3.20000000000000E+01,
 																							'oz'		=> 1.60000000000000E+01,
 																							'cup'		=> 2.00000000000000E+00,
@@ -621,7 +621,7 @@ 
 																							'l'			=> 4.73279432064682E-01,
 																							'lt'		=> 4.73279432064682E-01
 																						),
-																		'uk_pt'	=> array(	'tsp'		=> 1.15266000000000E+02,
+																		'uk_pt'	=> array('tsp'		=> 1.15266000000000E+02,
 																							'tbs'		=> 3.84220000000000E+01,
 																							'oz'		=> 1.92110000000000E+01,
 																							'cup'		=> 2.40137500000000E+00,
@@ -633,7 +633,7 @@ 
 																							'l'			=> 5.68260698087162E-01,
 																							'lt'		=> 5.68260698087162E-01
 																						),
-																		'qt'	=> array(	'tsp'		=> 1.92000000000000E+02,
+																		'qt'	=> array('tsp'		=> 1.92000000000000E+02,
 																							'tbs'		=> 6.40000000000000E+01,
 																							'oz'		=> 3.20000000000000E+01,
 																							'cup'		=> 4.00000000000000E+00,
@@ -645,7 +645,7 @@ 
 																							'l'			=> 9.46558864129363E-01,
 																							'lt'		=> 9.46558864129363E-01
 																						),
-																		'gal'	=> array(	'tsp'		=> 7.68000000000000E+02,
+																		'gal'	=> array('tsp'		=> 7.68000000000000E+02,
 																							'tbs'		=> 2.56000000000000E+02,
 																							'oz'		=> 1.28000000000000E+02,
 																							'cup'		=> 1.60000000000000E+01,
@@ -657,7 +657,7 @@ 
 																							'l'			=> 3.78623545651745E+00,
 																							'lt'		=> 3.78623545651745E+00
 																						),
-																		'l'		=> array(	'tsp'		=> 2.02840000000000E+02,
+																		'l'		=> array('tsp'		=> 2.02840000000000E+02,
 																							'tbs'		=> 6.76133333333333E+01,
 																							'oz'		=> 3.38066666666667E+01,
 																							'cup'		=> 4.22583333333333E+00,
@@ -669,7 +669,7 @@ 
 																							'l'			=> 1.0,
 																							'lt'		=> 1.0
 																						),
-																		'lt'	=> array(	'tsp'		=> 2.02840000000000E+02,
+																		'lt'	=> array('tsp'		=> 2.02840000000000E+02,
 																							'tbs'		=> 6.76133333333333E+01,
 																							'oz'		=> 3.38066666666667E+01,
 																							'cup'		=> 4.22583333333333E+00,
@@ -698,9 +698,9 @@ 
 
 		$realNumber = $imaginary = 0;
 		//	Extract the suffix, if there is one
-		$suffix = substr($workString,-1);
-		if (!is_numeric($suffix)) {
-			$workString = substr($workString,0,-1);
+		$suffix = substr($workString, -1);
+		if ( ! is_numeric($suffix)) {
+			$workString = substr($workString, 0, -1);
 		} else {
 			$suffix = '';
 		}
@@ -712,15 +712,15 @@ 
 		}
 		$power = '';
 		$realNumber = strtok($workString, '+-');
-		if (strtoupper(substr($realNumber,-1)) == 'E') {
+		if (strtoupper(substr($realNumber, -1)) == 'E') {
 			$power = strtok('+-');
 			++$leadingSign;
 		}
 
-		$realNumber = substr($workString,0,strlen($realNumber)+strlen($power)+$leadingSign);
+		$realNumber = substr($workString, 0, strlen($realNumber) + strlen($power) + $leadingSign);
 
 		if ($suffix != '') {
-			$imaginary = substr($workString,strlen($realNumber));
+			$imaginary = substr($workString, strlen($realNumber));
 
 			if (($imaginary == '') && (($realNumber == '') || ($realNumber == '+') || ($realNumber == '-'))) {
 				$imaginary = $realNumber.'1';
@@ -733,7 +733,7 @@ 
 			}
 		}
 
-		return array( 'real'		=> $realNumber,
+		return array('real'		=> $realNumber,
 					  'imaginary'	=> $imaginary,
 					  'suffix'		=> $suffix
 					);
@@ -749,24 +749,24 @@ 
 	 * @return	string		The "cleaned" complex number
 	 */
 	private static function _cleanComplex($complexNumber) {
-		if ($complexNumber{0} == '+') $complexNumber = substr($complexNumber,1);
-		if ($complexNumber{0} == '0') $complexNumber = substr($complexNumber,1);
+		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);
+		if ($complexNumber{0} == '+') $complexNumber = substr($complexNumber, 1);
 		return $complexNumber;
 	}
 
 
-	private static function _nbrConversionFormat($xVal,$places) {
-		if (!is_null($places)) {
+	private static function _nbrConversionFormat($xVal, $places) {
+		if ( ! is_null($places)) {
 			if (strlen($xVal) <= $places) {
-				return substr(str_pad($xVal,$places,'0',STR_PAD_LEFT),-10);
+				return substr(str_pad($xVal, $places, '0', STR_PAD_LEFT), -10);
 			} else {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
 		}
 
-		return substr($xVal,-10);
+		return substr($xVal, -10);
 	}	//	function _nbrConversionFormat()
 
 
@@ -792,11 +792,11 @@ 
 	 *
 	 */
 	public static function BESSELI($x, $ord) {
-		$x	= (is_null($x))	? 0.0 :	PHPExcel_Calculation_Functions::flattenSingleValue($x);
-		$ord	= (is_null($ord))	? 0.0 :	PHPExcel_Calculation_Functions::flattenSingleValue($ord);
+		$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);
+			$ord = floor($ord);
 			if ($ord < 0) {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
@@ -846,11 +846,11 @@ 
 	 *
 	 */
 	public static function BESSELJ($x, $ord) {
-		$x	= (is_null($x))	? 0.0 :	PHPExcel_Calculation_Functions::flattenSingleValue($x);
-		$ord	= (is_null($ord))	? 0.0 :	PHPExcel_Calculation_Functions::flattenSingleValue($ord);
+		$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);
+			$ord = floor($ord);
 			if ($ord < 0) {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
@@ -937,26 +937,26 @@ 
 	 *
 	 */
 	public static function BESSELK($x, $ord) {
-		$x		= (is_null($x))		? 0.0 :	PHPExcel_Calculation_Functions::flattenSingleValue($x);
-		$ord	= (is_null($ord))	? 0.0 :	PHPExcel_Calculation_Functions::flattenSingleValue($ord);
+		$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)) {
+			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);
+				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;
+								$fBk = $fBkp;
 							}
 			}
 			return (is_nan($fBk)) ? PHPExcel_Calculation_Functions::NaN() : $fBk;
@@ -990,7 +990,7 @@ 
 				(-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);
+			$fRet = $f1 / $f2 + 0.636619772 * (self::BESSELJ($fNum, 1) * log($fNum) - 1 / $fNum);
 		} else {
 //			$z = 8.0 / $fNum;
 //			$y = ($z * $z);
@@ -1026,26 +1026,26 @@ 
 	 * @return	float
 	 */
 	public static function BESSELY($x, $ord) {
-		$x		= (is_null($x))		? 0.0 :	PHPExcel_Calculation_Functions::flattenSingleValue($x);
-		$ord	= (is_null($ord))	? 0.0 :	PHPExcel_Calculation_Functions::flattenSingleValue($ord);
+		$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)) {
+			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);
+				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;
+								$fBy = $fByp;
 							}
 			}
 			return (is_nan($fBy)) ? PHPExcel_Calculation_Functions::NaN() : $fBy;
@@ -1073,7 +1073,7 @@ 
 	 * @return	string
 	 */
 	public static function BINTODEC($x) {
-		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
+		$x = PHPExcel_Calculation_Functions::flattenSingleValue($x);
 
 		if (is_bool($x)) {
 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
@@ -1086,15 +1086,15 @@ 
 			$x = floor($x);
 		}
 		$x = (string) $x;
-		if (strlen($x) > preg_match_all('/[01]/',$x,$out)) {
+		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));
+			$x = substr($x, -9);
+			return '-'.(512 - bindec($x));
 		}
 		return bindec($x);
 	}	//	function BINTODEC()
@@ -1124,9 +1124,9 @@ 
 	 *								If places is negative, BIN2HEX returns the #NUM! error value.
 	 * @return	string
 	 */
-	public static function BINTOHEX($x, $places=NULL) {
-		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
-		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
+	public static function BINTOHEX($x, $places = NULL) {
+		$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) {
@@ -1139,18 +1139,18 @@ 
 			$x = floor($x);
 		}
 		$x = (string) $x;
-		if (strlen($x) > preg_match_all('/[01]/',$x,$out)) {
+		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);
+			return str_repeat('F', 8).substr(strtoupper(dechex(bindec(substr($x, -9)))), -2);
 		}
 		$hexVal = (string) strtoupper(dechex(bindec($x)));
 
-		return self::_nbrConversionFormat($hexVal,$places);
+		return self::_nbrConversionFormat($hexVal, $places);
 	}	//	function BINTOHEX()
 
 
@@ -1178,9 +1178,9 @@ 
 	 *								If places is negative, BIN2OCT returns the #NUM! error value.
 	 * @return	string
 	 */
-	public static function BINTOOCT($x, $places=NULL) {
-		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
-		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
+	public static function BINTOOCT($x, $places = NULL) {
+		$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) {
@@ -1193,18 +1193,18 @@ 
 			$x = floor($x);
 		}
 		$x = (string) $x;
-		if (strlen($x) > preg_match_all('/[01]/',$x,$out)) {
+		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);
+			return str_repeat('7', 7).substr(strtoupper(decoct(bindec(substr($x, -9)))), -3);
 		}
 		$octVal = (string) decoct(bindec($x));
 
-		return self::_nbrConversionFormat($octVal,$places);
+		return self::_nbrConversionFormat($octVal, $places);
 	}	//	function BINTOOCT()
 
 
@@ -1236,9 +1236,9 @@ 
 	 *								If places is zero or negative, DEC2BIN returns the #NUM! error value.
 	 * @return	string
 	 */
-	public static function DECTOBIN($x, $places=NULL) {
-		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
-		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
+	public static function DECTOBIN($x, $places = NULL) {
+		$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) {
@@ -1248,19 +1248,19 @@ 
 			}
 		}
 		$x = (string) $x;
-		if (strlen($x) > preg_match_all('/[-0123456789.]/',$x,$out)) {
+		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);
+			$r = substr($r, -10);
 		} elseif (strlen($r) > 11) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
 
-		return self::_nbrConversionFormat($r,$places);
+		return self::_nbrConversionFormat($r, $places);
 	}	//	function DECTOBIN()
 
 
@@ -1292,9 +1292,9 @@ 
 	 *								If places is zero or negative, DEC2HEX returns the #NUM! error value.
 	 * @return	string
 	 */
-	public static function DECTOHEX($x, $places=null) {
-		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
-		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
+	public static function DECTOHEX($x, $places = null) {
+		$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) {
@@ -1304,7 +1304,7 @@ 
 			}
 		}
 		$x = (string) $x;
-		if (strlen($x) > preg_match_all('/[-0123456789.]/',$x,$out)) {
+		if (strlen($x) > preg_match_all('/[-0123456789.]/', $x, $out)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 		$x = (string) floor($x);
@@ -1314,7 +1314,7 @@ 
 			$r = 'FF'.$r;
 		}
 
-		return self::_nbrConversionFormat($r,$places);
+		return self::_nbrConversionFormat($r, $places);
 	}	//	function DECTOHEX()
 
 
@@ -1346,9 +1346,9 @@ 
 	 *								If places is zero or negative, DEC2OCT returns the #NUM! error value.
 	 * @return	string
 	 */
-	public static function DECTOOCT($x, $places=null) {
-		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
-		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
+	public static function DECTOOCT($x, $places = null) {
+		$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) {
@@ -1358,17 +1358,17 @@ 
 			}
 		}
 		$x = (string) $x;
-		if (strlen($x) > preg_match_all('/[-0123456789.]/',$x,$out)) {
+		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);
+			$r = substr($r, -10);
 		}
 
-		return self::_nbrConversionFormat($r,$places);
+		return self::_nbrConversionFormat($r, $places);
 	}	//	function DECTOOCT()
 
 
@@ -1403,20 +1403,20 @@ 
 	 *									If places is negative, HEX2BIN returns the #NUM! error value.
 	 * @return	string
 	 */
-	public static function HEXTOBIN($x, $places=null) {
-		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
-		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
+	public static function HEXTOBIN($x, $places = null) {
+		$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)) {
+		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);
+		return substr(self::_nbrConversionFormat($binVal, $places), -10);
 	}	//	function HEXTOBIN()
 
 
@@ -1440,13 +1440,13 @@ 
 	 * @return	string
 	 */
 	public static function HEXTODEC($x) {
-		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
+		$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)) {
+		if (strlen($x) > preg_match_all('/[0123456789ABCDEF]/', strtoupper($x), $out)) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
 		return hexdec($x);
@@ -1485,20 +1485,20 @@ 
 	 *									If places is negative, HEX2OCT returns the #NUM! error value.
 	 * @return	string
 	 */
-	public static function HEXTOOCT($x, $places=null) {
-		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
-		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
+	public static function HEXTOOCT($x, $places = null) {
+		$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)) {
+		if (strlen($x) > preg_match_all('/[0123456789ABCDEF]/', strtoupper($x), $out)) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
 		$octVal = decoct(hexdec($x));
 
-		return self::_nbrConversionFormat($octVal,$places);
+		return self::_nbrConversionFormat($octVal, $places);
 	}	//	function HEXTOOCT()
 
 
@@ -1536,20 +1536,20 @@ 
 	 *									value.
 	 * @return	string
 	 */
-	public static function OCTTOBIN($x, $places=null) {
-		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
-		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
+	public static function OCTTOBIN($x, $places = null) {
+		$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)) {
+		if (preg_match_all('/[01234567]/', $x, $out) != strlen($x)) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
 		$r = decbin(octdec($x));
 
-		return self::_nbrConversionFormat($r,$places);
+		return self::_nbrConversionFormat($r, $places);
 	}	//	function OCTTOBIN()
 
 
@@ -1573,13 +1573,13 @@ 
 	 * @return	string
 	 */
 	public static function OCTTODEC($x) {
-		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
+		$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)) {
+		if (preg_match_all('/[01234567]/', $x, $out) != strlen($x)) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
 		return octdec($x);
@@ -1615,20 +1615,20 @@ 
 	 *									If places is negative, OCT2HEX returns the #NUM! error value.
 	 * @return	string
 	 */
-	public static function OCTTOHEX($x, $places=null) {
-		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
-		$places	= PHPExcel_Calculation_Functions::flattenSingleValue($places);
+	public static function OCTTOHEX($x, $places = null) {
+		$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)) {
+		if (preg_match_all('/[01234567]/', $x, $out) != strlen($x)) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
 		$hexVal = strtoupper(dechex(octdec($x)));
 
-		return self::_nbrConversionFormat($hexVal,$places);
+		return self::_nbrConversionFormat($hexVal, $places);
 	}	//	function OCTTOHEX()
 
 
@@ -1648,15 +1648,15 @@ 
 	 *										If omitted, the suffix is assumed to be "i".
 	 * @return	string
 	 */
-	public static function COMPLEX($realNumber=0.0, $imaginary=0.0, $suffix='i') {
-		$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);
+	public static function COMPLEX($realNumber = 0.0, $imaginary = 0.0, $suffix = 'i') {
+		$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;
+			$realNumber = (float) $realNumber;
+			$imaginary = (float) $imaginary;
 
 			if ($suffix == '') $suffix = 'i';
 			if ($realNumber == 0.0) {
@@ -1766,7 +1766,7 @@ 
 		if ($parsedComplex['real'] == 0.0) {
 			if ($parsedComplex['imaginary'] == 0.0) {
 				return 0.0;
-			} elseif($parsedComplex['imaginary'] < 0.0) {
+			} elseif ($parsedComplex['imaginary'] < 0.0) {
 				return M_PI / -2;
 			} else {
 				return M_PI / 2;
@@ -1800,7 +1800,7 @@ 
 		if ($parsedComplex['imaginary'] == 0.0) {
 			return $parsedComplex['real'];
 		} else {
-			return self::_cleanComplex( self::COMPLEX( $parsedComplex['real'],
+			return self::_cleanComplex(self::COMPLEX($parsedComplex['real'],
 													   0 - $parsedComplex['imaginary'],
 													   $parsedComplex['suffix']
 													 )
@@ -1828,7 +1828,7 @@ 
 		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']));
+			return self::IMCONJUGATE(self::COMPLEX(cos($parsedComplex['real']) * cosh($parsedComplex['imaginary']), sin($parsedComplex['real']) * sinh($parsedComplex['imaginary']), $parsedComplex['suffix']));
 		}
 	}	//	function IMCOS()
 
@@ -1852,7 +1852,7 @@ 
 		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']);
+			return self::COMPLEX(sin($parsedComplex['real']) * cosh($parsedComplex['imaginary']), cos($parsedComplex['real']) * sinh($parsedComplex['imaginary']), $parsedComplex['suffix']);
 		}
 	}	//	function IMSIN()
 
@@ -1879,9 +1879,9 @@ 
 		$r = sqrt(sqrt(($parsedComplex['real'] * $parsedComplex['real']) + ($parsedComplex['imaginary'] * $parsedComplex['imaginary'])));
 
 		if ($parsedComplex['suffix'] == '') {
-			return self::COMPLEX($d1 * $r,$d2 * $r);
+			return self::COMPLEX($d1 * $r, $d2 * $r);
 		} else {
-			return self::COMPLEX($d1 * $r,$d2 * $r,$parsedComplex['suffix']);
+			return self::COMPLEX($d1 * $r, $d2 * $r, $parsedComplex['suffix']);
 		}
 	}	//	function IMSQRT()
 
@@ -1910,9 +1910,9 @@ 
 		$t = self::IMARGUMENT($complexNumber);
 
 		if ($parsedComplex['suffix'] == '') {
-			return self::COMPLEX($logR,$t);
+			return self::COMPLEX($logR, $t);
 		} else {
-			return self::COMPLEX($logR,$t,$parsedComplex['suffix']);
+			return self::COMPLEX($logR, $t, $parsedComplex['suffix']);
 		}
 	}	//	function IMLN()
 
@@ -1939,7 +1939,7 @@ 
 			return log10($parsedComplex['real']);
 		}
 
-		return self::IMPRODUCT(log10(EULER),self::IMLN($complexNumber));
+		return self::IMPRODUCT(log10(EULER), self::IMLN($complexNumber));
 	}	//	function IMLOG10()
 
 
@@ -1962,10 +1962,10 @@ 
 		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 log($parsedComplex['real'], 2);
 		}
 
-		return self::IMPRODUCT(log(EULER,2),self::IMLN($complexNumber));
+		return self::IMPRODUCT(log(EULER, 2), self::IMLN($complexNumber));
 	}	//	function IMLOG2()
 
 
@@ -1994,9 +1994,9 @@ 
 		$eY = $e * sin($parsedComplex['imaginary']);
 
 		if ($parsedComplex['suffix'] == '') {
-			return self::COMPLEX($eX,$eY);
+			return self::COMPLEX($eX, $eY);
 		} else {
-			return self::COMPLEX($eX,$eY,$parsedComplex['suffix']);
+			return self::COMPLEX($eX, $eY, $parsedComplex['suffix']);
 		}
 	}	//	function IMEXP()
 
@@ -2013,25 +2013,25 @@ 
 	 * @param	float		$realNumber		The power to which you want to raise the complex number.
 	 * @return	string
 	 */
-	public static function IMPOWER($complexNumber,$realNumber) {
-		$complexNumber	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
-		$realNumber		= PHPExcel_Calculation_Functions::flattenSingleValue($realNumber);
+	public static function IMPOWER($complexNumber, $realNumber) {
+		$complexNumber = PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber);
+		$realNumber = PHPExcel_Calculation_Functions::flattenSingleValue($realNumber);
 
-		if (!is_numeric($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);
+		$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']);
+			return self::COMPLEX($rPower * cos($theta), $rPower * sin($theta), $parsedComplex['suffix']);
 		} else {
-			return self::COMPLEX($rPower * cos($theta),$rPower * sin($theta),$parsedComplex['suffix']);
+			return self::COMPLEX($rPower * cos($theta), $rPower * sin($theta), $parsedComplex['suffix']);
 		}
 	}	//	function IMPOWER()
 
@@ -2048,9 +2048,9 @@ 
 	 * @param	string		$complexDivisor		The complex denominator or divisor.
 	 * @return	string
 	 */
-	public static function IMDIV($complexDividend,$complexDivisor) {
-		$complexDividend	= PHPExcel_Calculation_Functions::flattenSingleValue($complexDividend);
-		$complexDivisor	= PHPExcel_Calculation_Functions::flattenSingleValue($complexDivisor);
+	public static function IMDIV($complexDividend, $complexDivisor) {
+		$complexDividend = PHPExcel_Calculation_Functions::flattenSingleValue($complexDividend);
+		$complexDivisor = PHPExcel_Calculation_Functions::flattenSingleValue($complexDivisor);
 
 		$parsedComplexDividend = self::_parseComplex($complexDividend);
 		$parsedComplexDivisor = self::_parseComplex($complexDivisor);
@@ -2067,8 +2067,8 @@ 
 		$d2 = ($parsedComplexDividend['imaginary'] * $parsedComplexDivisor['real']) - ($parsedComplexDividend['real'] * $parsedComplexDivisor['imaginary']);
 		$d3 = ($parsedComplexDivisor['real'] * $parsedComplexDivisor['real']) + ($parsedComplexDivisor['imaginary'] * $parsedComplexDivisor['imaginary']);
 
-		$r = $d1/$d3;
-		$i = $d2/$d3;
+		$r = $d1 / $d3;
+		$i = $d2 / $d3;
 
 		if ($i > 0.0) {
 			return self::_cleanComplex($r.'+'.$i.$parsedComplexDivisor['suffix']);
@@ -2092,7 +2092,7 @@ 
 	 * @param	string		$complexNumber2		The complex number to subtract from complexNumber1.
 	 * @return	string
 	 */
-	public static function IMSUB($complexNumber1,$complexNumber2) {
+	public static function IMSUB($complexNumber1, $complexNumber2) {
 		$complexNumber1	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber1);
 		$complexNumber2	= PHPExcel_Calculation_Functions::flattenSingleValue($complexNumber2);
 
@@ -2109,7 +2109,7 @@ 
 		$d1 = $parsedComplex1['real'] - $parsedComplex2['real'];
 		$d2 = $parsedComplex1['imaginary'] - $parsedComplex2['imaginary'];
 
-		return self::COMPLEX($d1,$d2,$parsedComplex1['suffix']);
+		return self::COMPLEX($d1, $d2, $parsedComplex1['suffix']);
 	}	//	function IMSUB()
 
 
@@ -2145,7 +2145,7 @@ 
 		}
 
 		if ($returnValue['imaginary'] == 0.0) { $activeSuffix = ''; }
-		return self::COMPLEX($returnValue['real'],$returnValue['imaginary'],$activeSuffix);
+		return self::COMPLEX($returnValue['real'], $returnValue['imaginary'], $activeSuffix);
 	}	//	function IMSUM()
 
 
@@ -2181,7 +2181,7 @@ 
 		}
 
 		if ($returnValue['imaginary'] == 0.0) { $activeSuffix = ''; }
-		return self::COMPLEX($returnValue['real'],$returnValue['imaginary'],$activeSuffix);
+		return self::COMPLEX($returnValue['real'], $returnValue['imaginary'], $activeSuffix);
 	}	//	function IMPRODUCT()
 
 
@@ -2200,7 +2200,7 @@ 
 	 * @param	float		$b	The second number. If omitted, b is assumed to be zero.
 	 * @return	int
 	 */
-	public static function DELTA($a, $b=0) {
+	public static function DELTA($a, $b = 0) {
 		$a	= PHPExcel_Calculation_Functions::flattenSingleValue($a);
 		$b	= PHPExcel_Calculation_Functions::flattenSingleValue($b);
 
@@ -2223,9 +2223,9 @@ 
 	 *									If you omit a value for step, GESTEP uses zero.
 	 * @return	int
 	 */
-	public static function GESTEP($number, $step=0) {
-		$number	= PHPExcel_Calculation_Functions::flattenSingleValue($number);
-		$step	= PHPExcel_Calculation_Functions::flattenSingleValue($step);
+	public static function GESTEP($number, $step = 0) {
+		$number = PHPExcel_Calculation_Functions::flattenSingleValue($number);
+		$step = PHPExcel_Calculation_Functions::flattenSingleValue($step);
 
 		return (int) ($number >= $step);
 	}	//	function GESTEP()
@@ -2337,7 +2337,7 @@ 
 	 * @return	int
 	 */
 	public static function ERFC($x) {
-		$x	= PHPExcel_Calculation_Functions::flattenSingleValue($x);
+		$x = PHPExcel_Calculation_Functions::flattenSingleValue($x);
 
 		if (is_numeric($x)) {
 			if ($x < 0) {
@@ -2356,7 +2356,7 @@ 
 	 */
 	public static function getConversionGroups() {
 		$conversionGroups = array();
-		foreach(self::$_conversionUnits as $conversionUnit) {
+		foreach (self::$_conversionUnits as $conversionUnit) {
 			$conversionGroups[] = $conversionUnit['Group'];
 		}
 		return array_merge(array_unique($conversionGroups));
@@ -2370,7 +2370,7 @@ 
 	 */
 	public static function getConversionGroupUnits($group = NULL) {
 		$conversionGroups = array();
-		foreach(self::$_conversionUnits as $conversionUnit => $conversionGroup) {
+		foreach (self::$_conversionUnits as $conversionUnit => $conversionGroup) {
 			if ((is_null($group)) || ($conversionGroup['Group'] == $group)) {
 				$conversionGroups[$conversionGroup['Group']][] = $conversionUnit;
 			}
@@ -2386,9 +2386,9 @@ 
 	 */
 	public static function getConversionGroupUnitDetails($group = NULL) {
 		$conversionGroups = array();
-		foreach(self::$_conversionUnits as $conversionUnit => $conversionGroup) {
+		foreach (self::$_conversionUnits as $conversionUnit => $conversionGroup) {
 			if ((is_null($group)) || ($conversionGroup['Group'] == $group)) {
-				$conversionGroups[$conversionGroup['Group']][] = array(	'unit'			=> $conversionUnit,
+				$conversionGroups[$conversionGroup['Group']][] = array('unit'			=> $conversionUnit,
 																		'description'	=> $conversionGroup['Unit Name']
 																	  );
 			}
@@ -2424,18 +2424,18 @@ 
 	 */
 	public static function CONVERTUOM($value, $fromUOM, $toUOM) {
 		$value		= PHPExcel_Calculation_Functions::flattenSingleValue($value);
-		$fromUOM	= PHPExcel_Calculation_Functions::flattenSingleValue($fromUOM);
+		$fromUOM = PHPExcel_Calculation_Functions::flattenSingleValue($fromUOM);
 		$toUOM		= PHPExcel_Calculation_Functions::flattenSingleValue($toUOM);
 
-		if (!is_numeric($value)) {
+		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);
+			$fromMultiplier = substr($fromUOM, 0, 1);
+			$fromUOM = substr($fromUOM, 1);
 			if (isset(self::$_conversionMultipliers[$fromMultiplier])) {
 				$fromMultiplier = self::$_conversionMultipliers[$fromMultiplier]['multiplier'];
 			} else {
@@ -2453,8 +2453,8 @@ 
 		if (isset(self::$_conversionUnits[$toUOM])) {
 			$unitGroup2 = self::$_conversionUnits[$toUOM]['Group'];
 		} else {
-			$toMultiplier = substr($toUOM,0,1);
-			$toUOM = substr($toUOM,1);
+			$toMultiplier = substr($toUOM, 0, 1);
+			$toUOM = substr($toUOM, 1);
 			if (isset(self::$_conversionMultipliers[$toMultiplier])) {
 				$toMultiplier = self::$_conversionMultipliers[$toMultiplier]['multiplier'];
 			} else {

Braces +15 added lines, -5 removed lines

@@ -749,10 +749,18 @@ 
 	 * @return	string		The "cleaned" complex number
 	 */
 	private static function _cleanComplex($complexNumber) {
-		if ($complexNumber{0} == '+') $complexNumber = substr($complexNumber,1);
-		if ($complexNumber{0} == '0') $complexNumber = substr($complexNumber,1);
-		if ($complexNumber{0} == '.') $complexNumber = '0'.$complexNumber;
-		if ($complexNumber{0} == '+') $complexNumber = substr($complexNumber,1);
+		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;
 	}
 
@@ -1658,7 +1666,9 @@ 
 			$realNumber	= (float) $realNumber;
 			$imaginary	= (float) $imaginary;
 
-			if ($suffix == '') $suffix = 'i';
+			if ($suffix == '') {
+				$suffix = 'i';
+			}
 			if ($realNumber == 0.0) {
 				if ($imaginary == 0.0) {
 					return (string) '0';

app/Vendor/PHPExcel/PHPExcel/Calculation/Financial.php

Doc Comments +28 added lines, -17 removed lines

@@ -80,6 +80,10 @@ 
 	}	//	function _firstDayOfMonth()
 
 
+	/**
+	 * @param integer $frequency
+	 * @param boolean $next
+	 */
 	private static function _coupFirstPeriodDate($settlement, $maturity, $frequency, $next)
 	{
 		$months = 12 / $frequency;
@@ -102,6 +106,9 @@ 
 	}	//	function _coupFirstPeriodDate()
 
 
+	/**
+	 * @param integer $frequency
+	 */
 	private static function _validFrequency($frequency)
 	{
 		if (($frequency == 1) || ($frequency == 2) || ($frequency == 4)) {
@@ -179,7 +186,7 @@ 
 	 *									The security settlement date is the date after the issue date
 	 *									when the security is traded to the buyer.
 	 * @param	float	$rate			The security's annual coupon rate.
-	 * @param	float	$par			The security's par value.
+	 * @param	integer	$par			The security's par value.
 	 *									If you omit par, ACCRINT uses $1,000.
 	 * @param	integer	$frequency		the number of coupon payments per year.
 	 *									Valid frequency values are:
@@ -446,6 +453,7 @@ 
 	 *										2				Actual/360
 	 *										3				Actual/365
 	 *										4				European 30/360
+	 * @param integer $frequency
 	 * @return	float
 	 */
 	public static function COUPDAYBS($settlement, $maturity, $frequency, $basis=0) {
@@ -504,6 +512,7 @@ 
 	 *										2				Actual/360
 	 *										3				Actual/365
 	 *										4				European 30/360
+	 * @param integer $frequency
 	 * @return	float
 	 */
 	public static function COUPDAYS($settlement, $maturity, $frequency, $basis=0) {
@@ -574,6 +583,7 @@ 
 	 *										2				Actual/360
 	 *										3				Actual/365
 	 *										4				European 30/360
+	 * @param integer $frequency
 	 * @return	float
 	 */
 	public static function COUPDAYSNC($settlement, $maturity, $frequency, $basis=0) {
@@ -689,6 +699,7 @@ 
 	 *										2				Actual/360
 	 *										3				Actual/365
 	 *										4				European 30/360
+	 * @param integer $frequency
 	 * @return	integer
 	 */
 	public static function COUPNUM($settlement, $maturity, $frequency, $basis=0) {
@@ -1143,7 +1154,7 @@ 
 	 *
 	 * @access	public
 	 * @category Financial Functions
-	 * @param	float	$nominal_rate		Nominal interest rate
+	 * @param	integer	$nominal_rate		Nominal interest rate
 	 * @param	integer	$npery				Number of compounding payments per year
 	 * @return	float
 	 */
@@ -1170,12 +1181,12 @@ 
 	 *
 	 * @access	public
 	 * @category Financial Functions
-	 * @param	float	$rate	The interest rate per period
+	 * @param	integer	$rate	The interest rate per period
 	 * @param	int		$nper	Total number of payment periods in an annuity
-	 * @param	float	$pmt	The payment made each period: it cannot change over the
+	 * @param	integer	$pmt	The payment made each period: it cannot change over the
 	 *							life of the annuity. Typically, pmt contains principal
 	 *							and interest but no other fees or taxes.
-	 * @param	float	$pv		Present Value, or the lump-sum amount that a series of
+	 * @param	integer	$pv		Present Value, or the lump-sum amount that a series of
 	 *							future payments is worth right now.
 	 * @param	integer	$type	A number 0 or 1 and indicates when payments are due:
 	 *								0 or omitted	At the end of the period.
@@ -1277,7 +1288,7 @@ 
 	 * @param	int		$per	Period for which we want to find the interest
 	 * @param	int		$nper	Number of periods
 	 * @param	float	$pv		Present Value
-	 * @param	float	$fv		Future Value
+	 * @param	integer	$fv		Future Value
 	 * @param	int		$type	Payment type: 0 = at the end of each period, 1 = at the beginning of each period
 	 * @return	float
 	 */
@@ -1419,7 +1430,7 @@ 
 	 *
 	 * Returns the nominal interest rate given the effective rate and the number of compounding payments per year.
 	 *
-	 * @param	float	$effect_rate	Effective interest rate
+	 * @param	integer	$effect_rate	Effective interest rate
 	 * @param	int		$npery			Number of compounding payments per year
 	 * @return	float
 	 */
@@ -1442,10 +1453,10 @@ 
 	 *
 	 * Returns the number of periods for a cash flow with constant periodic payments (annuities), and interest rate.
 	 *
-	 * @param	float	$rate	Interest rate per period
+	 * @param	integer	$rate	Interest rate per period
 	 * @param	int		$pmt	Periodic payment (annuity)
-	 * @param	float	$pv		Present Value
-	 * @param	float	$fv		Future Value
+	 * @param	integer	$pv		Present Value
+	 * @param	integer	$fv		Future Value
 	 * @param	int		$type	Payment type: 0 = at the end of each period, 1 = at the beginning of each period
 	 * @return	float
 	 */
@@ -1511,10 +1522,10 @@ 
 	 *
 	 * Returns the constant payment (annuity) for a cash flow with a constant interest rate.
 	 *
-	 * @param	float	$rate	Interest rate per period
+	 * @param	integer	$rate	Interest rate per period
 	 * @param	int		$nper	Number of periods
-	 * @param	float	$pv		Present Value
-	 * @param	float	$fv		Future Value
+	 * @param	integer	$pv		Present Value
+	 * @param	integer	$fv		Future Value
 	 * @param	int		$type	Payment type: 0 = at the end of each period, 1 = at the beginning of each period
 	 * @return	float
 	 */
@@ -1548,7 +1559,7 @@ 
 	 * @param	int		$per	Period for which we want to find the interest
 	 * @param	int		$nper	Number of periods
 	 * @param	float	$pv		Present Value
-	 * @param	float	$fv		Future Value
+	 * @param	integer	$fv		Future Value
 	 * @param	int		$type	Payment type: 0 = at the end of each period, 1 = at the beginning of each period
 	 * @return	float
 	 */
@@ -1727,10 +1738,10 @@ 
 	 *
 	 * Returns the Present Value of a cash flow with constant payments and interest rate (annuities).
 	 *
-	 * @param	float	$rate	Interest rate per period
+	 * @param	integer	$rate	Interest rate per period
 	 * @param	int		$nper	Number of periods
-	 * @param	float	$pmt	Periodic payment (annuity)
-	 * @param	float	$fv		Future Value
+	 * @param	integer	$pmt	Periodic payment (annuity)
+	 * @param	integer	$fv		Future Value
 	 * @param	int		$type	Payment type: 0 = at the end of each period, 1 = at the beginning of each period
 	 * @return	float
 	 */

Spacing +194 added lines, -194 removed lines

@@ -27,12 +27,12 @@ 
 
 
 /** PHPExcel root directory */
-if (!defined('PHPEXCEL_ROOT')) {
+if ( ! defined('PHPEXCEL_ROOT')) {
 	/**
 	 * @ignore
 	 */
-	define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
-	require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	define('PHPEXCEL_ROOT', dirname(__FILE__).'/../../');
+	require(PHPEXCEL_ROOT.'PHPExcel/Autoloader.php');
 }
 
 
@@ -129,7 +129,7 @@ 
 	 *									4						European 360
 	 * @return	integer
 	 */
-	private static function _daysPerYear($year, $basis=0)
+	private static function _daysPerYear($year, $basis = 0)
 	{
 		switch ($basis) {
 			case 0 :
@@ -150,11 +150,11 @@ 
 	}	//	function _daysPerYear()
 
 
-	private static function _interestAndPrincipal($rate=0, $per=0, $nper=0, $pv=0, $fv=0, $type=0)
+	private static function _interestAndPrincipal($rate = 0, $per = 0, $nper = 0, $pv = 0, $fv = 0, $type = 0)
 	{
 		$pmt = self::PMT($rate, $nper, $pv, $fv, $type);
 		$capital = $pv;
-		for ($i = 1; $i<= $per; ++$i) {
+		for ($i = 1; $i <= $per; ++$i) {
 			$interest = ($type && $i == 1) ? 0 : -$capital * $rate;
 			$principal = $pmt - $interest;
 			$capital += $principal;
@@ -198,25 +198,25 @@ 
 	 *										4				European 30/360
 	 * @return	float
 	 */
-	public static function ACCRINT($issue, $firstinterest, $settlement, $rate, $par=1000, $frequency=1, $basis=0)
+	public static function ACCRINT($issue, $firstinterest, $settlement, $rate, $par = 1000, $frequency = 1, $basis = 0)
 	{
-		$issue		= PHPExcel_Calculation_Functions::flattenSingleValue($issue);
-		$firstinterest	= PHPExcel_Calculation_Functions::flattenSingleValue($firstinterest);
-		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
-		$rate		= PHPExcel_Calculation_Functions::flattenSingleValue($rate);
-		$par		= (is_null($par))		? 1000 :	PHPExcel_Calculation_Functions::flattenSingleValue($par);
-		$frequency	= (is_null($frequency))	? 1	: 		PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
-		$basis		= (is_null($basis))		? 0	:		PHPExcel_Calculation_Functions::flattenSingleValue($basis);
+		$issue = PHPExcel_Calculation_Functions::flattenSingleValue($issue);
+		$firstinterest = PHPExcel_Calculation_Functions::flattenSingleValue($firstinterest);
+		$settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
+		$rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
+		$par = (is_null($par)) ? 1000 : PHPExcel_Calculation_Functions::flattenSingleValue($par);
+		$frequency = (is_null($frequency)) ? 1 : PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
+		$basis = (is_null($basis)) ? 0 : PHPExcel_Calculation_Functions::flattenSingleValue($basis);
 
 		//	Validate
 		if ((is_numeric($rate)) && (is_numeric($par))) {
-			$rate	= (float) $rate;
-			$par	= (float) $par;
+			$rate = (float) $rate;
+			$par = (float) $par;
 			if (($rate <= 0) || ($par <= 0)) {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
 			$daysBetweenIssueAndSettlement = PHPExcel_Calculation_DateTime::YEARFRAC($issue, $settlement, $basis);
-			if (!is_numeric($daysBetweenIssueAndSettlement)) {
+			if ( ! is_numeric($daysBetweenIssueAndSettlement)) {
 				//	return date error
 				return $daysBetweenIssueAndSettlement;
 			}
@@ -250,22 +250,22 @@ 
 	 *										4				European 30/360
 	 * @return	float
 	 */
-	public static function ACCRINTM($issue, $settlement, $rate, $par=1000, $basis=0) {
-		$issue		= PHPExcel_Calculation_Functions::flattenSingleValue($issue);
-		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
-		$rate		= PHPExcel_Calculation_Functions::flattenSingleValue($rate);
-		$par		= (is_null($par))	? 1000 :	PHPExcel_Calculation_Functions::flattenSingleValue($par);
-		$basis		= (is_null($basis))	? 0 :		PHPExcel_Calculation_Functions::flattenSingleValue($basis);
+	public static function ACCRINTM($issue, $settlement, $rate, $par = 1000, $basis = 0) {
+		$issue = PHPExcel_Calculation_Functions::flattenSingleValue($issue);
+		$settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
+		$rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
+		$par = (is_null($par)) ? 1000 : PHPExcel_Calculation_Functions::flattenSingleValue($par);
+		$basis = (is_null($basis)) ? 0 : PHPExcel_Calculation_Functions::flattenSingleValue($basis);
 
 		//	Validate
 		if ((is_numeric($rate)) && (is_numeric($par))) {
-			$rate	= (float) $rate;
-			$par	= (float) $par;
+			$rate = (float) $rate;
+			$par = (float) $par;
 			if (($rate <= 0) || ($par <= 0)) {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
 			$daysBetweenIssueAndSettlement = PHPExcel_Calculation_DateTime::YEARFRAC($issue, $settlement, $basis);
-			if (!is_numeric($daysBetweenIssueAndSettlement)) {
+			if ( ! is_numeric($daysBetweenIssueAndSettlement)) {
 				//	return date error
 				return $daysBetweenIssueAndSettlement;
 			}
@@ -306,14 +306,14 @@ 
 	 *										4				European 30/360
 	 * @return	float
 	 */
-	public static function AMORDEGRC($cost, $purchased, $firstPeriod, $salvage, $period, $rate, $basis=0) {
-		$cost			= PHPExcel_Calculation_Functions::flattenSingleValue($cost);
-		$purchased		= PHPExcel_Calculation_Functions::flattenSingleValue($purchased);
-		$firstPeriod	= PHPExcel_Calculation_Functions::flattenSingleValue($firstPeriod);
+	public static function AMORDEGRC($cost, $purchased, $firstPeriod, $salvage, $period, $rate, $basis = 0) {
+		$cost = PHPExcel_Calculation_Functions::flattenSingleValue($cost);
+		$purchased = PHPExcel_Calculation_Functions::flattenSingleValue($purchased);
+		$firstPeriod = PHPExcel_Calculation_Functions::flattenSingleValue($firstPeriod);
 		$salvage		= PHPExcel_Calculation_Functions::flattenSingleValue($salvage);
 		$period			= floor(PHPExcel_Calculation_Functions::flattenSingleValue($period));
-		$rate			= PHPExcel_Calculation_Functions::flattenSingleValue($rate);
-		$basis			= (is_null($basis))	? 0 :	(int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
+		$rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
+		$basis = (is_null($basis)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
 
 		//	The depreciation coefficients are:
 		//	Life of assets (1/rate)		Depreciation coefficient
@@ -333,12 +333,12 @@ 
 		}
 
 		$rate *= $amortiseCoeff;
-		$fNRate = round(PHPExcel_Calculation_DateTime::YEARFRAC($purchased, $firstPeriod, $basis) * $rate * $cost,0);
+		$fNRate = round(PHPExcel_Calculation_DateTime::YEARFRAC($purchased, $firstPeriod, $basis) * $rate * $cost, 0);
 		$cost -= $fNRate;
 		$fRest = $cost - $salvage;
 
 		for ($n = 0; $n < $period; ++$n) {
-			$fNRate = round($rate * $cost,0);
+			$fNRate = round($rate * $cost, 0);
 			$fRest -= $fNRate;
 
 			if ($fRest < 0.0) {
@@ -382,14 +382,14 @@ 
 	 *										4				European 30/360
 	 * @return	float
 	 */
-	public static function AMORLINC($cost, $purchased, $firstPeriod, $salvage, $period, $rate, $basis=0) {
-		$cost			= PHPExcel_Calculation_Functions::flattenSingleValue($cost);
-		$purchased		= PHPExcel_Calculation_Functions::flattenSingleValue($purchased);
-		$firstPeriod	= PHPExcel_Calculation_Functions::flattenSingleValue($firstPeriod);
+	public static function AMORLINC($cost, $purchased, $firstPeriod, $salvage, $period, $rate, $basis = 0) {
+		$cost = PHPExcel_Calculation_Functions::flattenSingleValue($cost);
+		$purchased = PHPExcel_Calculation_Functions::flattenSingleValue($purchased);
+		$firstPeriod = PHPExcel_Calculation_Functions::flattenSingleValue($firstPeriod);
 		$salvage		= PHPExcel_Calculation_Functions::flattenSingleValue($salvage);
 		$period			= PHPExcel_Calculation_Functions::flattenSingleValue($period);
-		$rate			= PHPExcel_Calculation_Functions::flattenSingleValue($rate);
-		$basis			= (is_null($basis))	? 0 :	(int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
+		$rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
+		$basis = (is_null($basis)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
 
 		$fOneRate = $cost * $rate;
 		$fCostDelta = $cost - $salvage;
@@ -448,11 +448,11 @@ 
 	 *										4				European 30/360
 	 * @return	float
 	 */
-	public static function COUPDAYBS($settlement, $maturity, $frequency, $basis=0) {
-		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
-		$maturity	= PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
-		$frequency	= (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
-		$basis		= (is_null($basis))	? 0 :	(int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
+	public static function COUPDAYBS($settlement, $maturity, $frequency, $basis = 0) {
+		$settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
+		$maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
+		$frequency = (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
+		$basis = (is_null($basis)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
 
 		if (is_string($settlement = PHPExcel_Calculation_DateTime::_getDateValue($settlement))) {
 			return PHPExcel_Calculation_Functions::VALUE();
@@ -462,12 +462,12 @@ 
 		}
 
 		if (($settlement > $maturity) ||
-			(!self::_validFrequency($frequency)) ||
+			( ! self::_validFrequency($frequency)) ||
 			(($basis < 0) || ($basis > 4))) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
 
-		$daysPerYear = self::_daysPerYear(PHPExcel_Calculation_DateTime::YEAR($settlement),$basis);
+		$daysPerYear = self::_daysPerYear(PHPExcel_Calculation_DateTime::YEAR($settlement), $basis);
 		$prev = self::_coupFirstPeriodDate($settlement, $maturity, $frequency, False);
 
 		return PHPExcel_Calculation_DateTime::YEARFRAC($prev, $settlement, $basis) * $daysPerYear;
@@ -506,11 +506,11 @@ 
 	 *										4				European 30/360
 	 * @return	float
 	 */
-	public static function COUPDAYS($settlement, $maturity, $frequency, $basis=0) {
-		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
-		$maturity	= PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
-		$frequency	= (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
-		$basis		= (is_null($basis))	? 0 :	(int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
+	public static function COUPDAYS($settlement, $maturity, $frequency, $basis = 0) {
+		$settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
+		$maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
+		$frequency = (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
+		$basis = (is_null($basis)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
 
 		if (is_string($settlement = PHPExcel_Calculation_DateTime::_getDateValue($settlement))) {
 			return PHPExcel_Calculation_Functions::VALUE();
@@ -520,7 +520,7 @@ 
 		}
 
 		if (($settlement > $maturity) ||
-			(!self::_validFrequency($frequency)) ||
+			( ! self::_validFrequency($frequency)) ||
 			(($basis < 0) || ($basis > 4))) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
@@ -530,7 +530,7 @@ 
 					return 365 / $frequency;
 			case 1: // Actual/actual
 					if ($frequency == 1) {
-						$daysPerYear = self::_daysPerYear(PHPExcel_Calculation_DateTime::YEAR($maturity),$basis);
+						$daysPerYear = self::_daysPerYear(PHPExcel_Calculation_DateTime::YEAR($maturity), $basis);
 						return ($daysPerYear / $frequency);
 					} else {
 						$prev = self::_coupFirstPeriodDate($settlement, $maturity, $frequency, False);
@@ -576,11 +576,11 @@ 
 	 *										4				European 30/360
 	 * @return	float
 	 */
-	public static function COUPDAYSNC($settlement, $maturity, $frequency, $basis=0) {
-		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
-		$maturity	= PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
-		$frequency	= (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
-		$basis		= (is_null($basis))	? 0 :	(int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
+	public static function COUPDAYSNC($settlement, $maturity, $frequency, $basis = 0) {
+		$settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
+		$maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
+		$frequency = (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
+		$basis = (is_null($basis)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
 
 		if (is_string($settlement = PHPExcel_Calculation_DateTime::_getDateValue($settlement))) {
 			return PHPExcel_Calculation_Functions::VALUE();
@@ -590,12 +590,12 @@ 
 		}
 
 		if (($settlement > $maturity) ||
-			(!self::_validFrequency($frequency)) ||
+			( ! self::_validFrequency($frequency)) ||
 			(($basis < 0) || ($basis > 4))) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
 
-		$daysPerYear = self::_daysPerYear(PHPExcel_Calculation_DateTime::YEAR($settlement),$basis);
+		$daysPerYear = self::_daysPerYear(PHPExcel_Calculation_DateTime::YEAR($settlement), $basis);
 		$next = self::_coupFirstPeriodDate($settlement, $maturity, $frequency, True);
 
 		return PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $next, $basis) * $daysPerYear;
@@ -635,11 +635,11 @@ 
 	 * @return	mixed	Excel date/time serial value, PHP date/time serial value or PHP date/time object,
 	 *						depending on the value of the ReturnDateType flag
 	 */
-	public static function COUPNCD($settlement, $maturity, $frequency, $basis=0) {
-		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
-		$maturity	= PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
-		$frequency	= (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
-		$basis		= (is_null($basis))	? 0 :	(int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
+	public static function COUPNCD($settlement, $maturity, $frequency, $basis = 0) {
+		$settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
+		$maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
+		$frequency = (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
+		$basis = (is_null($basis)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
 
 		if (is_string($settlement = PHPExcel_Calculation_DateTime::_getDateValue($settlement))) {
 			return PHPExcel_Calculation_Functions::VALUE();
@@ -649,7 +649,7 @@ 
 		}
 
 		if (($settlement > $maturity) ||
-			(!self::_validFrequency($frequency)) ||
+			( ! self::_validFrequency($frequency)) ||
 			(($basis < 0) || ($basis > 4))) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
@@ -691,11 +691,11 @@ 
 	 *										4				European 30/360
 	 * @return	integer
 	 */
-	public static function COUPNUM($settlement, $maturity, $frequency, $basis=0) {
-		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
-		$maturity	= PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
-		$frequency	= (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
-		$basis		= (is_null($basis))	? 0 :	(int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
+	public static function COUPNUM($settlement, $maturity, $frequency, $basis = 0) {
+		$settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
+		$maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
+		$frequency = (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
+		$basis = (is_null($basis)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
 
 		if (is_string($settlement = PHPExcel_Calculation_DateTime::_getDateValue($settlement))) {
 			return PHPExcel_Calculation_Functions::VALUE();
@@ -705,7 +705,7 @@ 
 		}
 
 		if (($settlement > $maturity) ||
-			(!self::_validFrequency($frequency)) ||
+			( ! self::_validFrequency($frequency)) ||
 			(($basis < 0) || ($basis > 4))) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
@@ -762,11 +762,11 @@ 
 	 * @return	mixed	Excel date/time serial value, PHP date/time serial value or PHP date/time object,
 	 *						depending on the value of the ReturnDateType flag
 	 */
-	public static function COUPPCD($settlement, $maturity, $frequency, $basis=0) {
-		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
-		$maturity	= PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
-		$frequency	= (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
-		$basis		= (is_null($basis))	? 0 :	(int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
+	public static function COUPPCD($settlement, $maturity, $frequency, $basis = 0) {
+		$settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
+		$maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
+		$frequency = (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
+		$basis = (is_null($basis)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
 
 		if (is_string($settlement = PHPExcel_Calculation_DateTime::_getDateValue($settlement))) {
 			return PHPExcel_Calculation_Functions::VALUE();
@@ -776,7 +776,7 @@ 
 		}
 
 		if (($settlement > $maturity) ||
-			(!self::_validFrequency($frequency)) ||
+			( ! self::_validFrequency($frequency)) ||
 			(($basis < 0) || ($basis > 4))) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
@@ -810,9 +810,9 @@ 
 		$rate	= PHPExcel_Calculation_Functions::flattenSingleValue($rate);
 		$nper	= (int) PHPExcel_Calculation_Functions::flattenSingleValue($nper);
 		$pv		= PHPExcel_Calculation_Functions::flattenSingleValue($pv);
-		$start	= (int) PHPExcel_Calculation_Functions::flattenSingleValue($start);
+		$start = (int) PHPExcel_Calculation_Functions::flattenSingleValue($start);
 		$end	= (int) PHPExcel_Calculation_Functions::flattenSingleValue($end);
-		$type	= (int) PHPExcel_Calculation_Functions::flattenSingleValue($type);
+		$type = (int) PHPExcel_Calculation_Functions::flattenSingleValue($type);
 
 		// Validate parameters
 		if ($type != 0 && $type != 1) {
@@ -857,9 +857,9 @@ 
 		$rate	= PHPExcel_Calculation_Functions::flattenSingleValue($rate);
 		$nper	= (int) PHPExcel_Calculation_Functions::flattenSingleValue($nper);
 		$pv		= PHPExcel_Calculation_Functions::flattenSingleValue($pv);
-		$start	= (int) PHPExcel_Calculation_Functions::flattenSingleValue($start);
+		$start = (int) PHPExcel_Calculation_Functions::flattenSingleValue($start);
 		$end	= (int) PHPExcel_Calculation_Functions::flattenSingleValue($end);
-		$type	= (int) PHPExcel_Calculation_Functions::flattenSingleValue($type);
+		$type = (int) PHPExcel_Calculation_Functions::flattenSingleValue($type);
 
 		// Validate parameters
 		if ($type != 0 && $type != 1) {
@@ -905,12 +905,12 @@ 
 	 *								it defaults to 12.
 	 * @return	float
 	 */
-	public static function DB($cost, $salvage, $life, $period, $month=12) {
+	public static function DB($cost, $salvage, $life, $period, $month = 12) {
 		$cost		= PHPExcel_Calculation_Functions::flattenSingleValue($cost);
 		$salvage	= PHPExcel_Calculation_Functions::flattenSingleValue($salvage);
 		$life		= PHPExcel_Calculation_Functions::flattenSingleValue($life);
 		$period		= PHPExcel_Calculation_Functions::flattenSingleValue($period);
-		$month		= PHPExcel_Calculation_Functions::flattenSingleValue($month);
+		$month = PHPExcel_Calculation_Functions::flattenSingleValue($month);
 
 		//	Validate
 		if ((is_numeric($cost)) && (is_numeric($salvage)) && (is_numeric($life)) && (is_numeric($period)) && (is_numeric($month))) {
@@ -918,7 +918,7 @@ 
 			$salvage	= (float) $salvage;
 			$life		= (int) $life;
 			$period		= (int) $period;
-			$month		= (int) $month;
+			$month = (int) $month;
 			if ($cost == 0) {
 				return 0.0;
 			} elseif (($cost < 0) || (($salvage / $cost) < 0) || ($life <= 0) || ($period < 1) || ($month < 1)) {
@@ -941,7 +941,7 @@ 
 				$previousDepreciation += $depreciation;
 			}
 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
-				$depreciation = round($depreciation,2);
+				$depreciation = round($depreciation, 2);
 			}
 			return $depreciation;
 		}
@@ -972,7 +972,7 @@ 
 	 *								double-declining balance method).
 	 * @return	float
 	 */
-	public static function DDB($cost, $salvage, $life, $period, $factor=2.0) {
+	public static function DDB($cost, $salvage, $life, $period, $factor = 2.0) {
 		$cost		= PHPExcel_Calculation_Functions::flattenSingleValue($cost);
 		$salvage	= PHPExcel_Calculation_Functions::flattenSingleValue($salvage);
 		$life		= PHPExcel_Calculation_Functions::flattenSingleValue($life);
@@ -996,11 +996,11 @@ 
 			//	Loop through each period calculating the depreciation
 			$previousDepreciation = 0;
 			for ($per = 1; $per <= $period; ++$per) {
-				$depreciation = min( ($cost - $previousDepreciation) * ($factor / $life), ($cost - $salvage - $previousDepreciation) );
+				$depreciation = min(($cost - $previousDepreciation) * ($factor / $life), ($cost - $salvage - $previousDepreciation));
 				$previousDepreciation += $depreciation;
 			}
 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
-				$depreciation = round($depreciation,2);
+				$depreciation = round($depreciation, 2);
 			}
 			return $depreciation;
 		}
@@ -1033,9 +1033,9 @@ 
 	 *										4				European 30/360
 	 * @return	float
 	 */
-	public static function DISC($settlement, $maturity, $price, $redemption, $basis=0) {
+	public static function DISC($settlement, $maturity, $price, $redemption, $basis = 0) {
 		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
-		$maturity	= PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
+		$maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
 		$price		= PHPExcel_Calculation_Functions::flattenSingleValue($price);
 		$redemption	= PHPExcel_Calculation_Functions::flattenSingleValue($redemption);
 		$basis		= PHPExcel_Calculation_Functions::flattenSingleValue($basis);
@@ -1043,13 +1043,13 @@ 
 		//	Validate
 		if ((is_numeric($price)) && (is_numeric($redemption)) && (is_numeric($basis))) {
 			$price		= (float) $price;
-			$redemption	= (float) $redemption;
+			$redemption = (float) $redemption;
 			$basis		= (int) $basis;
 			if (($price <= 0) || ($redemption <= 0)) {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
 			$daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity, $basis);
-			if (!is_numeric($daysBetweenSettlementAndMaturity)) {
+			if ( ! is_numeric($daysBetweenSettlementAndMaturity)) {
 				//	return date error
 				return $daysBetweenSettlementAndMaturity;
 			}
@@ -1077,8 +1077,8 @@ 
 	 * @return	float
 	 */
 	public static function DOLLARDE($fractional_dollar = Null, $fraction = 0) {
-		$fractional_dollar	= PHPExcel_Calculation_Functions::flattenSingleValue($fractional_dollar);
-		$fraction			= (int)PHPExcel_Calculation_Functions::flattenSingleValue($fraction);
+		$fractional_dollar = PHPExcel_Calculation_Functions::flattenSingleValue($fractional_dollar);
+		$fraction = (int) PHPExcel_Calculation_Functions::flattenSingleValue($fraction);
 
 		// Validate parameters
 		if (is_null($fractional_dollar) || $fraction < 0) {
@@ -1089,9 +1089,9 @@ 
 		}
 
 		$dollars = floor($fractional_dollar);
-		$cents = fmod($fractional_dollar,1);
+		$cents = fmod($fractional_dollar, 1);
 		$cents /= $fraction;
-		$cents *= pow(10,ceil(log10($fraction)));
+		$cents *= pow(10, ceil(log10($fraction)));
 		return $dollars + $cents;
 	}	//	function DOLLARDE()
 
@@ -1113,8 +1113,8 @@ 
 	 * @return	float
 	 */
 	public static function DOLLARFR($decimal_dollar = Null, $fraction = 0) {
-		$decimal_dollar	= PHPExcel_Calculation_Functions::flattenSingleValue($decimal_dollar);
-		$fraction		= (int)PHPExcel_Calculation_Functions::flattenSingleValue($fraction);
+		$decimal_dollar = PHPExcel_Calculation_Functions::flattenSingleValue($decimal_dollar);
+		$fraction = (int) PHPExcel_Calculation_Functions::flattenSingleValue($fraction);
 
 		// Validate parameters
 		if (is_null($decimal_dollar) || $fraction < 0) {
@@ -1125,9 +1125,9 @@ 
 		}
 
 		$dollars = floor($decimal_dollar);
-		$cents = fmod($decimal_dollar,1);
+		$cents = fmod($decimal_dollar, 1);
 		$cents *= $fraction;
-		$cents *= pow(10,-ceil(log10($fraction)));
+		$cents *= pow(10, -ceil(log10($fraction)));
 		return $dollars + $cents;
 	}	//	function DOLLARFR()
 
@@ -1148,8 +1148,8 @@ 
 	 * @return	float
 	 */
 	public static function EFFECT($nominal_rate = 0, $npery = 0) {
-		$nominal_rate	= PHPExcel_Calculation_Functions::flattenSingleValue($nominal_rate);
-		$npery			= (int)PHPExcel_Calculation_Functions::flattenSingleValue($npery);
+		$nominal_rate = PHPExcel_Calculation_Functions::flattenSingleValue($nominal_rate);
+		$npery = (int) PHPExcel_Calculation_Functions::flattenSingleValue($npery);
 
 		// Validate parameters
 		if ($nominal_rate <= 0 || $npery < 1) {
@@ -1195,7 +1195,7 @@ 
 		}
 
 		// Calculate
-		if (!is_null($rate) && $rate != 0) {
+		if ( ! is_null($rate) && $rate != 0) {
 			return -$pv * pow(1 + $rate, $nper) - $pmt * (1 + $rate * $type) * (pow(1 + $rate, $nper) - 1) / $rate;
 		} else {
 			return -$pv - $pmt * $nper;
@@ -1208,10 +1208,10 @@ 
 	 *
 	 */
 	public static function FVSCHEDULE($principal, $schedule) {
-		$principal	= PHPExcel_Calculation_Functions::flattenSingleValue($principal);
-		$schedule	= PHPExcel_Calculation_Functions::flattenArray($schedule);
+		$principal = PHPExcel_Calculation_Functions::flattenSingleValue($principal);
+		$schedule = PHPExcel_Calculation_Functions::flattenArray($schedule);
 
-		foreach($schedule as $n) {
+		foreach ($schedule as $n) {
 			$principal *= 1 + $n;
 		}
 
@@ -1241,23 +1241,23 @@ 
 	 *										4				European 30/360
 	 * @return	float
 	 */
-	public static function INTRATE($settlement, $maturity, $investment, $redemption, $basis=0) {
+	public static function INTRATE($settlement, $maturity, $investment, $redemption, $basis = 0) {
 		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
-		$maturity	= PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
+		$maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
 		$investment	= PHPExcel_Calculation_Functions::flattenSingleValue($investment);
 		$redemption	= PHPExcel_Calculation_Functions::flattenSingleValue($redemption);
-		$basis		= PHPExcel_Calculation_Functions::flattenSingleValue($basis);
+		$basis = PHPExcel_Calculation_Functions::flattenSingleValue($basis);
 
 		//	Validate
 		if ((is_numeric($investment)) && (is_numeric($redemption)) && (is_numeric($basis))) {
 			$investment	= (float) $investment;
 			$redemption	= (float) $redemption;
-			$basis		= (int) $basis;
+			$basis = (int) $basis;
 			if (($investment <= 0) || ($redemption <= 0)) {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
 			$daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity, $basis);
-			if (!is_numeric($daysBetweenSettlementAndMaturity)) {
+			if ( ! is_numeric($daysBetweenSettlementAndMaturity)) {
 				//	return date error
 				return $daysBetweenSettlementAndMaturity;
 			}
@@ -1304,7 +1304,7 @@ 
 
 
 	public static function IRR($values, $guess = 0.1) {
-		if (!is_array($values)) return PHPExcel_Calculation_Functions::VALUE();
+		if ( ! is_array($values)) return PHPExcel_Calculation_Functions::VALUE();
 		$values = PHPExcel_Calculation_Functions::flattenArray($values);
 		$guess = PHPExcel_Calculation_Functions::flattenSingleValue($guess);
 
@@ -1332,7 +1332,7 @@ 
 			$dx = $x1 - $x2;
 		}
 
-		for ($i = 0;  $i < FINANCIAL_MAX_ITERATIONS; ++$i) {
+		for ($i = 0; $i < FINANCIAL_MAX_ITERATIONS; ++$i) {
 			$dx *= 0.5;
 			$x_mid = $rtb + $dx;
 			$f_mid = self::NPV($x_mid, $values);
@@ -1372,11 +1372,11 @@ 
 
 		// Calculate
 		$principlePayment = ($principleRemaining * 1.0) / ($numberPeriods * 1.0);
-		for($i=0; $i <= $period; ++$i) {
+		for ($i = 0; $i <= $period; ++$i) {
 			$returnValue = $interestRate * $principleRemaining * -1;
 			$principleRemaining -= $principlePayment;
 			// principle needs to be 0 after the last payment, don't let floating point screw it up
-			if($i == $numberPeriods) {
+			if ($i == $numberPeriods) {
 				$returnValue = 0;
 			}
 		}
@@ -1385,17 +1385,17 @@ 
 
 
 	public static function MIRR($values, $finance_rate, $reinvestment_rate) {
-		if (!is_array($values)) return PHPExcel_Calculation_Functions::VALUE();
-		$values				= PHPExcel_Calculation_Functions::flattenArray($values);
-		$finance_rate		= PHPExcel_Calculation_Functions::flattenSingleValue($finance_rate);
-		$reinvestment_rate	= PHPExcel_Calculation_Functions::flattenSingleValue($reinvestment_rate);
+		if ( ! is_array($values)) return PHPExcel_Calculation_Functions::VALUE();
+		$values = PHPExcel_Calculation_Functions::flattenArray($values);
+		$finance_rate = PHPExcel_Calculation_Functions::flattenSingleValue($finance_rate);
+		$reinvestment_rate = PHPExcel_Calculation_Functions::flattenSingleValue($reinvestment_rate);
 		$n = count($values);
 
 		$rr = 1.0 + $reinvestment_rate;
 		$fr = 1.0 + $finance_rate;
 
 		$npv_pos = $npv_neg = 0.0;
-		foreach($values as $i => $v) {
+		foreach ($values as $i => $v) {
 			if ($v >= 0) {
 				$npv_pos += $v / pow($rr, $i);
 			} else {
@@ -1424,8 +1424,8 @@ 
 	 * @return	float
 	 */
 	public static function NOMINAL($effect_rate = 0, $npery = 0) {
-		$effect_rate	= PHPExcel_Calculation_Functions::flattenSingleValue($effect_rate);
-		$npery			= (int)PHPExcel_Calculation_Functions::flattenSingleValue($npery);
+		$effect_rate = PHPExcel_Calculation_Functions::flattenSingleValue($effect_rate);
+		$npery = (int) PHPExcel_Calculation_Functions::flattenSingleValue($npery);
 
 		// Validate parameters
 		if ($effect_rate <= 0 || $npery < 1) {
@@ -1450,11 +1450,11 @@ 
 	 * @return	float
 	 */
 	public static function NPER($rate = 0, $pmt = 0, $pv = 0, $fv = 0, $type = 0) {
-		$rate	= PHPExcel_Calculation_Functions::flattenSingleValue($rate);
+		$rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
 		$pmt	= PHPExcel_Calculation_Functions::flattenSingleValue($pmt);
 		$pv		= PHPExcel_Calculation_Functions::flattenSingleValue($pv);
 		$fv		= PHPExcel_Calculation_Functions::flattenSingleValue($fv);
-		$type	= PHPExcel_Calculation_Functions::flattenSingleValue($type);
+		$type = PHPExcel_Calculation_Functions::flattenSingleValue($type);
 
 		// Validate parameters
 		if ($type != 0 && $type != 1) {
@@ -1462,7 +1462,7 @@ 
 		}
 
 		// Calculate
-		if (!is_null($rate) && $rate != 0) {
+		if ( ! is_null($rate) && $rate != 0) {
 			if ($pmt == 0 && $pv == 0) {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
@@ -1471,7 +1471,7 @@ 
 			if ($pmt == 0) {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
-			return (-$pv -$fv) / $pmt;
+			return (-$pv - $fv) / $pmt;
 		}
 	}	//	function NPER()
 
@@ -1531,7 +1531,7 @@ 
 		}
 
 		// Calculate
-		if (!is_null($rate) && $rate != 0) {
+		if ( ! is_null($rate) && $rate != 0) {
 			return (-$fv - $pv * pow(1 + $rate, $nper)) / (1 + $rate * $type) / ((pow(1 + $rate, $nper) - 1) / $rate);
 		} else {
 			return (-$pv - $fv) / $nper;
@@ -1574,14 +1574,14 @@ 
 	}	//	function PPMT()
 
 
-	public static function PRICE($settlement, $maturity, $rate, $yield, $redemption, $frequency, $basis=0) {
-		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
-		$maturity	= PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
-		$rate		= (float) PHPExcel_Calculation_Functions::flattenSingleValue($rate);
+	public static function PRICE($settlement, $maturity, $rate, $yield, $redemption, $frequency, $basis = 0) {
+		$settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
+		$maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
+		$rate = (float) PHPExcel_Calculation_Functions::flattenSingleValue($rate);
 		$yield		= (float) PHPExcel_Calculation_Functions::flattenSingleValue($yield);
-		$redemption	= (float) PHPExcel_Calculation_Functions::flattenSingleValue($redemption);
-		$frequency	= (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
-		$basis		= (is_null($basis))	? 0 :	(int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
+		$redemption = (float) PHPExcel_Calculation_Functions::flattenSingleValue($redemption);
+		$frequency = (int) PHPExcel_Calculation_Functions::flattenSingleValue($frequency);
+		$basis		= (is_null($basis)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
 
 		if (is_string($settlement = PHPExcel_Calculation_DateTime::_getDateValue($settlement))) {
 			return PHPExcel_Calculation_Functions::VALUE();
@@ -1591,7 +1591,7 @@ 
 		}
 
 		if (($settlement > $maturity) ||
-			(!self::_validFrequency($frequency)) ||
+			( ! self::_validFrequency($frequency)) ||
 			(($basis < 0) || ($basis > 4))) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
@@ -1601,12 +1601,12 @@ 
 		$n = self::COUPNUM($settlement, $maturity, $frequency, $basis);
 		$a = self::COUPDAYBS($settlement, $maturity, $frequency, $basis);
 
-		$baseYF	= 1.0 + ($yield / $frequency);
-		$rfp	= 100 * ($rate / $frequency);
-		$de	= $dsc / $e;
+		$baseYF = 1.0 + ($yield / $frequency);
+		$rfp = 100 * ($rate / $frequency);
+		$de = $dsc / $e;
 
 		$result = $redemption / pow($baseYF, (--$n + $de));
-		for($k = 0; $k <= $n; ++$k) {
+		for ($k = 0; $k <= $n; ++$k) {
 			$result += $rfp / (pow($baseYF, ($k + $de)));
 		}
 		$result -= $rfp * ($a / $e);
@@ -1634,12 +1634,12 @@ 
 	 *										4				European 30/360
 	 * @return	float
 	 */
-	public static function PRICEDISC($settlement, $maturity, $discount, $redemption, $basis=0) {
+	public static function PRICEDISC($settlement, $maturity, $discount, $redemption, $basis = 0) {
 		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
 		$maturity	= PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
 		$discount	= (float) PHPExcel_Calculation_Functions::flattenSingleValue($discount);
 		$redemption	= (float) PHPExcel_Calculation_Functions::flattenSingleValue($redemption);
-		$basis		= (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
+		$basis = (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
 
 		//	Validate
 		if ((is_numeric($discount)) && (is_numeric($redemption)) && (is_numeric($basis))) {
@@ -1647,7 +1647,7 @@ 
 				return PHPExcel_Calculation_Functions::NaN();
 			}
 			$daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity, $basis);
-			if (!is_numeric($daysBetweenSettlementAndMaturity)) {
+			if ( ! is_numeric($daysBetweenSettlementAndMaturity)) {
 				//	return date error
 				return $daysBetweenSettlementAndMaturity;
 			}
@@ -1678,11 +1678,11 @@ 
 	 *										4				European 30/360
 	 * @return	float
 	 */
-	public static function PRICEMAT($settlement, $maturity, $issue, $rate, $yield, $basis=0) {
-		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
-		$maturity	= PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
+	public static function PRICEMAT($settlement, $maturity, $issue, $rate, $yield, $basis = 0) {
+		$settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
+		$maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
 		$issue		= PHPExcel_Calculation_Functions::flattenSingleValue($issue);
-		$rate		= PHPExcel_Calculation_Functions::flattenSingleValue($rate);
+		$rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
 		$yield		= PHPExcel_Calculation_Functions::flattenSingleValue($yield);
 		$basis		= (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
 
@@ -1691,24 +1691,24 @@ 
 			if (($rate <= 0) || ($yield <= 0)) {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
-			$daysPerYear = self::_daysPerYear(PHPExcel_Calculation_DateTime::YEAR($settlement),$basis);
-			if (!is_numeric($daysPerYear)) {
+			$daysPerYear = self::_daysPerYear(PHPExcel_Calculation_DateTime::YEAR($settlement), $basis);
+			if ( ! is_numeric($daysPerYear)) {
 				return $daysPerYear;
 			}
 			$daysBetweenIssueAndSettlement = PHPExcel_Calculation_DateTime::YEARFRAC($issue, $settlement, $basis);
-			if (!is_numeric($daysBetweenIssueAndSettlement)) {
+			if ( ! is_numeric($daysBetweenIssueAndSettlement)) {
 				//	return date error
 				return $daysBetweenIssueAndSettlement;
 			}
 			$daysBetweenIssueAndSettlement *= $daysPerYear;
 			$daysBetweenIssueAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($issue, $maturity, $basis);
-			if (!is_numeric($daysBetweenIssueAndMaturity)) {
+			if ( ! is_numeric($daysBetweenIssueAndMaturity)) {
 				//	return date error
 				return $daysBetweenIssueAndMaturity;
 			}
 			$daysBetweenIssueAndMaturity *= $daysPerYear;
 			$daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity, $basis);
-			if (!is_numeric($daysBetweenSettlementAndMaturity)) {
+			if ( ! is_numeric($daysBetweenSettlementAndMaturity)) {
 				//	return date error
 				return $daysBetweenSettlementAndMaturity;
 			}
@@ -1747,7 +1747,7 @@ 
 		}
 
 		// Calculate
-		if (!is_null($rate) && $rate != 0) {
+		if ( ! is_null($rate) && $rate != 0) {
 			return (-$pmt * (1 + $rate * $type) * ((pow(1 + $rate, $nper) - 1) / $rate) - $fv) / pow(1 + $rate, $nper);
 		} else {
 			return -$fv - $pmt * $nper;
@@ -1786,12 +1786,12 @@ 
 	 * @return	float
 	 **/
 	public static function RATE($nper, $pmt, $pv, $fv = 0.0, $type = 0, $guess = 0.1) {
-		$nper	= (int) PHPExcel_Calculation_Functions::flattenSingleValue($nper);
+		$nper = (int) PHPExcel_Calculation_Functions::flattenSingleValue($nper);
 		$pmt	= PHPExcel_Calculation_Functions::flattenSingleValue($pmt);
 		$pv		= PHPExcel_Calculation_Functions::flattenSingleValue($pv);
-		$fv		= (is_null($fv))	? 0.0	:	PHPExcel_Calculation_Functions::flattenSingleValue($fv);
-		$type	= (is_null($type))	? 0		:	(int) PHPExcel_Calculation_Functions::flattenSingleValue($type);
-		$guess	= (is_null($guess))	? 0.1	:	PHPExcel_Calculation_Functions::flattenSingleValue($guess);
+		$fv		= (is_null($fv)) ? 0.0 : PHPExcel_Calculation_Functions::flattenSingleValue($fv);
+		$type	= (is_null($type)) ? 0 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($type);
+		$guess = (is_null($guess)) ? 0.1 : PHPExcel_Calculation_Functions::flattenSingleValue($guess);
 
 		$rate = $guess;
 		if (abs($rate) < FINANCIAL_PRECISION) {
@@ -1847,12 +1847,12 @@ 
 	 *										4				European 30/360
 	 * @return	float
 	 */
-	public static function RECEIVED($settlement, $maturity, $investment, $discount, $basis=0) {
+	public static function RECEIVED($settlement, $maturity, $investment, $discount, $basis = 0) {
 		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
 		$maturity	= PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
 		$investment	= (float) PHPExcel_Calculation_Functions::flattenSingleValue($investment);
 		$discount	= (float) PHPExcel_Calculation_Functions::flattenSingleValue($discount);
-		$basis		= (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
+		$basis = (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
 
 		//	Validate
 		if ((is_numeric($investment)) && (is_numeric($discount)) && (is_numeric($basis))) {
@@ -1860,12 +1860,12 @@ 
 				return PHPExcel_Calculation_Functions::NaN();
 			}
 			$daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity, $basis);
-			if (!is_numeric($daysBetweenSettlementAndMaturity)) {
+			if ( ! is_numeric($daysBetweenSettlementAndMaturity)) {
 				//	return date error
 				return $daysBetweenSettlementAndMaturity;
 			}
 
-			return $investment / ( 1 - ($discount * $daysBetweenSettlementAndMaturity));
+			return $investment / (1 - ($discount * $daysBetweenSettlementAndMaturity));
 		}
 		return PHPExcel_Calculation_Functions::VALUE();
 	}	//	function RECEIVED()
@@ -1883,7 +1883,7 @@ 
 	 */
 	public static function SLN($cost, $salvage, $life) {
 		$cost		= PHPExcel_Calculation_Functions::flattenSingleValue($cost);
-		$salvage	= PHPExcel_Calculation_Functions::flattenSingleValue($salvage);
+		$salvage = PHPExcel_Calculation_Functions::flattenSingleValue($salvage);
 		$life		= PHPExcel_Calculation_Functions::flattenSingleValue($life);
 
 		// Calculate
@@ -1938,7 +1938,7 @@ 
 	 * @return	float
 	 */
 	public static function TBILLEQ($settlement, $maturity, $discount) {
-		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
+		$settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
 		$maturity	= PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
 		$discount	= PHPExcel_Calculation_Functions::flattenSingleValue($discount);
 
@@ -1976,7 +1976,7 @@ 
 	 * @return	float
 	 */
 	public static function TBILLPRICE($settlement, $maturity, $discount) {
-		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
+		$settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
 		$maturity	= PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
 		$discount	= PHPExcel_Calculation_Functions::flattenSingleValue($discount);
 
@@ -1993,7 +1993,7 @@ 
 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
 				++$maturity;
 				$daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity) * 360;
-				if (!is_numeric($daysBetweenSettlementAndMaturity)) {
+				if ( ! is_numeric($daysBetweenSettlementAndMaturity)) {
 					//	return date error
 					return $daysBetweenSettlementAndMaturity;
 				}
@@ -2028,9 +2028,9 @@ 
 	 * @return	float
 	 */
 	public static function TBILLYIELD($settlement, $maturity, $price) {
-		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
-		$maturity	= PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
-		$price		= PHPExcel_Calculation_Functions::flattenSingleValue($price);
+		$settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
+		$maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
+		$price = PHPExcel_Calculation_Functions::flattenSingleValue($price);
 
 		//	Validate
 		if (is_numeric($price)) {
@@ -2041,7 +2041,7 @@ 
 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
 				++$maturity;
 				$daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity) * 360;
-				if (!is_numeric($daysBetweenSettlementAndMaturity)) {
+				if ( ! is_numeric($daysBetweenSettlementAndMaturity)) {
 					//	return date error
 					return $daysBetweenSettlementAndMaturity;
 				}
@@ -2060,8 +2060,8 @@ 
 
 
 	public static function XIRR($values, $dates, $guess = 0.1) {
-		if ((!is_array($values)) && (!is_array($dates))) return PHPExcel_Calculation_Functions::VALUE();
-		$values	= PHPExcel_Calculation_Functions::flattenArray($values);
+		if (( ! is_array($values)) && ( ! is_array($dates))) return PHPExcel_Calculation_Functions::VALUE();
+		$values = PHPExcel_Calculation_Functions::flattenArray($values);
 		$dates	= PHPExcel_Calculation_Functions::flattenArray($dates);
 		$guess = PHPExcel_Calculation_Functions::flattenSingleValue($guess);
 		if (count($values) != count($dates)) return PHPExcel_Calculation_Functions::NaN();
@@ -2090,7 +2090,7 @@ 
 			$dx = $x1 - $x2;
 		}
 
-		for ($i = 0;  $i < FINANCIAL_MAX_ITERATIONS; ++$i) {
+		for ($i = 0; $i < FINANCIAL_MAX_ITERATIONS; ++$i) {
 			$dx *= 0.5;
 			$x_mid = $rtb + $dx;
 			$f_mid = self::XNPV($x_mid, $values, $dates);
@@ -2117,18 +2117,18 @@ 
 	 */
 	public static function XNPV($rate, $values, $dates) {
 		$rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
-		if (!is_numeric($rate)) return PHPExcel_Calculation_Functions::VALUE();
-		if ((!is_array($values)) || (!is_array($dates))) return PHPExcel_Calculation_Functions::VALUE();
-		$values	= PHPExcel_Calculation_Functions::flattenArray($values);
-		$dates	= PHPExcel_Calculation_Functions::flattenArray($dates);
+		if ( ! is_numeric($rate)) return PHPExcel_Calculation_Functions::VALUE();
+		if (( ! is_array($values)) || ( ! is_array($dates))) return PHPExcel_Calculation_Functions::VALUE();
+		$values = PHPExcel_Calculation_Functions::flattenArray($values);
+		$dates = PHPExcel_Calculation_Functions::flattenArray($dates);
 		$valCount = count($values);
 		if ($valCount != count($dates)) return PHPExcel_Calculation_Functions::NaN();
 		if ((min($values) > 0) || (max($values) < 0)) return PHPExcel_Calculation_Functions::VALUE();
 
 		$xnpv = 0.0;
 		for ($i = 0; $i < $valCount; ++$i) {
-			if (!is_numeric($values[$i])) return PHPExcel_Calculation_Functions::VALUE();
-			$xnpv += $values[$i] / pow(1 + $rate, PHPExcel_Calculation_DateTime::DATEDIF($dates[0],$dates[$i],'d') / 365);
+			if ( ! is_numeric($values[$i])) return PHPExcel_Calculation_Functions::VALUE();
+			$xnpv += $values[$i] / pow(1 + $rate, PHPExcel_Calculation_DateTime::DATEDIF($dates[0], $dates[$i], 'd') / 365);
 		}
 		return (is_finite($xnpv)) ? $xnpv : PHPExcel_Calculation_Functions::VALUE();
 	}	//	function XNPV()
@@ -2153,9 +2153,9 @@ 
 	 *										4				European 30/360
 	 * @return	float
 	 */
-	public static function YIELDDISC($settlement, $maturity, $price, $redemption, $basis=0) {
+	public static function YIELDDISC($settlement, $maturity, $price, $redemption, $basis = 0) {
 		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
-		$maturity	= PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
+		$maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
 		$price		= PHPExcel_Calculation_Functions::flattenSingleValue($price);
 		$redemption	= PHPExcel_Calculation_Functions::flattenSingleValue($redemption);
 		$basis		= (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
@@ -2165,12 +2165,12 @@ 
 			if (($price <= 0) || ($redemption <= 0)) {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
-			$daysPerYear = self::_daysPerYear(PHPExcel_Calculation_DateTime::YEAR($settlement),$basis);
-			if (!is_numeric($daysPerYear)) {
+			$daysPerYear = self::_daysPerYear(PHPExcel_Calculation_DateTime::YEAR($settlement), $basis);
+			if ( ! is_numeric($daysPerYear)) {
 				return $daysPerYear;
 			}
-			$daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity,$basis);
-			if (!is_numeric($daysBetweenSettlementAndMaturity)) {
+			$daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity, $basis);
+			if ( ! is_numeric($daysBetweenSettlementAndMaturity)) {
 				//	return date error
 				return $daysBetweenSettlementAndMaturity;
 			}
@@ -2202,11 +2202,11 @@ 
 	 *										4				European 30/360
 	 * @return	float
 	 */
-	public static function YIELDMAT($settlement, $maturity, $issue, $rate, $price, $basis=0) {
-		$settlement	= PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
-		$maturity	= PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
+	public static function YIELDMAT($settlement, $maturity, $issue, $rate, $price, $basis = 0) {
+		$settlement = PHPExcel_Calculation_Functions::flattenSingleValue($settlement);
+		$maturity = PHPExcel_Calculation_Functions::flattenSingleValue($maturity);
 		$issue		= PHPExcel_Calculation_Functions::flattenSingleValue($issue);
-		$rate		= PHPExcel_Calculation_Functions::flattenSingleValue($rate);
+		$rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
 		$price		= PHPExcel_Calculation_Functions::flattenSingleValue($price);
 		$basis		= (int) PHPExcel_Calculation_Functions::flattenSingleValue($basis);
 
@@ -2215,24 +2215,24 @@ 
 			if (($rate <= 0) || ($price <= 0)) {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
-			$daysPerYear = self::_daysPerYear(PHPExcel_Calculation_DateTime::YEAR($settlement),$basis);
-			if (!is_numeric($daysPerYear)) {
+			$daysPerYear = self::_daysPerYear(PHPExcel_Calculation_DateTime::YEAR($settlement), $basis);
+			if ( ! is_numeric($daysPerYear)) {
 				return $daysPerYear;
 			}
 			$daysBetweenIssueAndSettlement = PHPExcel_Calculation_DateTime::YEARFRAC($issue, $settlement, $basis);
-			if (!is_numeric($daysBetweenIssueAndSettlement)) {
+			if ( ! is_numeric($daysBetweenIssueAndSettlement)) {
 				//	return date error
 				return $daysBetweenIssueAndSettlement;
 			}
 			$daysBetweenIssueAndSettlement *= $daysPerYear;
 			$daysBetweenIssueAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($issue, $maturity, $basis);
-			if (!is_numeric($daysBetweenIssueAndMaturity)) {
+			if ( ! is_numeric($daysBetweenIssueAndMaturity)) {
 				//	return date error
 				return $daysBetweenIssueAndMaturity;
 			}
 			$daysBetweenIssueAndMaturity *= $daysPerYear;
 			$daysBetweenSettlementAndMaturity = PHPExcel_Calculation_DateTime::YEARFRAC($settlement, $maturity, $basis);
-			if (!is_numeric($daysBetweenSettlementAndMaturity)) {
+			if ( ! is_numeric($daysBetweenSettlementAndMaturity)) {
 				//	return date error
 				return $daysBetweenSettlementAndMaturity;
 			}

Braces +54 added lines, -19 removed lines

@@ -1304,7 +1304,9 @@ 
 
 
 	public static function IRR($values, $guess = 0.1) {
-		if (!is_array($values)) return PHPExcel_Calculation_Functions::VALUE();
+		if (!is_array($values)) {
+			return PHPExcel_Calculation_Functions::VALUE();
+		}
 		$values = PHPExcel_Calculation_Functions::flattenArray($values);
 		$guess = PHPExcel_Calculation_Functions::flattenSingleValue($guess);
 
@@ -1314,14 +1316,18 @@ 
 		$f1 = self::NPV($x1, $values);
 		$f2 = self::NPV($x2, $values);
 		for ($i = 0; $i < FINANCIAL_MAX_ITERATIONS; ++$i) {
-			if (($f1 * $f2) < 0.0) break;
+			if (($f1 * $f2) < 0.0) {
+				break;
+			}
 			if (abs($f1) < abs($f2)) {
 				$f1 = self::NPV($x1 += 1.6 * ($x1 - $x2), $values);
 			} else {
 				$f2 = self::NPV($x2 += 1.6 * ($x2 - $x1), $values);
 			}
 		}
-		if (($f1 * $f2) > 0.0) return PHPExcel_Calculation_Functions::VALUE();
+		if (($f1 * $f2) > 0.0) {
+			return PHPExcel_Calculation_Functions::VALUE();
+		}
 
 		$f = self::NPV($x1, $values);
 		if ($f < 0.0) {
@@ -1336,8 +1342,12 @@ 
 			$dx *= 0.5;
 			$x_mid = $rtb + $dx;
 			$f_mid = self::NPV($x_mid, $values);
-			if ($f_mid <= 0.0) $rtb = $x_mid;
-			if ((abs($f_mid) < FINANCIAL_PRECISION) || (abs($dx) < FINANCIAL_PRECISION)) return $x_mid;
+			if ($f_mid <= 0.0) {
+				$rtb = $x_mid;
+			}
+			if ((abs($f_mid) < FINANCIAL_PRECISION) || (abs($dx) < FINANCIAL_PRECISION)) {
+				return $x_mid;
+			}
 		}
 		return PHPExcel_Calculation_Functions::VALUE();
 	}	//	function IRR()
@@ -1385,7 +1395,9 @@ 
 
 
 	public static function MIRR($values, $finance_rate, $reinvestment_rate) {
-		if (!is_array($values)) return PHPExcel_Calculation_Functions::VALUE();
+		if (!is_array($values)) {
+			return PHPExcel_Calculation_Functions::VALUE();
+		}
 		$values				= PHPExcel_Calculation_Functions::flattenArray($values);
 		$finance_rate		= PHPExcel_Calculation_Functions::flattenSingleValue($finance_rate);
 		$reinvestment_rate	= PHPExcel_Calculation_Functions::flattenSingleValue($reinvestment_rate);
@@ -1810,8 +1822,9 @@ 
 			$rate = ($y1 * $x0 - $y0 * $x1) / ($y1 - $y0);
 			$x0 = $x1;
 			$x1 = $rate;
-			if (($nper * abs($pmt)) > ($pv - $fv))
-				$x1 = abs($x1);
+			if (($nper * abs($pmt)) > ($pv - $fv)) {
+							$x1 = abs($x1);
+			}
 
 			if (abs($rate) < FINANCIAL_PRECISION) {
 				$y = $pv * (1 + $nper * $rate) + $pmt * (1 + $rate * $type) * $nper + $fv;
@@ -2060,11 +2073,15 @@ 
 
 
 	public static function XIRR($values, $dates, $guess = 0.1) {
-		if ((!is_array($values)) && (!is_array($dates))) return PHPExcel_Calculation_Functions::VALUE();
+		if ((!is_array($values)) && (!is_array($dates))) {
+			return PHPExcel_Calculation_Functions::VALUE();
+		}
 		$values	= PHPExcel_Calculation_Functions::flattenArray($values);
 		$dates	= PHPExcel_Calculation_Functions::flattenArray($dates);
 		$guess = PHPExcel_Calculation_Functions::flattenSingleValue($guess);
-		if (count($values) != count($dates)) return PHPExcel_Calculation_Functions::NaN();
+		if (count($values) != count($dates)) {
+			return PHPExcel_Calculation_Functions::NaN();
+		}
 
 		// create an initial range, with a root somewhere between 0 and guess
 		$x1 = 0.0;
@@ -2072,14 +2089,18 @@ 
 		$f1 = self::XNPV($x1, $values, $dates);
 		$f2 = self::XNPV($x2, $values, $dates);
 		for ($i = 0; $i < FINANCIAL_MAX_ITERATIONS; ++$i) {
-			if (($f1 * $f2) < 0.0) break;
+			if (($f1 * $f2) < 0.0) {
+				break;
+			}
 			if (abs($f1) < abs($f2)) {
 				$f1 = self::XNPV($x1 += 1.6 * ($x1 - $x2), $values, $dates);
 			} else {
 				$f2 = self::XNPV($x2 += 1.6 * ($x2 - $x1), $values, $dates);
 			}
 		}
-		if (($f1 * $f2) > 0.0) return PHPExcel_Calculation_Functions::VALUE();
+		if (($f1 * $f2) > 0.0) {
+			return PHPExcel_Calculation_Functions::VALUE();
+		}
 
 		$f = self::XNPV($x1, $values, $dates);
 		if ($f < 0.0) {
@@ -2094,8 +2115,12 @@ 
 			$dx *= 0.5;
 			$x_mid = $rtb + $dx;
 			$f_mid = self::XNPV($x_mid, $values, $dates);
-			if ($f_mid <= 0.0) $rtb = $x_mid;
-			if ((abs($f_mid) < FINANCIAL_PRECISION) || (abs($dx) < FINANCIAL_PRECISION)) return $x_mid;
+			if ($f_mid <= 0.0) {
+				$rtb = $x_mid;
+			}
+			if ((abs($f_mid) < FINANCIAL_PRECISION) || (abs($dx) < FINANCIAL_PRECISION)) {
+				return $x_mid;
+			}
 		}
 		return PHPExcel_Calculation_Functions::VALUE();
 	}
@@ -2117,17 +2142,27 @@ 
 	 */
 	public static function XNPV($rate, $values, $dates) {
 		$rate = PHPExcel_Calculation_Functions::flattenSingleValue($rate);
-		if (!is_numeric($rate)) return PHPExcel_Calculation_Functions::VALUE();
-		if ((!is_array($values)) || (!is_array($dates))) return PHPExcel_Calculation_Functions::VALUE();
+		if (!is_numeric($rate)) {
+			return PHPExcel_Calculation_Functions::VALUE();
+		}
+		if ((!is_array($values)) || (!is_array($dates))) {
+			return PHPExcel_Calculation_Functions::VALUE();
+		}
 		$values	= PHPExcel_Calculation_Functions::flattenArray($values);
 		$dates	= PHPExcel_Calculation_Functions::flattenArray($dates);
 		$valCount = count($values);
-		if ($valCount != count($dates)) return PHPExcel_Calculation_Functions::NaN();
-		if ((min($values) > 0) || (max($values) < 0)) return PHPExcel_Calculation_Functions::VALUE();
+		if ($valCount != count($dates)) {
+			return PHPExcel_Calculation_Functions::NaN();
+		}
+		if ((min($values) > 0) || (max($values) < 0)) {
+			return PHPExcel_Calculation_Functions::VALUE();
+		}
 
 		$xnpv = 0.0;
 		for ($i = 0; $i < $valCount; ++$i) {
-			if (!is_numeric($values[$i])) return PHPExcel_Calculation_Functions::VALUE();
+			if (!is_numeric($values[$i])) {
+				return PHPExcel_Calculation_Functions::VALUE();
+			}
 			$xnpv += $values[$i] / pow(1 + $rate, PHPExcel_Calculation_DateTime::DATEDIF($dates[0],$dates[$i],'d') / 365);
 		}
 		return (is_finite($xnpv)) ? $xnpv : PHPExcel_Calculation_Functions::VALUE();

Indentation +1 added lines, -1 removed lines

@@ -409,7 +409,7 @@
 		} elseif ($period <= $nNumOfFullPeriods) {
 			return $fOneRate;
 		} elseif ($period == ($nNumOfFullPeriods + 1)) {
-            return ($fCostDelta - $fOneRate * $nNumOfFullPeriods - $f0Rate);
+			return ($fCostDelta - $fOneRate * $nNumOfFullPeriods - $f0Rate);
 		} else {
 			return 0.0;
 		}

app/Vendor/PHPExcel/PHPExcel/Calculation/FormulaParser.php

Doc Comments +2 added lines, -2 removed lines

@@ -121,7 +121,7 @@ 
      * Get Token
      *
      * @param 	int		$pId	Token id
-     * @return	string
+     * @return	PHPExcel_Calculation_FormulaToken
      * @throws  Exception
      */
     public function getToken($pId = 0) {
@@ -135,7 +135,7 @@ 
     /**
      * Get Token count
      *
-     * @return string
+     * @return integer
      */
     public function getTokenCount() {
     	return count($this->_tokens);

Indentation +68 added lines, -68 removed lines

@@ -89,71 +89,71 @@ 
 	 */
 	private $_tokens = array();
 
-    /**
-     * Create a new PHPExcel_Calculation_FormulaParser
-     *
-     * @param 	string		$pFormula	Formula to parse
-     * @throws 	Exception
-     */
-    public function __construct($pFormula = '')
-    {
-    	// Check parameters
-    	if (is_null($pFormula)) {
-    		throw new Exception("Invalid parameter passed: formula");
-    	}
-
-    	// Initialise values
-    	$this->_formula = trim($pFormula);
-    	// Parse!
-    	$this->_parseToTokens();
-    }
-
-    /**
-     * Get Formula
-     *
-     * @return string
-     */
-    public function getFormula() {
-    	return $this->_formula;
-    }
-
-    /**
-     * Get Token
-     *
-     * @param 	int		$pId	Token id
-     * @return	string
-     * @throws  Exception
-     */
-    public function getToken($pId = 0) {
-    	if (isset($this->_tokens[$pId])) {
-    		return $this->_tokens[$pId];
-    	} else {
-    		throw new Exception("Token with id $pId does not exist.");
-    	}
-    }
-
-    /**
-     * Get Token count
-     *
-     * @return string
-     */
-    public function getTokenCount() {
-    	return count($this->_tokens);
-    }
-
-    /**
-     * Get Tokens
-     *
-     * @return PHPExcel_Calculation_FormulaToken[]
-     */
-    public function getTokens() {
-    	return $this->_tokens;
-    }
-
-    /**
-     * Parse to tokens
-     */
-    private function _parseToTokens() {
+	/**
+	 * Create a new PHPExcel_Calculation_FormulaParser
+	 *
+	 * @param 	string		$pFormula	Formula to parse
+	 * @throws 	Exception
+	 */
+	public function __construct($pFormula = '')
+	{
+		// Check parameters
+		if (is_null($pFormula)) {
+			throw new Exception("Invalid parameter passed: formula");
+		}
+
+		// Initialise values
+		$this->_formula = trim($pFormula);
+		// Parse!
+		$this->_parseToTokens();
+	}
+
+	/**
+	 * Get Formula
+	 *
+	 * @return string
+	 */
+	public function getFormula() {
+		return $this->_formula;
+	}
+
+	/**
+	 * Get Token
+	 *
+	 * @param 	int		$pId	Token id
+	 * @return	string
+	 * @throws  Exception
+	 */
+	public function getToken($pId = 0) {
+		if (isset($this->_tokens[$pId])) {
+			return $this->_tokens[$pId];
+		} else {
+			throw new Exception("Token with id $pId does not exist.");
+		}
+	}
+
+	/**
+	 * Get Token count
+	 *
+	 * @return string
+	 */
+	public function getTokenCount() {
+		return count($this->_tokens);
+	}
+
+	/**
+	 * Get Tokens
+	 *
+	 * @return PHPExcel_Calculation_FormulaToken[]
+	 */
+	public function getTokens() {
+		return $this->_tokens;
+	}
+
+	/**
+	 * Parse to tokens
+	 */
+	private function _parseToTokens() {
 		// No attempt is made to verify formulas; assumes formulas are derived from Excel, where
 		// they can only exist if valid; stack overflows/underflows sunk as nulls without exceptions.
 
@@ -453,7 +453,7 @@ 
 				continue;
 			}
 
-        	// token accumulation
+			// token accumulation
 			$value .= $this->_formula{$index};
 			++$index;
 		}
@@ -608,7 +608,7 @@ 
 				}
 			}
 
-        	$this->_tokens[] = $token;
+			$this->_tokens[] = $token;
 		}
-    }
+	}
 }

Spacing +14 added lines, -14 removed lines

@@ -71,9 +71,9 @@ 
 	const COMMA         = ',';
 	const ERROR_START   = '#';
 
-	const OPERATORS_SN 			= "+-";
-	const OPERATORS_INFIX 		= "+-*/^&=><";
-	const OPERATORS_POSTFIX 	= "%";
+	const OPERATORS_SN = "+-";
+	const OPERATORS_INFIX = "+-*/^&=><";
+	const OPERATORS_POSTFIX = "%";
 
 	/**
 	 * Formula
@@ -162,15 +162,15 @@ 
 		if ($formulaLength < 2 || $this->_formula{0} != '=') return;
 
 		// Helper variables
-		$tokens1	= $tokens2 	= $stack = array();
-		$inString	= $inPath 	= $inRange 	= $inError = false;
-		$token		= $previousToken	= $nextToken	= null;
+		$tokens1 = $tokens2 	= $stack = array();
+		$inString = $inPath 	= $inRange = $inError = false;
+		$token = $previousToken = $nextToken = null;
 
 		$index	= 1;
 		$value	= '';
 
-		$ERRORS 			= array("#NULL!", "#DIV/0!", "#VALUE!", "#REF!", "#NAME?", "#NUM!", "#N/A");
-		$COMPARATORS_MULTI 	= array(">=", "<=", "<>");
+		$ERRORS = array("#NULL!", "#DIV/0!", "#VALUE!", "#REF!", "#NAME?", "#NUM!", "#N/A");
+		$COMPARATORS_MULTI = array(">=", "<=", "<>");
 
 		while ($index < $formulaLength) {
 			// state-dependent character evaluation (order is important)
@@ -381,7 +381,7 @@ 
 			// standard infix operators
 			if (strpos(PHPExcel_Calculation_FormulaParser::OPERATORS_INFIX, $this->_formula{$index}) !== false) {
 				if (strlen($value) > 0) {
-					$tokens1[] =new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND);
+					$tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND);
 					$value = "";
 				}
 				$tokens1[] = new PHPExcel_Calculation_FormulaToken($this->_formula{$index}, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORINFIX);
@@ -491,11 +491,11 @@ 
 				continue;
 			}
 
-			if (! (
+			if ( ! (
 					(($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION) && ($previousToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP)) ||
 					(($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_SUBEXPRESSION) && ($previousToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP)) ||
 					($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND)
-				  ) ) {
+				  )) {
 				continue;
 			}
 
@@ -503,11 +503,11 @@ 
 				continue;
 			}
 
-			if (! (
+			if ( ! (
 					(($nextToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION) && ($nextToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START)) ||
 					(($nextToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_SUBEXPRESSION) && ($nextToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START)) ||
 					($nextToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND)
-				  ) ) {
+				  )) {
 				continue;
 			}
 
@@ -586,7 +586,7 @@ 
 			}
 
 			if ($token->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND && $token->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_NOTHING) {
-				if (!is_numeric($token->getValue())) {
+				if ( ! is_numeric($token->getValue())) {
 					if (strtoupper($token->getValue()) == "TRUE" || strtoupper($token->getValue() == "FALSE")) {
 						$token->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_LOGICAL);
 					} else {

Braces +3 added lines, -1 removed lines

@@ -159,7 +159,9 @@
 
 		// Check if the formula has a valid starting =
 		$formulaLength = strlen($this->_formula);
-		if ($formulaLength < 2 || $this->_formula{0} != '=') return;
+		if ($formulaLength < 2 || $this->_formula{0} != '=') {
+			return;
+		}
 
 		// Helper variables
 		$tokens1	= $tokens2 	= $stack = array();

app/Vendor/PHPExcel/PHPExcel/Calculation/Logical.php

Doc Comments +5 added lines, -7 removed lines

@@ -97,8 +97,7 @@ 
 	 *
 	 * @access	public
 	 * @category Logical Functions
-	 * @param	mixed		$arg,...		Data values
-	 * @return	boolean		The logical AND of the arguments.
+	 * @return	string|boolean		The logical AND of the arguments.
 	 */
 	public static function LOGICAL_AND() {
 		// Return value
@@ -152,8 +151,7 @@ 
 	 *
 	 * @access	public
 	 * @category Logical Functions
-	 * @param	mixed		$arg,...		Data values
-	 * @return	boolean		The logical OR of the arguments.
+	 * @return	string|boolean		The logical OR of the arguments.
 	 */
 	public static function LOGICAL_OR() {
 		// Return value
@@ -207,7 +205,7 @@ 
 	 * @access	public
 	 * @category Logical Functions
 	 * @param	mixed		$logical	A value or expression that can be evaluated to TRUE or FALSE
-	 * @return	boolean		The boolean inverse of the argument.
+	 * @return	boolean|string		The boolean inverse of the argument.
 	 */
 	public static function NOT($logical=FALSE) {
 		$logical = PHPExcel_Calculation_Functions::flattenSingleValue($logical);
@@ -252,8 +250,8 @@ 
 	 *
 	 * @access	public
 	 * @category Logical Functions
-	 * @param	mixed	$condition		Condition to evaluate
-	 * @param	mixed	$returnIfTrue	Value to return when condition is true
+	 * @param	boolean	$condition		Condition to evaluate
+	 * @param	integer	$returnIfTrue	Value to return when condition is true
 	 * @param	mixed	$returnIfFalse	Optional value to return when condition is false
 	 * @return	mixed	The value of returnIfTrue or returnIfFalse determined by condition
 	 */

Spacing +12 added lines, -12 removed lines

@@ -27,12 +27,12 @@ 
 
 
 /** PHPExcel root directory */
-if (!defined('PHPEXCEL_ROOT')) {
+if ( ! defined('PHPEXCEL_ROOT')) {
 	/**
 	 * @ignore
 	 */
-	define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
-	require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	define('PHPEXCEL_ROOT', dirname(__FILE__).'/../../');
+	require(PHPEXCEL_ROOT.'PHPExcel/Autoloader.php');
 }
 
 
@@ -111,7 +111,7 @@ 
 			// Is it a boolean value?
 			if (is_bool($arg)) {
 				$returnValue = $returnValue && $arg;
-			} elseif ((is_numeric($arg)) && (!is_string($arg))) {
+			} elseif ((is_numeric($arg)) && ( ! is_string($arg))) {
 				$returnValue = $returnValue && ($arg != 0);
 			} elseif (is_string($arg)) {
 				$arg = strtoupper($arg);
@@ -166,7 +166,7 @@ 
 			// Is it a boolean value?
 			if (is_bool($arg)) {
 				$returnValue = $returnValue || $arg;
-			} elseif ((is_numeric($arg)) && (!is_string($arg))) {
+			} elseif ((is_numeric($arg)) && ( ! is_string($arg))) {
 				$returnValue = $returnValue || ($arg != 0);
 			} elseif (is_string($arg)) {
 				$arg = strtoupper($arg);
@@ -209,7 +209,7 @@ 
 	 * @param	mixed		$logical	A value or expression that can be evaluated to TRUE or FALSE
 	 * @return	boolean		The boolean inverse of the argument.
 	 */
-	public static function NOT($logical=FALSE) {
+	public static function NOT($logical = FALSE) {
 		$logical = PHPExcel_Calculation_Functions::flattenSingleValue($logical);
 		if (is_string($logical)) {
 			$logical = strtoupper($logical);
@@ -222,7 +222,7 @@ 
 			}
 		}
 
-		return !$logical;
+		return ! $logical;
 	}	//	function NOT()
 
 	/**
@@ -258,9 +258,9 @@ 
 	 * @return	mixed	The value of returnIfTrue or returnIfFalse determined by condition
 	 */
 	public static function STATEMENT_IF($condition = TRUE, $returnIfTrue = 0, $returnIfFalse = FALSE) {
-		$condition		= (is_null($condition))		? TRUE :	(boolean) PHPExcel_Calculation_Functions::flattenSingleValue($condition);
-		$returnIfTrue	= (is_null($returnIfTrue))	? 0 :		PHPExcel_Calculation_Functions::flattenSingleValue($returnIfTrue);
-		$returnIfFalse	= (is_null($returnIfFalse))	? FALSE :	PHPExcel_Calculation_Functions::flattenSingleValue($returnIfFalse);
+		$condition = (is_null($condition)) ? TRUE : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($condition);
+		$returnIfTrue = (is_null($returnIfTrue)) ? 0 : PHPExcel_Calculation_Functions::flattenSingleValue($returnIfTrue);
+		$returnIfFalse = (is_null($returnIfFalse)) ? FALSE : PHPExcel_Calculation_Functions::flattenSingleValue($returnIfFalse);
 
 		return ($condition) ? $returnIfTrue : $returnIfFalse;
 	}	//	function STATEMENT_IF()
@@ -279,8 +279,8 @@ 
 	 * @return	mixed	The value of errorpart or testValue determined by error condition
 	 */
 	public static function IFERROR($testValue = '', $errorpart = '') {
-		$testValue	= (is_null($testValue))	? '' :	PHPExcel_Calculation_Functions::flattenSingleValue($testValue);
-		$errorpart	= (is_null($errorpart))	? '' :	PHPExcel_Calculation_Functions::flattenSingleValue($errorpart);
+		$testValue	= (is_null($testValue)) ? '' : PHPExcel_Calculation_Functions::flattenSingleValue($testValue);
+		$errorpart	= (is_null($errorpart)) ? '' : PHPExcel_Calculation_Functions::flattenSingleValue($errorpart);
 
 		return self::STATEMENT_IF(PHPExcel_Calculation_Functions::IS_ERROR($testValue), $errorpart, $testValue);
 	}	//	function IFERROR()

app/Vendor/PHPExcel/PHPExcel/Calculation/LookupRef.php

Doc Comments +4 added lines, -4 removed lines

@@ -56,7 +56,7 @@ 
 	 *
 	 * @param	row				Row number to use in the cell reference
 	 * @param	column			Column number to use in the cell reference
-	 * @param	relativity		Flag indicating the type of reference to return
+	 * @param	relativity		integer indicating the type of reference to return
 	 *								1 or omitted	Absolute
 	 *								2				Absolute row; relative column
 	 *								3				Relative row; absolute column
@@ -345,7 +345,7 @@ 
 	 *
 	 * @param	cellAddress		The reference from which you want to base the offset. Reference must refer to a cell or
 	 *								range of adjacent cells; otherwise, OFFSET returns the #VALUE! error value.
-	 * @param	rows			The number of rows, up or down, that you want the upper-left cell to refer to.
+	 * @param	rows			integer number of rows, up or down, that you want the upper-left cell to refer to.
 	 *								Using 5 as the rows argument specifies that the upper-left cell in the reference is
 	 *								five rows below reference. Rows can be positive (which means below the starting reference)
 	 *								or negative (which means above the starting reference).
@@ -480,7 +480,7 @@ 
 	 *
 	 * @param	lookup_value	The value that you want to match in lookup_array
 	 * @param	lookup_array	The range of cells being searched
-	 * @param	match_type		The number -1, 0, or 1. -1 means above, 0 means exact match, 1 means below. If match_type is 1 or -1, the list has to be ordered.
+	 * @param	match_type		integer number -1, 0, or 1. -1 means above, 0 means exact match, 1 means below. If match_type is 1 or -1, the list has to be ordered.
 	 * @return	integer			The relative position of the found item
 	 */
 	public static function MATCH($lookup_value, $lookup_array, $match_type=1) {
@@ -682,7 +682,7 @@ 
 	* The VLOOKUP function searches for value in the left-most column of lookup_array and returns the value in the same row based on the index_number.
 	* @param	lookup_value	The value that you want to match in lookup_array
 	* @param	lookup_array	The range of cells being searched
-	* @param	index_number	The column number in table_array from which the matching value must be returned. The first column is 1.
+	* @param	index_number	integer column number in table_array from which the matching value must be returned. The first column is 1.
 	* @param	not_exact_match	Determines if you are looking for an exact match based on lookup_value.
 	* @return	mixed			The value of the found cell
 	*/

Indentation +8 added lines, -8 removed lines

@@ -678,14 +678,14 @@
 
 
 	/**
-	* VLOOKUP
-	* The VLOOKUP function searches for value in the left-most column of lookup_array and returns the value in the same row based on the index_number.
-	* @param	lookup_value	The value that you want to match in lookup_array
-	* @param	lookup_array	The range of cells being searched
-	* @param	index_number	The column number in table_array from which the matching value must be returned. The first column is 1.
-	* @param	not_exact_match	Determines if you are looking for an exact match based on lookup_value.
-	* @return	mixed			The value of the found cell
-	*/
+	 * VLOOKUP
+	 * The VLOOKUP function searches for value in the left-most column of lookup_array and returns the value in the same row based on the index_number.
+	 * @param	lookup_value	The value that you want to match in lookup_array
+	 * @param	lookup_array	The range of cells being searched
+	 * @param	index_number	The column number in table_array from which the matching value must be returned. The first column is 1.
+	 * @param	not_exact_match	Determines if you are looking for an exact match based on lookup_value.
+	 * @return	mixed			The value of the found cell
+	 */
 	public static function VLOOKUP($lookup_value, $lookup_array, $index_number, $not_exact_match=true) {
 		$lookup_value	= PHPExcel_Calculation_Functions::flattenSingleValue($lookup_value);
 		$index_number	= PHPExcel_Calculation_Functions::flattenSingleValue($index_number);

Spacing +103 added lines, -103 removed lines

@@ -27,12 +27,12 @@ 
 
 
 /** PHPExcel root directory */
-if (!defined('PHPEXCEL_ROOT')) {
+if ( ! defined('PHPEXCEL_ROOT')) {
 	/**
 	 * @ignore
 	 */
-	define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
-	require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	define('PHPEXCEL_ROOT', dirname(__FILE__).'/../../');
+	require(PHPEXCEL_ROOT.'PHPExcel/Autoloader.php');
 }
 
 
@@ -67,23 +67,23 @@ 
 	 * @param	sheetText		Optional Name of worksheet to use
 	 * @return	string
 	 */
-	public static function CELL_ADDRESS($row, $column, $relativity=1, $referenceStyle=True, $sheetText='') {
-		$row		= PHPExcel_Calculation_Functions::flattenSingleValue($row);
-		$column		= PHPExcel_Calculation_Functions::flattenSingleValue($column);
-		$relativity	= PHPExcel_Calculation_Functions::flattenSingleValue($relativity);
-		$sheetText	= PHPExcel_Calculation_Functions::flattenSingleValue($sheetText);
+	public static function CELL_ADDRESS($row, $column, $relativity = 1, $referenceStyle = True, $sheetText = '') {
+		$row = PHPExcel_Calculation_Functions::flattenSingleValue($row);
+		$column = PHPExcel_Calculation_Functions::flattenSingleValue($column);
+		$relativity = PHPExcel_Calculation_Functions::flattenSingleValue($relativity);
+		$sheetText = PHPExcel_Calculation_Functions::flattenSingleValue($sheetText);
 
 		if (($row < 1) || ($column < 1)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 
 		if ($sheetText > '') {
-			if (strpos($sheetText,' ') !== False) { $sheetText = "'".$sheetText."'"; }
-			$sheetText .='!';
+			if (strpos($sheetText, ' ') !== False) { $sheetText = "'".$sheetText."'"; }
+			$sheetText .= '!';
 		}
-		if ((!is_bool($referenceStyle)) || $referenceStyle) {
+		if (( ! is_bool($referenceStyle)) || $referenceStyle) {
 			$rowRelative = $columnRelative = '$';
-			$column = PHPExcel_Cell::stringFromColumnIndex($column-1);
+			$column = PHPExcel_Cell::stringFromColumnIndex($column - 1);
 			if (($relativity == 2) || ($relativity == 4)) { $columnRelative = ''; }
 			if (($relativity == 3) || ($relativity == 4)) { $rowRelative = ''; }
 			return $sheetText.$columnRelative.$column.$rowRelative.$row;
@@ -109,29 +109,29 @@ 
 	 * @param	cellAddress		A reference to a range of cells for which you want the column numbers
 	 * @return	integer or array of integer
 	 */
-	public static function COLUMN($cellAddress=Null) {
+	public static function COLUMN($cellAddress = Null) {
 		if (is_null($cellAddress) || trim($cellAddress) === '') { return 0; }
 
 		if (is_array($cellAddress)) {
-			foreach($cellAddress as $columnKey => $value) {
-				$columnKey = preg_replace('/[^a-z]/i','',$columnKey);
+			foreach ($cellAddress as $columnKey => $value) {
+				$columnKey = preg_replace('/[^a-z]/i', '', $columnKey);
 				return (integer) PHPExcel_Cell::columnIndexFromString($columnKey);
 			}
 		} else {
-			if (strpos($cellAddress,'!') !== false) {
-				list($sheet,$cellAddress) = explode('!',$cellAddress);
+			if (strpos($cellAddress, '!') !== false) {
+				list($sheet, $cellAddress) = explode('!', $cellAddress);
 			}
-			if (strpos($cellAddress,':') !== false) {
-				list($startAddress,$endAddress) = explode(':',$cellAddress);
-				$startAddress = preg_replace('/[^a-z]/i','',$startAddress);
-				$endAddress = preg_replace('/[^a-z]/i','',$endAddress);
+			if (strpos($cellAddress, ':') !== false) {
+				list($startAddress, $endAddress) = explode(':', $cellAddress);
+				$startAddress = preg_replace('/[^a-z]/i', '', $startAddress);
+				$endAddress = preg_replace('/[^a-z]/i', '', $endAddress);
 				$returnValue = array();
 				do {
 					$returnValue[] = (integer) PHPExcel_Cell::columnIndexFromString($startAddress);
 				} while ($startAddress++ != $endAddress);
 				return $returnValue;
 			} else {
-				$cellAddress = preg_replace('/[^a-z]/i','',$cellAddress);
+				$cellAddress = preg_replace('/[^a-z]/i', '', $cellAddress);
 				return (integer) PHPExcel_Cell::columnIndexFromString($cellAddress);
 			}
 		}
@@ -149,17 +149,17 @@ 
 	 * @param	cellAddress		An array or array formula, or a reference to a range of cells for which you want the number of columns
 	 * @return	integer			The number of columns in cellAddress
 	 */
-	public static function COLUMNS($cellAddress=Null) {
+	public static function COLUMNS($cellAddress = Null) {
 		if (is_null($cellAddress) || $cellAddress === '') {
 			return 1;
-		} elseif (!is_array($cellAddress)) {
+		} elseif ( ! is_array($cellAddress)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 
 		$x = array_keys($cellAddress);
 		$x = array_shift($x);
 		$isMatrix = (is_numeric($x));
-		list($columns,$rows) = PHPExcel_Calculation::_getMatrixDimensions($cellAddress);
+		list($columns, $rows) = PHPExcel_Calculation::_getMatrixDimensions($cellAddress);
 
 		if ($isMatrix) {
 			return $rows;
@@ -183,31 +183,31 @@ 
 	 * @param	cellAddress		A reference to a range of cells for which you want the row numbers
 	 * @return	integer or array of integer
 	 */
-	public static function ROW($cellAddress=Null) {
+	public static function ROW($cellAddress = Null) {
 		if (is_null($cellAddress) || trim($cellAddress) === '') { return 0; }
 
 		if (is_array($cellAddress)) {
-			foreach($cellAddress as $columnKey => $rowValue) {
-				foreach($rowValue as $rowKey => $cellValue) {
-					return (integer) preg_replace('/[^0-9]/i','',$rowKey);
+			foreach ($cellAddress as $columnKey => $rowValue) {
+				foreach ($rowValue as $rowKey => $cellValue) {
+					return (integer) preg_replace('/[^0-9]/i', '', $rowKey);
 				}
 			}
 		} else {
-			if (strpos($cellAddress,'!') !== false) {
-				list($sheet,$cellAddress) = explode('!',$cellAddress);
+			if (strpos($cellAddress, '!') !== false) {
+				list($sheet, $cellAddress) = explode('!', $cellAddress);
 			}
-			if (strpos($cellAddress,':') !== false) {
-				list($startAddress,$endAddress) = explode(':',$cellAddress);
-				$startAddress = preg_replace('/[^0-9]/','',$startAddress);
-				$endAddress = preg_replace('/[^0-9]/','',$endAddress);
+			if (strpos($cellAddress, ':') !== false) {
+				list($startAddress, $endAddress) = explode(':', $cellAddress);
+				$startAddress = preg_replace('/[^0-9]/', '', $startAddress);
+				$endAddress = preg_replace('/[^0-9]/', '', $endAddress);
 				$returnValue = array();
 				do {
 					$returnValue[][] = (integer) $startAddress;
 				} while ($startAddress++ != $endAddress);
 				return $returnValue;
 			} else {
-				list($cellAddress) = explode(':',$cellAddress);
-				return (integer) preg_replace('/[^0-9]/','',$cellAddress);
+				list($cellAddress) = explode(':', $cellAddress);
+				return (integer) preg_replace('/[^0-9]/', '', $cellAddress);
 			}
 		}
 	}	//	function ROW()
@@ -224,16 +224,16 @@ 
 	 * @param	cellAddress		An array or array formula, or a reference to a range of cells for which you want the number of rows
 	 * @return	integer			The number of rows in cellAddress
 	 */
-	public static function ROWS($cellAddress=Null) {
+	public static function ROWS($cellAddress = Null) {
 		if (is_null($cellAddress) || $cellAddress === '') {
 			return 1;
-		} elseif (!is_array($cellAddress)) {
+		} elseif ( ! is_array($cellAddress)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 
 		$i = array_keys($cellAddress);
 		$isMatrix = (is_numeric(array_shift($i)));
-		list($columns,$rows) = PHPExcel_Calculation::_getMatrixDimensions($cellAddress);
+		list($columns, $rows) = PHPExcel_Calculation::_getMatrixDimensions($cellAddress);
 
 		if ($isMatrix) {
 			return $columns;
@@ -259,10 +259,10 @@ 
 		$args = func_get_args();
 		$pCell = array_pop($args);
 
-		$linkURL		= (is_null($linkURL))		? '' :	PHPExcel_Calculation_Functions::flattenSingleValue($linkURL);
-		$displayName	= (is_null($displayName))	? '' :	PHPExcel_Calculation_Functions::flattenSingleValue($displayName);
+		$linkURL = (is_null($linkURL)) ? '' : PHPExcel_Calculation_Functions::flattenSingleValue($linkURL);
+		$displayName = (is_null($displayName)) ? '' : PHPExcel_Calculation_Functions::flattenSingleValue($displayName);
 
-		if ((!is_object($pCell)) || (trim($linkURL) == '')) {
+		if (( ! is_object($pCell)) || (trim($linkURL) == '')) {
 			return PHPExcel_Calculation_Functions::REF();
 		}
 
@@ -293,27 +293,27 @@ 
 	 * @todo	Support for the optional a1 parameter introduced in Excel 2010
 	 *
 	 */
-	public static function INDIRECT($cellAddress=Null, PHPExcel_Cell $pCell = null) {
-		$cellAddress	= PHPExcel_Calculation_Functions::flattenSingleValue($cellAddress);
+	public static function INDIRECT($cellAddress = Null, PHPExcel_Cell $pCell = null) {
+		$cellAddress = PHPExcel_Calculation_Functions::flattenSingleValue($cellAddress);
 		if (is_null($cellAddress) || $cellAddress === '') {
 			return PHPExcel_Calculation_Functions::REF();
 		}
 
 		$cellAddress1 = $cellAddress;
 		$cellAddress2 = NULL;
-		if (strpos($cellAddress,':') !== false) {
-			list($cellAddress1,$cellAddress2) = explode(':',$cellAddress);
+		if (strpos($cellAddress, ':') !== false) {
+			list($cellAddress1, $cellAddress2) = explode(':', $cellAddress);
 		}
 
-		if ((!preg_match('/^'.PHPExcel_Calculation::CALCULATION_REGEXP_CELLREF.'$/i', $cellAddress1, $matches)) ||
-			((!is_null($cellAddress2)) && (!preg_match('/^'.PHPExcel_Calculation::CALCULATION_REGEXP_CELLREF.'$/i', $cellAddress2, $matches)))) {
+		if (( ! preg_match('/^'.PHPExcel_Calculation::CALCULATION_REGEXP_CELLREF.'$/i', $cellAddress1, $matches)) ||
+			(( ! is_null($cellAddress2)) && ( ! preg_match('/^'.PHPExcel_Calculation::CALCULATION_REGEXP_CELLREF.'$/i', $cellAddress2, $matches)))) {
 
-			if (!preg_match('/^'.PHPExcel_Calculation::CALCULATION_REGEXP_NAMEDRANGE.'$/i', $cellAddress1, $matches)) {
+			if ( ! preg_match('/^'.PHPExcel_Calculation::CALCULATION_REGEXP_NAMEDRANGE.'$/i', $cellAddress1, $matches)) {
 				return PHPExcel_Calculation_Functions::REF();
 			}
 
-			if (strpos($cellAddress,'!') !== false) {
-				list($sheetName,$cellAddress) = explode('!',$cellAddress);
+			if (strpos($cellAddress, '!') !== false) {
+				list($sheetName, $cellAddress) = explode('!', $cellAddress);
 				$pSheet = $pCell->getParent()->getParent()->getSheetByName($sheetName);
 			} else {
 				$pSheet = $pCell->getParent();
@@ -322,8 +322,8 @@ 
 			return PHPExcel_Calculation::getInstance()->extractNamedRange($cellAddress, $pSheet, False);
 		}
 
-		if (strpos($cellAddress,'!') !== false) {
-			list($sheetName,$cellAddress) = explode('!',$cellAddress);
+		if (strpos($cellAddress, '!') !== false) {
+			list($sheetName, $cellAddress) = explode('!', $cellAddress);
 			$pSheet = $pCell->getParent()->getParent()->getSheetByName($sheetName);
 		} else {
 			$pSheet = $pCell->getParent();
@@ -358,32 +358,32 @@ 
 	 * @param	width			The width, in number of columns, that you want the returned reference to be. Width must be a positive number.
 	 * @return	string			A reference to a cell or range of cells
 	 */
-	public static function OFFSET($cellAddress=Null,$rows=0,$columns=0,$height=null,$width=null) {
-		$rows		= PHPExcel_Calculation_Functions::flattenSingleValue($rows);
+	public static function OFFSET($cellAddress = Null, $rows = 0, $columns = 0, $height = null, $width = null) {
+		$rows = PHPExcel_Calculation_Functions::flattenSingleValue($rows);
 		$columns	= PHPExcel_Calculation_Functions::flattenSingleValue($columns);
 		$height		= PHPExcel_Calculation_Functions::flattenSingleValue($height);
-		$width		= PHPExcel_Calculation_Functions::flattenSingleValue($width);
+		$width = PHPExcel_Calculation_Functions::flattenSingleValue($width);
 		if ($cellAddress == Null) {
 			return 0;
 		}
 
 		$args = func_get_args();
 		$pCell = array_pop($args);
-		if (!is_object($pCell)) {
+		if ( ! is_object($pCell)) {
 			return PHPExcel_Calculation_Functions::REF();
 		}
 
 		$sheetName = null;
-		if (strpos($cellAddress,"!")) {
-			list($sheetName,$cellAddress) = explode("!",$cellAddress);
+		if (strpos($cellAddress, "!")) {
+			list($sheetName, $cellAddress) = explode("!", $cellAddress);
 		}
-		if (strpos($cellAddress,":")) {
-			list($startCell,$endCell) = explode(":",$cellAddress);
+		if (strpos($cellAddress, ":")) {
+			list($startCell, $endCell) = explode(":", $cellAddress);
 		} else {
 			$startCell = $endCell = $cellAddress;
 		}
-		list($startCellColumn,$startCellRow) = PHPExcel_Cell::coordinateFromString($startCell);
-		list($endCellColumn,$endCellRow) = PHPExcel_Cell::coordinateFromString($endCell);
+		list($startCellColumn, $startCellRow) = PHPExcel_Cell::coordinateFromString($startCell);
+		list($endCellColumn, $endCellRow) = PHPExcel_Cell::coordinateFromString($endCell);
 
 		$startCellRow += $rows;
 		$startCellColumn = PHPExcel_Cell::columnIndexFromString($startCellColumn) - 1;
@@ -393,14 +393,14 @@ 
 			return PHPExcel_Calculation_Functions::REF();
 		}
 		$endCellColumn = PHPExcel_Cell::columnIndexFromString($endCellColumn) - 1;
-		if (($width != null) && (!is_object($width))) {
+		if (($width != null) && ( ! is_object($width))) {
 			$endCellColumn = $startCellColumn + $width - 1;
 		} else {
 			$endCellColumn += $columns;
 		}
 		$startCellColumn = PHPExcel_Cell::stringFromColumnIndex($startCellColumn);
 
-		if (($height != null) && (!is_object($height))) {
+		if (($height != null) && ( ! is_object($height))) {
 			$endCellRow = $startCellRow + $height - 1;
 		} else {
 			$endCellRow += $rows;
@@ -449,10 +449,10 @@ 
 		$chosenEntry = PHPExcel_Calculation_Functions::flattenArray(array_shift($chooseArgs));
 		$entryCount = count($chooseArgs) - 1;
 
-		if(is_array($chosenEntry)) {
+		if (is_array($chosenEntry)) {
 			$chosenEntry = array_shift($chosenEntry);
 		}
-		if ((is_numeric($chosenEntry)) && (!is_bool($chosenEntry))) {
+		if ((is_numeric($chosenEntry)) && ( ! is_bool($chosenEntry))) {
 			--$chosenEntry;
 		} else {
 			return PHPExcel_Calculation_Functions::VALUE();
@@ -483,15 +483,15 @@ 
 	 * @param	match_type		The number -1, 0, or 1. -1 means above, 0 means exact match, 1 means below. If match_type is 1 or -1, the list has to be ordered.
 	 * @return	integer			The relative position of the found item
 	 */
-	public static function MATCH($lookup_value, $lookup_array, $match_type=1) {
+	public static function MATCH($lookup_value, $lookup_array, $match_type = 1) {
 		$lookup_array = PHPExcel_Calculation_Functions::flattenArray($lookup_array);
 		$lookup_value = PHPExcel_Calculation_Functions::flattenSingleValue($lookup_value);
-		$match_type	= (is_null($match_type)) ? 1 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($match_type);
+		$match_type = (is_null($match_type)) ? 1 : (int) PHPExcel_Calculation_Functions::flattenSingleValue($match_type);
 		//	MATCH is not case sensitive
 		$lookup_value = strtolower($lookup_value);
 
 		//	lookup_value type has to be number, text, or logical values
-		if ((!is_numeric($lookup_value)) && (!is_string($lookup_value)) && (!is_bool($lookup_value))) {
+		if (( ! is_numeric($lookup_value)) && ( ! is_string($lookup_value)) && ( ! is_bool($lookup_value))) {
 			return PHPExcel_Calculation_Functions::NA();
 		}
 
@@ -507,10 +507,10 @@ 
 		}
 
 		//	lookup_array should contain only number, text, or logical values, or empty (null) cells
-		foreach($lookup_array as $i => $lookupArrayValue) {
+		foreach ($lookup_array as $i => $lookupArrayValue) {
 			//	check the type of the value
-			if ((!is_numeric($lookupArrayValue)) && (!is_string($lookupArrayValue)) &&
-				(!is_bool($lookupArrayValue)) && (!is_null($lookupArrayValue))) {
+			if (( ! is_numeric($lookupArrayValue)) && ( ! is_string($lookupArrayValue)) &&
+				( ! is_bool($lookupArrayValue)) && ( ! is_null($lookupArrayValue))) {
 				return PHPExcel_Calculation_Functions::NA();
 			}
 			//	convert strings to lowercase for case-insensitive testing
@@ -518,7 +518,7 @@ 
 				$lookup_array[$i] = strtolower($lookupArrayValue);
 			}
 			if ((is_null($lookupArrayValue)) && (($match_type == 1) || ($match_type == -1))) {
-				$lookup_array = array_slice($lookup_array,0,$i-1);
+				$lookup_array = array_slice($lookup_array, 0, $i - 1);
 			}
 		}
 
@@ -526,7 +526,7 @@ 
 		if ($match_type == 1) {
 			asort($lookup_array);
 			$keySet = array_keys($lookup_array);
-		} elseif($match_type == -1) {
+		} elseif ($match_type == -1) {
 			arsort($lookup_array);
 			$keySet = array_keys($lookup_array);
 		}
@@ -537,7 +537,7 @@ 
 		// loop on the cells
 //		var_dump($lookup_array);
 //		echo '<br />';
-		foreach($lookup_array as $i => $lookupArrayValue) {
+		foreach ($lookup_array as $i => $lookupArrayValue) {
 			if (($match_type == 0) && ($lookupArrayValue == $lookup_value)) {
 				//	exact match
 				return ++$i;
@@ -548,15 +548,15 @@ 
 //				echo 'Keyset = ';
 //				var_dump($keySet);
 //				echo '<br />';
-				$i = array_search($i,$keySet);
+				$i = array_search($i, $keySet);
 //				echo '$i='.$i.'<br />';
 				// if match_type is -1 <=> find the smallest value that is greater than or equal to lookup_value
-				if ($i < 1){
+				if ($i < 1) {
 					// 1st cell was allready smaller than the lookup_value
 					break;
 				} else {
 					// the previous cell was the match
-					return $keySet[$i-1]+1;
+					return $keySet[$i - 1] + 1;
 				}
 			} elseif (($match_type == 1) && ($lookupArrayValue >= $lookup_value)) {
 //				echo '$i = '.$i.' => ';
@@ -565,15 +565,15 @@ 
 //				echo 'Keyset = ';
 //				var_dump($keySet);
 //				echo '<br />';
-				$i = array_search($i,$keySet);
+				$i = array_search($i, $keySet);
 //				echo '$i='.$i.'<br />';
 				// if match_type is 1 <=> find the largest value that is less than or equal to lookup_value
-				if ($i < 1){
+				if ($i < 1) {
 					// 1st cell was allready bigger than the lookup_value
 					break;
 				} else {
 					// the previous cell was the match
-					return $keySet[$i-1]+1;
+					return $keySet[$i - 1] + 1;
 				}
 			}
 		}
@@ -596,13 +596,13 @@ 
 	 * @param	column_num		The column in array from which to return a value. If column_num is omitted, row_num is required.
 	 * @return	mixed			the value of a specified cell or array of cells
 	 */
-	public static function INDEX($arrayValues,$rowNum = 0,$columnNum = 0) {
+	public static function INDEX($arrayValues, $rowNum = 0, $columnNum = 0) {
 
 		if (($rowNum < 0) || ($columnNum < 0)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 
-		if (!is_array($arrayValues)) {
+		if ( ! is_array($arrayValues)) {
 			return PHPExcel_Calculation_Functions::REF();
 		}
 
@@ -617,7 +617,7 @@ 
 			}
 			$rowNum = $rowKeys[--$rowNum];
 			$returnArray = array();
-			foreach($arrayValues as $arrayColumn) {
+			foreach ($arrayValues as $arrayColumn) {
 				if (is_array($arrayColumn)) {
 					if (isset($arrayColumn[$rowNum])) {
 						$returnArray[] = $arrayColumn[$rowNum];
@@ -652,12 +652,12 @@ 
 	 */
 	public static function TRANSPOSE($matrixData) {
 		$returnMatrix = array();
-		if (!is_array($matrixData)) { $matrixData = array(array($matrixData)); }
+		if ( ! is_array($matrixData)) { $matrixData = array(array($matrixData)); }
 
 		$column = 0;
-		foreach($matrixData as $matrixRow) {
+		foreach ($matrixData as $matrixRow) {
 			$row = 0;
-			foreach($matrixRow as $matrixCell) {
+			foreach ($matrixRow as $matrixCell) {
 				$returnMatrix[$row][$column] = $matrixCell;
 				++$row;
 			}
@@ -667,7 +667,7 @@ 
 	}	//	function TRANSPOSE()
 
 
-	private static function _vlookupSort($a,$b) {
+	private static function _vlookupSort($a, $b) {
 		$f = array_keys($a);
 		$firstColumn = array_shift($f);
 		if (strtolower($a[$firstColumn]) == strtolower($b[$firstColumn])) {
@@ -686,10 +686,10 @@ 
 	* @param	not_exact_match	Determines if you are looking for an exact match based on lookup_value.
 	* @return	mixed			The value of the found cell
 	*/
-	public static function VLOOKUP($lookup_value, $lookup_array, $index_number, $not_exact_match=true) {
+	public static function VLOOKUP($lookup_value, $lookup_array, $index_number, $not_exact_match = true) {
 		$lookup_value	= PHPExcel_Calculation_Functions::flattenSingleValue($lookup_value);
 		$index_number	= PHPExcel_Calculation_Functions::flattenSingleValue($index_number);
-		$not_exact_match	= PHPExcel_Calculation_Functions::flattenSingleValue($not_exact_match);
+		$not_exact_match = PHPExcel_Calculation_Functions::flattenSingleValue($not_exact_match);
 
 		// index_number must be greater than or equal to 1
 		if ($index_number < 1) {
@@ -697,12 +697,12 @@ 
 		}
 
 		// index_number must be less than or equal to the number of columns in lookup_array
-		if ((!is_array($lookup_array)) || (empty($lookup_array))) {
+		if (( ! is_array($lookup_array)) || (empty($lookup_array))) {
 			return PHPExcel_Calculation_Functions::REF();
 		} else {
 			$f = array_keys($lookup_array);
 			$firstRow = array_pop($f);
-			if ((!is_array($lookup_array[$firstRow])) || ($index_number > count($lookup_array[$firstRow]))) {
+			if (( ! is_array($lookup_array[$firstRow])) || ($index_number > count($lookup_array[$firstRow]))) {
 				return PHPExcel_Calculation_Functions::REF();
 			} else {
 				$columnKeys = array_keys($lookup_array[$firstRow]);
@@ -711,12 +711,12 @@ 
 			}
 		}
 
-		if (!$not_exact_match) {
-			uasort($lookup_array,array('self','_vlookupSort'));
+		if ( ! $not_exact_match) {
+			uasort($lookup_array, array('self', '_vlookupSort'));
 		}
 
 		$rowNumber = $rowValue = False;
-		foreach($lookup_array as $rowKey => $rowData) {
+		foreach ($lookup_array as $rowKey => $rowData) {
 			if (strtolower($rowData[$firstColumn]) > strtolower($lookup_value)) {
 				break;
 			}
@@ -725,7 +725,7 @@ 
 		}
 
 		if ($rowNumber !== false) {
-			if ((!$not_exact_match) && ($rowValue != $lookup_value)) {
+			if (( ! $not_exact_match) && ($rowValue != $lookup_value)) {
 				//	if an exact match is required, we have what we need to return an appropriate response
 				return PHPExcel_Calculation_Functions::NA();
 			} else {
@@ -746,10 +746,10 @@ 
 	 * @param	result_vector	The column from which the matching value must be returned
 	 * @return	mixed			The value of the found cell
 	 */
-	public static function LOOKUP($lookup_value, $lookup_vector, $result_vector=null) {
-		$lookup_value	= PHPExcel_Calculation_Functions::flattenSingleValue($lookup_value);
+	public static function LOOKUP($lookup_value, $lookup_vector, $result_vector = null) {
+		$lookup_value = PHPExcel_Calculation_Functions::flattenSingleValue($lookup_value);
 
-		if (!is_array($lookup_vector)) {
+		if ( ! is_array($lookup_vector)) {
 			return PHPExcel_Calculation_Functions::NA();
 		}
 		$lookupRows = count($lookup_vector);
@@ -782,7 +782,7 @@ 
 			$lookup_vector = array_shift($lookup_vector);
 		}
 		if ($lookupColumns != 2) {
-			foreach($lookup_vector as &$value) {
+			foreach ($lookup_vector as &$value) {
 				if (is_array($value)) {
 					$k = array_keys($value);
 					$key1 = $key2 = array_shift($k);
@@ -802,7 +802,7 @@ 
 			unset($value);
 		}
 
-		return self::VLOOKUP($lookup_value,$lookup_vector,2);
+		return self::VLOOKUP($lookup_value, $lookup_vector, 2);
  	}	//	function LOOKUP()
 
 }	//	class PHPExcel_Calculation_LookupRef

app/Vendor/PHPExcel/PHPExcel/Calculation/MathTrig.php

Doc Comments +10 added lines, -19 removed lines

@@ -70,6 +70,10 @@ 
 	}	//	function _factors()
 
 
+	/**
+	 * @param integer $num
+	 * @param integer $n
+	 */
 	private static function _romanCut($num, $n) {
 		return ($num - ($num % $n ) ) / $n;
 	}	//	function _romanCut()
@@ -423,8 +427,7 @@ 
 	 *
 	 * @access	public
 	 * @category Mathematical and Trigonometric Functions
-	 * @param	float	$value		The positive real number for which you want the logarithm
-	 * @param	float	$base		The base of the logarithm. If base is omitted, it is assumed to be 10.
+	 * @param	integer	$base		The base of the logarithm. If base is omitted, it is assumed to be 10.
 	 * @return	float
 	 */
 	public static function LOG_BASE($number = NULL, $base=10) {
@@ -681,8 +684,8 @@ 
 	 *
 	 * Computes x raised to the power y.
 	 *
-	 * @param	float		$x
-	 * @param	float		$y
+	 * @param	integer		$x
+	 * @param	integer		$y
 	 * @return	float
 	 */
 	public static function POWER($x = 0, $y = 2) {
@@ -712,7 +715,6 @@ 
 	 *
 	 * @access	public
 	 * @category Mathematical and Trigonometric Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function PRODUCT() {
@@ -750,8 +752,7 @@ 
 	 *
 	 * @access	public
 	 * @category Mathematical and Trigonometric Functions
-	 * @param	mixed		$arg,...		Data values
-	 * @return	float
+	 * @return	integer
 	 */
 	public static function QUOTIENT() {
 		// Return value
@@ -881,9 +882,6 @@ 
 	 *
 	 * Returns the sum of a power series
 	 *
-	 * @param	float			$x	Input value to the power series
-	 * @param	float			$n	Initial power to which you want to raise $x
-	 * @param	float			$m	Step by which to increase $n for each term in the series
 	 * @param	array of mixed		Data Series
 	 * @return	float
 	 */
@@ -1028,7 +1026,6 @@ 
 	 *
 	 * @access	public
 	 * @category Mathematical and Trigonometric Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function SUM() {
@@ -1058,9 +1055,8 @@ 
 	 *
 	 * @access	public
 	 * @category Mathematical and Trigonometric Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @param	string		$condition		The criteria that defines which cells will be summed.
-	 * @return	float
+	 * @return	integer
 	 */
 	public static function SUMIF($aArgs,$condition,$sumArgs = array()) {
 		// Return value
@@ -1095,7 +1091,6 @@ 
 	 *
 	 * @access	public
 	 * @category Mathematical and Trigonometric Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function SUMPRODUCT() {
@@ -1139,7 +1134,6 @@ 
 	 *
 	 * @access	public
 	 * @category Mathematical and Trigonometric Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function SUMSQ() {
@@ -1162,7 +1156,6 @@ 
 	/**
 	 * SUMX2MY2
 	 *
-	 * @param	mixed	$value	Value to check
 	 * @return	float
 	 */
 	public static function SUMX2MY2($matrixData1,$matrixData2) {
@@ -1191,7 +1184,6 @@ 
 	/**
 	 * SUMX2PY2
 	 *
-	 * @param	mixed	$value	Value to check
 	 * @return	float
 	 */
 	public static function SUMX2PY2($matrixData1,$matrixData2) {
@@ -1220,7 +1212,6 @@ 
 	/**
 	 * SUMXMY2
 	 *
-	 * @param	mixed	$value	Value to check
 	 * @return	float
 	 */
 	public static function SUMXMY2($matrixData1,$matrixData2) {
@@ -1251,7 +1242,7 @@ 
 	 *
 	 * Truncates value to the number of fractional digits by number_digits.
 	 *
-	 * @param	float		$value
+	 * @param	integer		$value
 	 * @param	int			$digits
 	 * @return	float		Truncated value
 	 */

app/Vendor/PHPExcel/PHPExcel/Calculation/Statistical.php

Doc Comments +4 added lines, -46 removed lines

@@ -144,7 +144,7 @@ 
 	 *
 	 * @param p require p>0
 	 * @param q require q>0
-	 * @return 0 if p<=0, q<=0 or p+q>2.55E305 to avoid errors and over/underflow
+	 * @return double if p<=0, q<=0 or p+q>2.55E305 to avoid errors and over/underflow
 	 * @author Jaco van Kooten
 	 */
 	private static function _logBeta($p, $q) {
@@ -165,6 +165,8 @@ 
 	 * Evaluates of continued fraction part of incomplete beta function.
 	 * Based on an idea from Numerical Recipes (W.H. Press et al, 1992).
 	 * @author Jaco van Kooten
+	 * @param double $p
+	 * @param double $q
 	 */
 	private static function _betaFraction($x, $p, $q) {
 		$c = 1.0;
@@ -694,7 +696,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function AVEDEV() {
@@ -742,7 +743,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function AVERAGE() {
@@ -784,7 +784,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function AVERAGEA() {
@@ -832,7 +831,6 @@ 
 	 *
 	 * @access	public
 	 * @category Mathematical and Trigonometric Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @param	string		$condition		The criteria that defines which cells will be checked.
 	 * @return	float
 	 */
@@ -876,7 +874,6 @@ 
 	 * @param	float		$value			Value at which you want to evaluate the distribution
 	 * @param	float		$alpha			Parameter to the distribution
 	 * @param	float		$beta			Parameter to the distribution
-	 * @param	boolean		$cumulative
 	 * @return	float
 	 *
 	 */
@@ -912,7 +909,6 @@ 
 	 * @param	float		$probability	Probability at which you want to evaluate the distribution
 	 * @param	float		$alpha			Parameter to the distribution
 	 * @param	float		$beta			Parameter to the distribution
-	 * @param	boolean		$cumulative
 	 * @return	float
 	 *
 	 */
@@ -1156,7 +1152,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	int
 	 */
 	public static function COUNT() {
@@ -1191,7 +1186,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	int
 	 */
 	public static function COUNTA() {
@@ -1222,7 +1216,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	int
 	 */
 	public static function COUNTBLANK() {
@@ -1253,7 +1246,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @param	string		$condition		The criteria that defines which cells will be counted.
 	 * @return	int
 	 */
@@ -1425,7 +1417,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function DEVSQ() {
@@ -1700,7 +1691,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function GEOMEAN() {
@@ -1759,7 +1749,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function HARMEAN() {
@@ -1911,8 +1900,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
-	 * @param	int			$entry			Position (ordered from the largest) in the array or range of data to return
 	 * @return	float
 	 *
 	 */
@@ -2059,7 +2046,6 @@ 
 	 *
 	 * Returns the inverse of the normal cumulative distribution
 	 *
-	 * @param	float		$value
 	 * @return	float
 	 *
 	 * @todo	Try implementing P J Acklam's refinement algorithm for greater
@@ -2116,7 +2102,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function MAX() {
@@ -2152,7 +2137,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function MAXA() {
@@ -2193,7 +2177,6 @@ 
 	 *
 	 * @access	public
 	 * @category Mathematical and Trigonometric Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @param	string		$condition		The criteria that defines which cells will be checked.
 	 * @return	float
 	 */
@@ -2233,7 +2216,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function MEDIAN() {
@@ -2278,7 +2260,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function MIN() {
@@ -2314,7 +2295,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function MINA() {
@@ -2355,7 +2335,6 @@ 
 	 *
 	 * @access	public
 	 * @category Mathematical and Trigonometric Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @param	string		$condition		The criteria that defines which cells will be checked.
 	 * @return	float
 	 */
@@ -2429,7 +2408,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function MODE() {
@@ -2534,9 +2512,9 @@ 
 	 *
 	 * Returns the inverse of the normal cumulative distribution for the specified mean and standard deviation.
 	 *
-	 * @param	float		$value
 	 * @param	float		$mean		Mean Value
 	 * @param	float		$stdDev		Standard Deviation
+	 * @param double $probability
 	 * @return	float
 	 *
 	 */
@@ -2598,8 +2576,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
-	 * @param	float		$entry			Percentile value in the range 0..1, inclusive.
 	 * @return	float
 	 */
 	public static function PERCENTILE() {
@@ -2759,8 +2735,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
-	 * @param	int			$entry			Quartile value in the range 1..3, inclusive.
 	 * @return	float
 	 */
 	public static function QUARTILE() {
@@ -2918,8 +2892,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
-	 * @param	int			$entry			Position (ordered from the smallest) in the array or range of data to return
 	 * @return	float
 	 */
 	public static function SMALL() {
@@ -2984,7 +2956,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function STDEV() {
@@ -3031,7 +3002,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function STDEVA() {
@@ -3083,7 +3053,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function STDEVP() {
@@ -3130,7 +3099,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function STDEVPA() {
@@ -3358,8 +3326,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
-	 * @param	float		$discard		Percentage to discard
 	 * @return	float
 	 */
 	public static function TRIMMEAN() {
@@ -3401,7 +3367,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function VARFunc() {
@@ -3443,7 +3408,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function VARA() {
@@ -3496,7 +3460,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function VARP() {
@@ -3538,7 +3501,6 @@ 
 	 *
 	 * @access	public
 	 * @category Statistical Functions
-	 * @param	mixed		$arg,...		Data values
 	 * @return	float
 	 */
 	public static function VARPA() {
@@ -3621,10 +3583,6 @@ 
 	 * Returns the Weibull distribution. Use this distribution in reliability
 	 * analysis, such as calculating a device's mean time to failure.
 	 *
-	 * @param	float		$value
-	 * @param	float		$alpha		Alpha Parameter
-	 * @param	float		$beta		Beta Parameter
-	 * @param	boolean		$cumulative
 	 * @return	float
 	 *
 	 */

Spacing +287 added lines, -287 removed lines

@@ -27,16 +27,16 @@ 
 
 
 /** PHPExcel root directory */
-if (!defined('PHPEXCEL_ROOT')) {
+if ( ! defined('PHPEXCEL_ROOT')) {
 	/**
 	 * @ignore
 	 */
-	define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
-	require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+	define('PHPEXCEL_ROOT', dirname(__FILE__).'/../../');
+	require(PHPEXCEL_ROOT.'PHPExcel/Autoloader.php');
 }
 
 
-require_once PHPEXCEL_ROOT . 'PHPExcel/Shared/trend/trendClass.php';
+require_once PHPEXCEL_ROOT.'PHPExcel/Shared/trend/trendClass.php';
 
 
 /** LOG_GAMMA_X_MAX_VALUE */
@@ -62,19 +62,19 @@ 
 class PHPExcel_Calculation_Statistical {
 
 
-	private static function _checkTrendArrays(&$array1,&$array2) {
-		if (!is_array($array1)) { $array1 = array($array1); }
-		if (!is_array($array2)) { $array2 = array($array2); }
+	private static function _checkTrendArrays(&$array1, &$array2) {
+		if ( ! is_array($array1)) { $array1 = array($array1); }
+		if ( ! is_array($array2)) { $array2 = array($array2); }
 
 		$array1 = PHPExcel_Calculation_Functions::flattenArray($array1);
 		$array2 = PHPExcel_Calculation_Functions::flattenArray($array2);
-		foreach($array1 as $key => $value) {
+		foreach ($array1 as $key => $value) {
 			if ((is_bool($value)) || (is_string($value)) || (is_null($value))) {
 				unset($array1[$key]);
 				unset($array2[$key]);
 			}
 		}
-		foreach($array2 as $key => $value) {
+		foreach ($array2 as $key => $value) {
 			if ((is_bool($value)) || (is_string($value)) || (is_null($value))) {
 				unset($array1[$key]);
 				unset($array2[$key]);
@@ -137,7 +137,7 @@ 
 	// Function cache for _logBeta function
 	private static $_logBetaCache_p			= 0.0;
 	private static $_logBetaCache_q			= 0.0;
-	private static $_logBetaCache_result	= 0.0;
+	private static $_logBetaCache_result = 0.0;
 
 	/**
 	 * The natural logarithm of the beta function.
@@ -177,12 +177,12 @@ 
 		}
 		$h = 1.0 / $h;
 		$frac = $h;
-		$m	 = 1;
+		$m = 1;
 		$delta = 0.0;
-		while ($m <= MAX_ITERATIONS && abs($delta-1.0) > PRECISION ) {
+		while ($m <= MAX_ITERATIONS && abs($delta - 1.0) > PRECISION) {
 			$m2 = 2 * $m;
 			// even index for d
-			$d = $m * ($q - $m) * $x / ( ($p_minus + $m2) * ($p + $m2));
+			$d = $m * ($q - $m) * $x / (($p_minus + $m2) * ($p + $m2));
 			$h = 1.0 + $d * $h;
 			if (abs($h) < XMININ) {
 				$h = XMININ;
@@ -256,8 +256,8 @@ 
 	 */
 
 	// Function cache for logGamma
-	private static $_logGammaCache_result	= 0.0;
-	private static $_logGammaCache_x		= 0.0;
+	private static $_logGammaCache_result = 0.0;
+	private static $_logGammaCache_x = 0.0;
 
 	private static function _logGamma($x) {
 		// Log Gamma related constants
@@ -265,57 +265,57 @@ 
 		static $lg_d2 = 0.4227843350984671393993777;
 		static $lg_d4 = 1.791759469228055000094023;
 
-		static $lg_p1 = array(	4.945235359296727046734888,
+		static $lg_p1 = array(4.945235359296727046734888,
 								201.8112620856775083915565,
 								2290.838373831346393026739,
 								11319.67205903380828685045,
 								28557.24635671635335736389,
 								38484.96228443793359990269,
 								26377.48787624195437963534,
-								7225.813979700288197698961 );
-		static $lg_p2 = array(	4.974607845568932035012064,
+								7225.813979700288197698961);
+		static $lg_p2 = array(4.974607845568932035012064,
 								542.4138599891070494101986,
 								15506.93864978364947665077,
 								184793.2904445632425417223,
 								1088204.76946882876749847,
 								3338152.967987029735917223,
 								5106661.678927352456275255,
-								3074109.054850539556250927 );
-		static $lg_p4 = array(	14745.02166059939948905062,
+								3074109.054850539556250927);
+		static $lg_p4 = array(14745.02166059939948905062,
 								2426813.369486704502836312,
 								121475557.4045093227939592,
 								2663432449.630976949898078,
 								29403789566.34553899906876,
 								170266573776.5398868392998,
 								492612579337.743088758812,
-								560625185622.3951465078242 );
+								560625185622.3951465078242);
 
-		static $lg_q1 = array(	67.48212550303777196073036,
+		static $lg_q1 = array(67.48212550303777196073036,
 								1113.332393857199323513008,
 								7738.757056935398733233834,
 								27639.87074403340708898585,
 								54993.10206226157329794414,
 								61611.22180066002127833352,
 								36351.27591501940507276287,
-								8785.536302431013170870835 );
-		static $lg_q2 = array(	183.0328399370592604055942,
+								8785.536302431013170870835);
+		static $lg_q2 = array(183.0328399370592604055942,
 								7765.049321445005871323047,
 								133190.3827966074194402448,
 								1136705.821321969608938755,
 								5267964.117437946917577538,
 								13467014.54311101692290052,
 								17827365.30353274213975932,
-								9533095.591844353613395747 );
-		static $lg_q4 = array(	2690.530175870899333379843,
+								9533095.591844353613395747);
+		static $lg_q4 = array(2690.530175870899333379843,
 								639388.5654300092398984238,
 								41355999.30241388052042842,
 								1120872109.61614794137657,
 								14886137286.78813811542398,
 								101680358627.2438228077304,
 								341747634550.7377132798597,
-								446315818741.9713286462081 );
+								446315818741.9713286462081);
 
-		static $lg_c  = array(	-0.001910444077728,
+		static $lg_c = array(	-0.001910444077728,
 								8.4171387781295e-4,
 								-5.952379913043012e-4,
 								7.93650793500350248e-4,
@@ -325,7 +325,7 @@ 
 
 	// Rough estimate of the fourth root of logGamma_xBig
 	static $lg_frtbig = 2.25e76;
-	static $pnt68	 = 0.6796875;
+	static $pnt68 = 0.6796875;
 
 
 	if ($x == self::$_logGammaCache_x) {
@@ -422,17 +422,17 @@ 
 	//
 	//	Private implementation of the incomplete Gamma function
 	//
-	private static function _incompleteGamma($a,$x) {
+	private static function _incompleteGamma($a, $x) {
 		static $max = 32;
 		$summer = 0;
-		for ($n=0; $n<=$max; ++$n) {
+		for ($n = 0; $n <= $max; ++$n) {
 			$divisor = $a;
-			for ($i=1; $i<=$n; ++$i) {
+			for ($i = 1; $i <= $n; ++$i) {
 				$divisor *= ($a + $i);
 			}
-			$summer += (pow($x,$n) / $divisor);
+			$summer += (pow($x, $n) / $divisor);
 		}
-		return pow($x,$a) * exp(0-$x) * $summer;
+		return pow($x, $a) * exp(0 - $x) * $summer;
 	}	//	function _incompleteGamma()
 
 
@@ -443,7 +443,7 @@ 
 		if ($data == 0.0) return 0;
 
 		static $p0 = 1.000000000190015;
-		static $p = array ( 1 => 76.18009172947146,
+		static $p = array(1 => 76.18009172947146,
 							2 => -86.50532032941677,
 							3 => 24.01409824083091,
 							4 => -1.231739572450155,
@@ -456,7 +456,7 @@ 
 		$tmp -= ($x + 0.5) * log($tmp);
 
 		$summer = $p0;
-		for ($j=1;$j<=6;++$j) {
+		for ($j = 1; $j <= 6; ++$j) {
 			$summer += ($p[$j] / ++$y);
 		}
 		return exp(0 - $tmp + log(SQRT2PI * $summer / $x));
@@ -485,7 +485,7 @@ 
 		//	Input paramater is $p - probability - where 0 < p < 1.
 
 		//	Coefficients in rational approximations
-		static $a = array(	1 => -3.969683028665376e+01,
+		static $a = array(1 => -3.969683028665376e+01,
 							2 => 2.209460984245205e+02,
 							3 => -2.759285104469687e+02,
 							4 => 1.383577518672690e+02,
@@ -493,14 +493,14 @@ 
 							6 => 2.506628277459239e+00
 						 );
 
-		static $b = array(	1 => -5.447609879822406e+01,
+		static $b = array(1 => -5.447609879822406e+01,
 							2 => 1.615858368580409e+02,
 							3 => -1.556989798598866e+02,
 							4 => 6.680131188771972e+01,
 							5 => -1.328068155288572e+01
 						 );
 
-		static $c = array(	1 => -7.784894002430293e-03,
+		static $c = array(1 => -7.784894002430293e-03,
 							2 => -3.223964580411365e-01,
 							3 => -2.400758277161838e+00,
 							4 => -2.549732539343734e+00,
@@ -508,15 +508,15 @@ 
 							6 => 2.938163982698783e+00
 						 );
 
-		static $d = array(	1 => 7.784695709041462e-03,
+		static $d = array(1 => 7.784695709041462e-03,
 							2 => 3.224671290700398e-01,
 							3 => 2.445134137142996e+00,
 							4 => 3.754408661907416e+00
 						 );
 
 		//	Define lower and upper region break-points.
-		$p_low = 0.02425;			//Use lower region approx. below this
-		$p_high = 1 - $p_low;		//Use upper region approx. above this
+		$p_low = 0.02425; //Use lower region approx. below this
+		$p_high = 1 - $p_low; //Use upper region approx. above this
 
 		if (0 < $p && $p < $p_low) {
 			//	Rational approximation for lower region.
@@ -662,7 +662,7 @@ 
 			} else {
 				$R = 1 - $p;
 			}
-			$R = pow(-log($R),2);
+			$R = pow(-log($R), 2);
 
 			//	computation for p not close to 0, 0.5 or 1.
 			If ($R <= $split2) {
@@ -708,11 +708,11 @@ 
 			$aCount = 0;
 			foreach ($aArgs as $k => $arg) {
 				if ((is_bool($arg)) &&
-					((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
+					(( ! PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
 					$arg = (integer) $arg;
 				}
 				// Is it a numeric value?
-				if ((is_numeric($arg)) && (!is_string($arg))) {
+				if ((is_numeric($arg)) && ( ! is_string($arg))) {
 					if (is_null($returnValue)) {
 						$returnValue = abs($arg - $aMean);
 					} else {
@@ -751,11 +751,11 @@ 
 		// Loop through arguments
 		foreach (PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()) as $k => $arg) {
 			if ((is_bool($arg)) &&
-				((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
+				(( ! PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
 				$arg = (integer) $arg;
 			}
 			// Is it a numeric value?
-			if ((is_numeric($arg)) && (!is_string($arg))) {
+			if ((is_numeric($arg)) && ( ! is_string($arg))) {
 				if (is_null($returnValue)) {
 					$returnValue = $arg;
 				} else {
@@ -795,7 +795,7 @@ 
 		// Loop through arguments
 		foreach (PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args()) as $k => $arg) {
 			if ((is_bool($arg)) &&
-				(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
+				( ! PHPExcel_Calculation_Functions::isMatrixValue($k))) {
 			} else {
 				if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {
 					if (is_bool($arg)) {
@@ -836,7 +836,7 @@ 
 	 * @param	string		$condition		The criteria that defines which cells will be checked.
 	 * @return	float
 	 */
-	public static function AVERAGEIF($aArgs,$condition,$averageArgs = array()) {
+	public static function AVERAGEIF($aArgs, $condition, $averageArgs = array()) {
 		// Return value
 		$returnValue = 0;
 
@@ -849,7 +849,7 @@ 
 		// Loop through arguments
 		$aCount = 0;
 		foreach ($aArgs as $key => $arg) {
-			if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
+			if ( ! is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
 			$testCondition = '='.$arg.$condition;
 			if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
 				if ((is_null($returnValue)) || ($arg > $returnValue)) {
@@ -880,7 +880,7 @@ 
 	 * @return	float
 	 *
 	 */
-	public static function BETADIST($value,$alpha,$beta,$rMin=0,$rMax=1) {
+	public static function BETADIST($value, $alpha, $beta, $rMin = 0, $rMax = 1) {
 		$value	= PHPExcel_Calculation_Functions::flattenSingleValue($value);
 		$alpha	= PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
 		$beta	= PHPExcel_Calculation_Functions::flattenSingleValue($beta);
@@ -898,7 +898,7 @@ 
 			}
 			$value -= $rMin;
 			$value /= ($rMax - $rMin);
-			return self::_incompleteBeta($value,$alpha,$beta);
+			return self::_incompleteBeta($value, $alpha, $beta);
 		}
 		return PHPExcel_Calculation_Functions::VALUE();
 	}	//	function BETADIST()
@@ -916,9 +916,9 @@ 
 	 * @return	float
 	 *
 	 */
-	public static function BETAINV($probability,$alpha,$beta,$rMin=0,$rMax=1) {
-		$probability	= PHPExcel_Calculation_Functions::flattenSingleValue($probability);
-		$alpha			= PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
+	public static function BETAINV($probability, $alpha, $beta, $rMin = 0, $rMax = 1) {
+		$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
+		$alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
 		$beta			= PHPExcel_Calculation_Functions::flattenSingleValue($beta);
 		$rMin			= PHPExcel_Calculation_Functions::flattenSingleValue($rMin);
 		$rMax			= PHPExcel_Calculation_Functions::flattenSingleValue($rMax);
@@ -950,7 +950,7 @@ 
 			if ($i == MAX_ITERATIONS) {
 				return PHPExcel_Calculation_Functions::NA();
 			}
-			return round($rMin + $guess * ($rMax - $rMin),12);
+			return round($rMin + $guess * ($rMax - $rMin), 12);
 		}
 		return PHPExcel_Calculation_Functions::VALUE();
 	}	//	function BETAINV()
@@ -975,9 +975,9 @@ 
 	 *
 	 */
 	public static function BINOMDIST($value, $trials, $probability, $cumulative) {
-		$value			= floor(PHPExcel_Calculation_Functions::flattenSingleValue($value));
-		$trials			= floor(PHPExcel_Calculation_Functions::flattenSingleValue($trials));
-		$probability	= PHPExcel_Calculation_Functions::flattenSingleValue($probability);
+		$value = floor(PHPExcel_Calculation_Functions::flattenSingleValue($value));
+		$trials = floor(PHPExcel_Calculation_Functions::flattenSingleValue($trials));
+		$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
 
 		if ((is_numeric($value)) && (is_numeric($trials)) && (is_numeric($probability))) {
 			if (($value < 0) || ($value > $trials)) {
@@ -990,11 +990,11 @@ 
 				if ($cumulative) {
 					$summer = 0;
 					for ($i = 0; $i <= $value; ++$i) {
-						$summer += PHPExcel_Calculation_MathTrig::COMBIN($trials,$i) * pow($probability,$i) * pow(1 - $probability,$trials - $i);
+						$summer += PHPExcel_Calculation_MathTrig::COMBIN($trials, $i) * pow($probability, $i) * pow(1 - $probability, $trials - $i);
 					}
 					return $summer;
 				} else {
-					return PHPExcel_Calculation_MathTrig::COMBIN($trials,$value) * pow($probability,$value) * pow(1 - $probability,$trials - $value) ;
+					return PHPExcel_Calculation_MathTrig::COMBIN($trials, $value) * pow($probability, $value) * pow(1 - $probability, $trials - $value);
 				}
 			}
 		}
@@ -1012,8 +1012,8 @@ 
 	 * @return	float
 	 */
 	public static function CHIDIST($value, $degrees) {
-		$value		= PHPExcel_Calculation_Functions::flattenSingleValue($value);
-		$degrees	= floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
+		$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
+		$degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
 
 		if ((is_numeric($value)) && (is_numeric($degrees))) {
 			if ($degrees < 1) {
@@ -1025,7 +1025,7 @@ 
 				}
 				return PHPExcel_Calculation_Functions::NaN();
 			}
-			return 1 - (self::_incompleteGamma($degrees/2,$value/2) / self::_gamma($degrees/2));
+			return 1 - (self::_incompleteGamma($degrees / 2, $value / 2) / self::_gamma($degrees / 2));
 		}
 		return PHPExcel_Calculation_Functions::VALUE();
 	}	//	function CHIDIST()
@@ -1041,8 +1041,8 @@ 
 	 * @return	float
 	 */
 	public static function CHIINV($probability, $degrees) {
-		$probability	= PHPExcel_Calculation_Functions::flattenSingleValue($probability);
-		$degrees		= floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
+		$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
+		$degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
 
 		if ((is_numeric($probability)) && (is_numeric($degrees))) {
 
@@ -1050,7 +1050,7 @@ 
 			$xHi = 0;
 
 			$x = $xNew = 1;
-			$dx	= 1;
+			$dx = 1;
 			$i = 0;
 
 			while ((abs($dx) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
@@ -1081,7 +1081,7 @@ 
 			if ($i == MAX_ITERATIONS) {
 				return PHPExcel_Calculation_Functions::NA();
 			}
-			return round($x,12);
+			return round($x, 12);
 		}
 		return PHPExcel_Calculation_Functions::VALUE();
 	}	//	function CHIINV()
@@ -1098,10 +1098,10 @@ 
 	 * @return	float
 	 *
 	 */
-	public static function CONFIDENCE($alpha,$stdDev,$size) {
-		$alpha	= PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
-		$stdDev	= PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
-		$size	= floor(PHPExcel_Calculation_Functions::flattenSingleValue($size));
+	public static function CONFIDENCE($alpha, $stdDev, $size) {
+		$alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
+		$stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
+		$size = floor(PHPExcel_Calculation_Functions::flattenSingleValue($size));
 
 		if ((is_numeric($alpha)) && (is_numeric($stdDev)) && (is_numeric($size))) {
 			if (($alpha <= 0) || ($alpha >= 1)) {
@@ -1125,11 +1125,11 @@ 
 	 * @param	array of mixed		Data Series X
 	 * @return	float
 	 */
-	public static function CORREL($yValues,$xValues=null) {
-		if ((is_null($xValues)) || (!is_array($yValues)) || (!is_array($xValues))) {
+	public static function CORREL($yValues, $xValues = null) {
+		if ((is_null($xValues)) || ( ! is_array($yValues)) || ( ! is_array($xValues))) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
-		if (!self::_checkTrendArrays($yValues,$xValues)) {
+		if ( ! self::_checkTrendArrays($yValues, $xValues)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 		$yValueCount = count($yValues);
@@ -1141,7 +1141,7 @@ 
 			return PHPExcel_Calculation_Functions::DIV0();
 		}
 
-		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
+		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR, $yValues, $xValues);
 		return $bestFitLinear->getCorrelation();
 	}	//	function CORREL()
 
@@ -1167,11 +1167,11 @@ 
 		$aArgs = PHPExcel_Calculation_Functions::flattenArrayIndexed(func_get_args());
 		foreach ($aArgs as $k => $arg) {
 			if ((is_bool($arg)) &&
-				((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
+				(( ! PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
 				$arg = (integer) $arg;
 			}
 			// Is it a numeric value?
-			if ((is_numeric($arg)) && (!is_string($arg))) {
+			if ((is_numeric($arg)) && ( ! is_string($arg))) {
 				++$returnValue;
 			}
 		}
@@ -1257,7 +1257,7 @@ 
 	 * @param	string		$condition		The criteria that defines which cells will be counted.
 	 * @return	int
 	 */
-	public static function COUNTIF($aArgs,$condition) {
+	public static function COUNTIF($aArgs, $condition) {
 		// Return value
 		$returnValue = 0;
 
@@ -1265,7 +1265,7 @@ 
 		$condition = PHPExcel_Calculation_Functions::_ifCondition($condition);
 		// Loop through arguments
 		foreach ($aArgs as $arg) {
-			if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
+			if ( ! is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
 			$testCondition = '='.$arg.$condition;
 			if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
 				// Is it a value within our criteria
@@ -1287,8 +1287,8 @@ 
 	 * @param	array of mixed		Data Series X
 	 * @return	float
 	 */
-	public static function COVAR($yValues,$xValues) {
-		if (!self::_checkTrendArrays($yValues,$xValues)) {
+	public static function COVAR($yValues, $xValues) {
+		if ( ! self::_checkTrendArrays($yValues, $xValues)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 		$yValueCount = count($yValues);
@@ -1300,7 +1300,7 @@ 
 			return PHPExcel_Calculation_Functions::DIV0();
 		}
 
-		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
+		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR, $yValues, $xValues);
 		return $bestFitLinear->getCovariance();
 	}	//	function COVAR()
 
@@ -1325,9 +1325,9 @@ 
 	 *
 	 */
 	public static function CRITBINOM($trials, $probability, $alpha) {
-		$trials			= floor(PHPExcel_Calculation_Functions::flattenSingleValue($trials));
-		$probability	= PHPExcel_Calculation_Functions::flattenSingleValue($probability);
-		$alpha			= PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
+		$trials = floor(PHPExcel_Calculation_Functions::flattenSingleValue($trials));
+		$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
+		$alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
 
 		if ((is_numeric($trials)) && (is_numeric($probability)) && (is_numeric($alpha))) {
 			if ($trials < 0) {
@@ -1343,7 +1343,7 @@ 
 				$t = sqrt(log(1 / ($alpha * $alpha)));
 				$trialsApprox = 0 - ($t + (2.515517 + 0.802853 * $t + 0.010328 * $t * $t) / (1 + 1.432788 * $t + 0.189269 * $t * $t + 0.001308 * $t * $t * $t));
 			} else {
-				$t = sqrt(log(1 / pow(1 - $alpha,2)));
+				$t = sqrt(log(1 / pow(1 - $alpha, 2)));
 				$trialsApprox = $t - (2.515517 + 0.802853 * $t + 0.010328 * $t * $t) / (1 + 1.432788 * $t + 0.189269 * $t * $t + 0.001308 * $t * $t * $t);
 			}
 			$Guess = floor($trials * $probability + $trialsApprox * sqrt($trials * $probability * (1 - $probability)));
@@ -1364,7 +1364,7 @@ 
 			$PreviousValue = 1;
 			$Done = False;
 			$k = $m + 1;
-			while ((!$Done) && ($k <= $trials)) {
+			while (( ! $Done) && ($k <= $trials)) {
 				$CurrentValue = $PreviousValue * ($trials - $k + 1) * $probability / ($k * (1 - $probability));
 				$TotalUnscaledProbability += $CurrentValue;
 				if ($k == $Guess) { $UnscaledPGuess += $CurrentValue; }
@@ -1377,7 +1377,7 @@ 
 			$PreviousValue = 1;
 			$Done = False;
 			$k = $m - 1;
-			while ((!$Done) && ($k >= 0)) {
+			while (( ! $Done) && ($k >= 0)) {
 				$CurrentValue = $PreviousValue * $k + 1 * (1 - $probability) / (($trials - $k) * $probability);
 				$TotalUnscaledProbability += $CurrentValue;
 				if ($k == $Guess) { $UnscaledPGuess += $CurrentValue; }
@@ -1440,14 +1440,14 @@ 
 			foreach ($aArgs as $k => $arg) {
 				// Is it a numeric value?
 				if ((is_bool($arg)) &&
-					((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
+					(( ! PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
 					$arg = (integer) $arg;
 				}
-				if ((is_numeric($arg)) && (!is_string($arg))) {
+				if ((is_numeric($arg)) && ( ! is_string($arg))) {
 					if (is_null($returnValue)) {
-						$returnValue = pow(($arg - $aMean),2);
+						$returnValue = pow(($arg - $aMean), 2);
 					} else {
-						$returnValue += pow(($arg - $aMean),2);
+						$returnValue += pow(($arg - $aMean), 2);
 					}
 					++$aCount;
 				}
@@ -1477,9 +1477,9 @@ 
 	 * @return	float
 	 */
 	public static function EXPONDIST($value, $lambda, $cumulative) {
-		$value	= PHPExcel_Calculation_Functions::flattenSingleValue($value);
-		$lambda	= PHPExcel_Calculation_Functions::flattenSingleValue($lambda);
-		$cumulative	= PHPExcel_Calculation_Functions::flattenSingleValue($cumulative);
+		$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
+		$lambda = PHPExcel_Calculation_Functions::flattenSingleValue($lambda);
+		$cumulative = PHPExcel_Calculation_Functions::flattenSingleValue($cumulative);
 
 		if ((is_numeric($value)) && (is_numeric($lambda))) {
 			if (($value < 0) || ($lambda < 0)) {
@@ -1487,9 +1487,9 @@ 
 			}
 			if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
 				if ($cumulative) {
-					return 1 - exp(0-$value*$lambda);
+					return 1 - exp(0 - $value * $lambda);
 				} else {
-					return $lambda * exp(0-$value*$lambda);
+					return $lambda * exp(0 - $value * $lambda);
 				}
 			}
 		}
@@ -1508,13 +1508,13 @@ 
 	 * @return	float
 	 */
 	public static function FISHER($value) {
-		$value	= PHPExcel_Calculation_Functions::flattenSingleValue($value);
+		$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
 
 		if (is_numeric($value)) {
 			if (($value <= -1) || ($value >= 1)) {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
-			return 0.5 * log((1+$value)/(1-$value));
+			return 0.5 * log((1 + $value) / (1 - $value));
 		}
 		return PHPExcel_Calculation_Functions::VALUE();
 	}	//	function FISHER()
@@ -1531,7 +1531,7 @@ 
 	 * @return	float
 	 */
 	public static function FISHERINV($value) {
-		$value	= PHPExcel_Calculation_Functions::flattenSingleValue($value);
+		$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
 
 		if (is_numeric($value)) {
 			return (exp(2 * $value) - 1) / (exp(2 * $value) + 1);
@@ -1550,13 +1550,13 @@ 
 	 * @param	array of mixed		Data Series X
 	 * @return	float
 	 */
-	public static function FORECAST($xValue,$yValues,$xValues) {
-		$xValue	= PHPExcel_Calculation_Functions::flattenSingleValue($xValue);
-		if (!is_numeric($xValue)) {
+	public static function FORECAST($xValue, $yValues, $xValues) {
+		$xValue = PHPExcel_Calculation_Functions::flattenSingleValue($xValue);
+		if ( ! is_numeric($xValue)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 
-		if (!self::_checkTrendArrays($yValues,$xValues)) {
+		if ( ! self::_checkTrendArrays($yValues, $xValues)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 		$yValueCount = count($yValues);
@@ -1568,7 +1568,7 @@ 
 			return PHPExcel_Calculation_Functions::DIV0();
 		}
 
-		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
+		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR, $yValues, $xValues);
 		return $bestFitLinear->getValueOfYForX($xValue);
 	}	//	function FORECAST()
 
@@ -1585,8 +1585,8 @@ 
 	 * @return	float
 	 *
 	 */
-	public static function GAMMADIST($value,$a,$b,$cumulative) {
-		$value	= PHPExcel_Calculation_Functions::flattenSingleValue($value);
+	public static function GAMMADIST($value, $a, $b, $cumulative) {
+		$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
 		$a		= PHPExcel_Calculation_Functions::flattenSingleValue($a);
 		$b		= PHPExcel_Calculation_Functions::flattenSingleValue($b);
 
@@ -1596,9 +1596,9 @@ 
 			}
 			if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
 				if ($cumulative) {
-					return self::_incompleteGamma($a,$value / $b) / self::_gamma($a);
+					return self::_incompleteGamma($a, $value / $b) / self::_gamma($a);
 				} else {
-					return (1 / (pow($b,$a) * self::_gamma($a))) * pow($value,$a-1) * exp(0-($value / $b));
+					return (1 / (pow($b, $a) * self::_gamma($a))) * pow($value, $a - 1) * exp(0 - ($value / $b));
 				}
 			}
 		}
@@ -1617,10 +1617,10 @@ 
 	 * @return	float
 	 *
 	 */
-	public static function GAMMAINV($probability,$alpha,$beta) {
-		$probability	= PHPExcel_Calculation_Functions::flattenSingleValue($probability);
-		$alpha			= PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
-		$beta			= PHPExcel_Calculation_Functions::flattenSingleValue($beta);
+	public static function GAMMAINV($probability, $alpha, $beta) {
+		$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
+		$alpha = PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
+		$beta = PHPExcel_Calculation_Functions::flattenSingleValue($beta);
 
 		if ((is_numeric($probability)) && (is_numeric($alpha)) && (is_numeric($beta))) {
 			if (($alpha <= 0) || ($beta <= 0) || ($probability < 0) || ($probability > 1)) {
@@ -1632,7 +1632,7 @@ 
 
 			$x = $xNew = 1;
 			$error = $pdf = 0;
-			$dx	= 1024;
+			$dx = 1024;
 			$i = 0;
 
 			while ((abs($dx) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
@@ -1676,7 +1676,7 @@ 
 	 * @return	float
 	 */
 	public static function GAMMALN($value) {
-		$value	= PHPExcel_Calculation_Functions::flattenSingleValue($value);
+		$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
 
 		if (is_numeric($value)) {
 			if ($value <= 0) {
@@ -1708,7 +1708,7 @@ 
 
 		$aMean = PHPExcel_Calculation_MathTrig::PRODUCT($aArgs);
 		if (is_numeric($aMean) && ($aMean > 0)) {
-			$aCount = self::COUNT($aArgs) ;
+			$aCount = self::COUNT($aArgs);
 			if (self::MIN($aArgs) > 0) {
 				return pow($aMean, (1 / $aCount));
 			}
@@ -1728,19 +1728,19 @@ 
 	 * @param	boolean				A logical value specifying whether to force the intersect to equal 0.
 	 * @return	array of float
 	 */
-	public static function GROWTH($yValues,$xValues=array(),$newValues=array(),$const=True) {
+	public static function GROWTH($yValues, $xValues = array(), $newValues = array(), $const = True) {
 		$yValues = PHPExcel_Calculation_Functions::flattenArray($yValues);
 		$xValues = PHPExcel_Calculation_Functions::flattenArray($xValues);
 		$newValues = PHPExcel_Calculation_Functions::flattenArray($newValues);
-		$const	= (is_null($const))	? True :	(boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
+		$const = (is_null($const)) ? True : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
 
-		$bestFitExponential = trendClass::calculate(trendClass::TREND_EXPONENTIAL,$yValues,$xValues,$const);
+		$bestFitExponential = trendClass::calculate(trendClass::TREND_EXPONENTIAL, $yValues, $xValues, $const);
 		if (empty($newValues)) {
 			$newValues = $bestFitExponential->getXValues();
 		}
 
 		$returnArray = array();
-		foreach($newValues as $xValue) {
+		foreach ($newValues as $xValue) {
 			$returnArray[0][] = $bestFitExponential->getValueOfYForX($xValue);
 		}
 
@@ -1774,7 +1774,7 @@ 
 		$aCount = 0;
 		foreach ($aArgs as $arg) {
 			// Is it a numeric value?
-			if ((is_numeric($arg)) && (!is_string($arg))) {
+			if ((is_numeric($arg)) && ( ! is_string($arg))) {
 				if ($arg <= 0) {
 					return PHPExcel_Calculation_Functions::NaN();
 				}
@@ -1810,10 +1810,10 @@ 
 	 *
 	 */
 	public static function HYPGEOMDIST($sampleSuccesses, $sampleNumber, $populationSuccesses, $populationNumber) {
-		$sampleSuccesses		= floor(PHPExcel_Calculation_Functions::flattenSingleValue($sampleSuccesses));
-		$sampleNumber			= floor(PHPExcel_Calculation_Functions::flattenSingleValue($sampleNumber));
-		$populationSuccesses	= floor(PHPExcel_Calculation_Functions::flattenSingleValue($populationSuccesses));
-		$populationNumber		= floor(PHPExcel_Calculation_Functions::flattenSingleValue($populationNumber));
+		$sampleSuccesses = floor(PHPExcel_Calculation_Functions::flattenSingleValue($sampleSuccesses));
+		$sampleNumber = floor(PHPExcel_Calculation_Functions::flattenSingleValue($sampleNumber));
+		$populationSuccesses = floor(PHPExcel_Calculation_Functions::flattenSingleValue($populationSuccesses));
+		$populationNumber = floor(PHPExcel_Calculation_Functions::flattenSingleValue($populationNumber));
 
 		if ((is_numeric($sampleSuccesses)) && (is_numeric($sampleNumber)) && (is_numeric($populationSuccesses)) && (is_numeric($populationNumber))) {
 			if (($sampleSuccesses < 0) || ($sampleSuccesses > $sampleNumber) || ($sampleSuccesses > $populationSuccesses)) {
@@ -1825,9 +1825,9 @@ 
 			if (($populationSuccesses <= 0) || ($populationSuccesses > $populationNumber)) {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
-			return PHPExcel_Calculation_MathTrig::COMBIN($populationSuccesses,$sampleSuccesses) *
-				   PHPExcel_Calculation_MathTrig::COMBIN($populationNumber - $populationSuccesses,$sampleNumber - $sampleSuccesses) /
-				   PHPExcel_Calculation_MathTrig::COMBIN($populationNumber,$sampleNumber);
+			return PHPExcel_Calculation_MathTrig::COMBIN($populationSuccesses, $sampleSuccesses) *
+				   PHPExcel_Calculation_MathTrig::COMBIN($populationNumber - $populationSuccesses, $sampleNumber - $sampleSuccesses) /
+				   PHPExcel_Calculation_MathTrig::COMBIN($populationNumber, $sampleNumber);
 		}
 		return PHPExcel_Calculation_Functions::VALUE();
 	}	//	function HYPGEOMDIST()
@@ -1842,8 +1842,8 @@ 
 	 * @param	array of mixed		Data Series X
 	 * @return	float
 	 */
-	public static function INTERCEPT($yValues,$xValues) {
-		if (!self::_checkTrendArrays($yValues,$xValues)) {
+	public static function INTERCEPT($yValues, $xValues) {
+		if ( ! self::_checkTrendArrays($yValues, $xValues)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 		$yValueCount = count($yValues);
@@ -1855,7 +1855,7 @@ 
 			return PHPExcel_Calculation_Functions::DIV0();
 		}
 
-		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
+		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR, $yValues, $xValues);
 		return $bestFitLinear->getIntersect();
 	}	//	function INTERCEPT()
 
@@ -1881,11 +1881,11 @@ 
 			// Loop through arguments
 			foreach ($aArgs as $k => $arg) {
 				if ((is_bool($arg)) &&
-					(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
+					( ! PHPExcel_Calculation_Functions::isMatrixValue($k))) {
 				} else {
 					// Is it a numeric value?
-					if ((is_numeric($arg)) && (!is_string($arg))) {
-						$summer += pow((($arg - $mean) / $stdDev),4) ;
+					if ((is_numeric($arg)) && ( ! is_string($arg))) {
+						$summer += pow((($arg - $mean) / $stdDev), 4);
 						++$count;
 					}
 				}
@@ -1893,7 +1893,7 @@ 
 
 			// Return
 			if ($count > 3) {
-				return $summer * ($count * ($count+1) / (($count-1) * ($count-2) * ($count-3))) - (3 * pow($count-1,2) / (($count-2) * ($count-3)));
+				return $summer * ($count * ($count + 1) / (($count - 1) * ($count - 2) * ($count - 3))) - (3 * pow($count - 1, 2) / (($count - 2) * ($count - 3)));
 			}
 		}
 		return PHPExcel_Calculation_Functions::DIV0();
@@ -1922,11 +1922,11 @@ 
 		// Calculate
 		$entry = floor(array_pop($aArgs));
 
-		if ((is_numeric($entry)) && (!is_string($entry))) {
+		if ((is_numeric($entry)) && ( ! is_string($entry))) {
 			$mArgs = array();
 			foreach ($aArgs as $arg) {
 				// Is it a numeric value?
-				if ((is_numeric($arg)) && (!is_string($arg))) {
+				if ((is_numeric($arg)) && ( ! is_string($arg))) {
 					$mArgs[] = $arg;
 				}
 			}
@@ -1954,12 +1954,12 @@ 
 	 * @param	boolean				A logical value specifying whether to return additional regression statistics.
 	 * @return	array
 	 */
-	public static function LINEST($yValues,$xValues=null,$const=True,$stats=False) {
-		$const	= (is_null($const))	? True :	(boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
-		$stats	= (is_null($stats))	? False :	(boolean) PHPExcel_Calculation_Functions::flattenSingleValue($stats);
-		if (is_null($xValues)) $xValues = range(1,count(PHPExcel_Calculation_Functions::flattenArray($yValues)));
+	public static function LINEST($yValues, $xValues = null, $const = True, $stats = False) {
+		$const	= (is_null($const)) ? True : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
+		$stats	= (is_null($stats)) ? False : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($stats);
+		if (is_null($xValues)) $xValues = range(1, count(PHPExcel_Calculation_Functions::flattenArray($yValues)));
 
-		if (!self::_checkTrendArrays($yValues,$xValues)) {
+		if ( ! self::_checkTrendArrays($yValues, $xValues)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 		$yValueCount = count($yValues);
@@ -1972,15 +1972,15 @@ 
 			return 0;
 		}
 
-		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues,$const);
+		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR, $yValues, $xValues, $const);
 		if ($stats) {
-			return array( array( $bestFitLinear->getSlope(),
+			return array(array($bestFitLinear->getSlope(),
 						 		 $bestFitLinear->getSlopeSE(),
 						 		 $bestFitLinear->getGoodnessOfFit(),
 						 		 $bestFitLinear->getF(),
 						 		 $bestFitLinear->getSSRegression(),
 							   ),
-						  array( $bestFitLinear->getIntersect(),
+						  array($bestFitLinear->getIntersect(),
 								 $bestFitLinear->getIntersectSE(),
 								 $bestFitLinear->getStdevOfResiduals(),
 								 $bestFitLinear->getDFResiduals(),
@@ -1988,7 +1988,7 @@ 
 							   )
 						);
 		} else {
-			return array( $bestFitLinear->getSlope(),
+			return array($bestFitLinear->getSlope(),
 						  $bestFitLinear->getIntersect()
 						);
 		}
@@ -2007,18 +2007,18 @@ 
 	 * @param	boolean				A logical value specifying whether to return additional regression statistics.
 	 * @return	array
 	 */
-	public static function LOGEST($yValues,$xValues=null,$const=True,$stats=False) {
-		$const	= (is_null($const))	? True :	(boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
-		$stats	= (is_null($stats))	? False :	(boolean) PHPExcel_Calculation_Functions::flattenSingleValue($stats);
-		if (is_null($xValues)) $xValues = range(1,count(PHPExcel_Calculation_Functions::flattenArray($yValues)));
+	public static function LOGEST($yValues, $xValues = null, $const = True, $stats = False) {
+		$const	= (is_null($const)) ? True : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
+		$stats	= (is_null($stats)) ? False : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($stats);
+		if (is_null($xValues)) $xValues = range(1, count(PHPExcel_Calculation_Functions::flattenArray($yValues)));
 
-		if (!self::_checkTrendArrays($yValues,$xValues)) {
+		if ( ! self::_checkTrendArrays($yValues, $xValues)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 		$yValueCount = count($yValues);
 		$xValueCount = count($xValues);
 
-		foreach($yValues as $value) {
+		foreach ($yValues as $value) {
 			if ($value <= 0.0) {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
@@ -2031,15 +2031,15 @@ 
 			return 1;
 		}
 
-		$bestFitExponential = trendClass::calculate(trendClass::TREND_EXPONENTIAL,$yValues,$xValues,$const);
+		$bestFitExponential = trendClass::calculate(trendClass::TREND_EXPONENTIAL, $yValues, $xValues, $const);
 		if ($stats) {
-			return array( array( $bestFitExponential->getSlope(),
+			return array(array($bestFitExponential->getSlope(),
 						 		 $bestFitExponential->getSlopeSE(),
 						 		 $bestFitExponential->getGoodnessOfFit(),
 						 		 $bestFitExponential->getF(),
 						 		 $bestFitExponential->getSSRegression(),
 							   ),
-						  array( $bestFitExponential->getIntersect(),
+						  array($bestFitExponential->getIntersect(),
 								 $bestFitExponential->getIntersectSE(),
 								 $bestFitExponential->getStdevOfResiduals(),
 								 $bestFitExponential->getDFResiduals(),
@@ -2047,7 +2047,7 @@ 
 							   )
 						);
 		} else {
-			return array( $bestFitExponential->getSlope(),
+			return array($bestFitExponential->getSlope(),
 						  $bestFitExponential->getIntersect()
 						);
 		}
@@ -2067,9 +2067,9 @@ 
 	 *			(as described at) http://home.online.no/~pjacklam/notes/invnorm/
 	 */
 	public static function LOGINV($probability, $mean, $stdDev) {
-		$probability	= PHPExcel_Calculation_Functions::flattenSingleValue($probability);
-		$mean			= PHPExcel_Calculation_Functions::flattenSingleValue($mean);
-		$stdDev			= PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
+		$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
+		$mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
+		$stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
 
 		if ((is_numeric($probability)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
 			if (($probability < 0) || ($probability > 1) || ($stdDev <= 0)) {
@@ -2091,9 +2091,9 @@ 
 	 * @return	float
 	 */
 	public static function LOGNORMDIST($value, $mean, $stdDev) {
-		$value	= PHPExcel_Calculation_Functions::flattenSingleValue($value);
-		$mean	= PHPExcel_Calculation_Functions::flattenSingleValue($mean);
-		$stdDev	= PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
+		$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
+		$mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
+		$stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
 
 		if ((is_numeric($value)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
 			if (($value <= 0) || ($stdDev <= 0)) {
@@ -2127,7 +2127,7 @@ 
 		$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
 		foreach ($aArgs as $arg) {
 			// Is it a numeric value?
-			if ((is_numeric($arg)) && (!is_string($arg))) {
+			if ((is_numeric($arg)) && ( ! is_string($arg))) {
 				if ((is_null($returnValue)) || ($arg > $returnValue)) {
 					$returnValue = $arg;
 				}
@@ -2135,7 +2135,7 @@ 
 		}
 
 		// Return
-		if(is_null($returnValue)) {
+		if (is_null($returnValue)) {
 			return 0;
 		}
 		return $returnValue;
@@ -2176,7 +2176,7 @@ 
 		}
 
 		// Return
-		if(is_null($returnValue)) {
+		if (is_null($returnValue)) {
 			return 0;
 		}
 		return $returnValue;
@@ -2197,7 +2197,7 @@ 
 	 * @param	string		$condition		The criteria that defines which cells will be checked.
 	 * @return	float
 	 */
-	public static function MAXIF($aArgs,$condition,$sumArgs = array()) {
+	public static function MAXIF($aArgs, $condition, $sumArgs = array()) {
 		// Return value
 		$returnValue = null;
 
@@ -2209,7 +2209,7 @@ 
 		$condition = PHPExcel_Calculation_Functions::_ifCondition($condition);
 		// Loop through arguments
 		foreach ($aArgs as $key => $arg) {
-			if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
+			if ( ! is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
 			$testCondition = '='.$arg.$condition;
 			if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
 				if ((is_null($returnValue)) || ($arg > $returnValue)) {
@@ -2245,14 +2245,14 @@ 
 		$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
 		foreach ($aArgs as $arg) {
 			// Is it a numeric value?
-			if ((is_numeric($arg)) && (!is_string($arg))) {
+			if ((is_numeric($arg)) && ( ! is_string($arg))) {
 				$mArgs[] = $arg;
 			}
 		}
 
 		$mValueCount = count($mArgs);
 		if ($mValueCount > 0) {
-			sort($mArgs,SORT_NUMERIC);
+			sort($mArgs, SORT_NUMERIC);
 			$mValueCount = $mValueCount / 2;
 			if ($mValueCount == floor($mValueCount)) {
 				$returnValue = ($mArgs[$mValueCount--] + $mArgs[$mValueCount]) / 2;
@@ -2289,7 +2289,7 @@ 
 		$aArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
 		foreach ($aArgs as $arg) {
 			// Is it a numeric value?
-			if ((is_numeric($arg)) && (!is_string($arg))) {
+			if ((is_numeric($arg)) && ( ! is_string($arg))) {
 				if ((is_null($returnValue)) || ($arg < $returnValue)) {
 					$returnValue = $arg;
 				}
@@ -2297,7 +2297,7 @@ 
 		}
 
 		// Return
-		if(is_null($returnValue)) {
+		if (is_null($returnValue)) {
 			return 0;
 		}
 		return $returnValue;
@@ -2338,7 +2338,7 @@ 
 		}
 
 		// Return
-		if(is_null($returnValue)) {
+		if (is_null($returnValue)) {
 			return 0;
 		}
 		return $returnValue;
@@ -2359,7 +2359,7 @@ 
 	 * @param	string		$condition		The criteria that defines which cells will be checked.
 	 * @return	float
 	 */
-	public static function MINIF($aArgs,$condition,$sumArgs = array()) {
+	public static function MINIF($aArgs, $condition, $sumArgs = array()) {
 		// Return value
 		$returnValue = null;
 
@@ -2371,7 +2371,7 @@ 
 		$condition = PHPExcel_Calculation_Functions::_ifCondition($condition);
 		// Loop through arguments
 		foreach ($aArgs as $key => $arg) {
-			if (!is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
+			if ( ! is_numeric($arg)) { $arg = PHPExcel_Calculation::_wrapResult(strtoupper($arg)); }
 			$testCondition = '='.$arg.$condition;
 			if (PHPExcel_Calculation::getInstance()->_calculateFormulaValue($testCondition)) {
 				if ((is_null($returnValue)) || ($arg < $returnValue)) {
@@ -2391,22 +2391,22 @@ 
 	//
 	private static function _modeCalc($data) {
 		$frequencyArray = array();
-		foreach($data as $datum) {
+		foreach ($data as $datum) {
 			$found = False;
-			foreach($frequencyArray as $key => $value) {
+			foreach ($frequencyArray as $key => $value) {
 				if ((string) $value['value'] == (string) $datum) {
 					++$frequencyArray[$key]['frequency'];
 					$found = True;
 					break;
 				}
 			}
-			if (!$found) {
+			if ( ! $found) {
 				$frequencyArray[] = array('value'		=> $datum,
-										  'frequency'	=>	1 );
+										  'frequency'	=>	1);
 			}
 		}
 
-		foreach($frequencyArray as $key => $value) {
+		foreach ($frequencyArray as $key => $value) {
 			$frequencyList[$key] = $value['frequency'];
 			$valueList[$key] = $value['value'];
 		}
@@ -2442,12 +2442,12 @@ 
 		$mArgs = array();
 		foreach ($aArgs as $arg) {
 			// Is it a numeric value?
-			if ((is_numeric($arg)) && (!is_string($arg))) {
+			if ((is_numeric($arg)) && ( ! is_string($arg))) {
 				$mArgs[] = $arg;
 			}
 		}
 
-		if (!empty($mArgs)) {
+		if ( ! empty($mArgs)) {
 			return self::_modeCalc($mArgs);
 		}
 
@@ -2472,9 +2472,9 @@ 
 	 *
 	 */
 	public static function NEGBINOMDIST($failures, $successes, $probability) {
-		$failures		= floor(PHPExcel_Calculation_Functions::flattenSingleValue($failures));
-		$successes		= floor(PHPExcel_Calculation_Functions::flattenSingleValue($successes));
-		$probability	= PHPExcel_Calculation_Functions::flattenSingleValue($probability);
+		$failures = floor(PHPExcel_Calculation_Functions::flattenSingleValue($failures));
+		$successes = floor(PHPExcel_Calculation_Functions::flattenSingleValue($successes));
+		$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
 
 		if ((is_numeric($failures)) && (is_numeric($successes)) && (is_numeric($probability))) {
 			if (($failures < 0) || ($successes < 1)) {
@@ -2488,7 +2488,7 @@ 
 					return PHPExcel_Calculation_Functions::NaN();
 				}
 			}
-			return (PHPExcel_Calculation_MathTrig::COMBIN($failures + $successes - 1,$successes - 1)) * (pow($probability,$successes)) * (pow(1 - $probability,$failures)) ;
+			return (PHPExcel_Calculation_MathTrig::COMBIN($failures + $successes - 1, $successes - 1)) * (pow($probability, $successes)) * (pow(1 - $probability, $failures));
 		}
 		return PHPExcel_Calculation_Functions::VALUE();
 	}	//	function NEGBINOMDIST()
@@ -2509,9 +2509,9 @@ 
 	 *
 	 */
 	public static function NORMDIST($value, $mean, $stdDev, $cumulative) {
-		$value	= PHPExcel_Calculation_Functions::flattenSingleValue($value);
-		$mean	= PHPExcel_Calculation_Functions::flattenSingleValue($mean);
-		$stdDev	= PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
+		$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
+		$mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
+		$stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
 
 		if ((is_numeric($value)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
 			if ($stdDev < 0) {
@@ -2521,7 +2521,7 @@ 
 				if ($cumulative) {
 					return 0.5 * (1 + PHPExcel_Calculation_Engineering::_erfVal(($value - $mean) / ($stdDev * sqrt(2))));
 				} else {
-					return (1 / (SQRT2PI * $stdDev)) * exp(0 - (pow($value - $mean,2) / (2 * ($stdDev * $stdDev))));
+					return (1 / (SQRT2PI * $stdDev)) * exp(0 - (pow($value - $mean, 2) / (2 * ($stdDev * $stdDev))));
 				}
 			}
 		}
@@ -2540,10 +2540,10 @@ 
 	 * @return	float
 	 *
 	 */
-	public static function NORMINV($probability,$mean,$stdDev) {
-		$probability	= PHPExcel_Calculation_Functions::flattenSingleValue($probability);
-		$mean			= PHPExcel_Calculation_Functions::flattenSingleValue($mean);
-		$stdDev			= PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
+	public static function NORMINV($probability, $mean, $stdDev) {
+		$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
+		$mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
+		$stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
 
 		if ((is_numeric($probability)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
 			if (($probability < 0) || ($probability > 1)) {
@@ -2569,7 +2569,7 @@ 
 	 * @return	float
 	 */
 	public static function NORMSDIST($value) {
-		$value	= PHPExcel_Calculation_Functions::flattenSingleValue($value);
+		$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
 
 		return self::NORMDIST($value, 0, 1, True);
 	}	//	function NORMSDIST()
@@ -2608,14 +2608,14 @@ 
 		// Calculate
 		$entry = array_pop($aArgs);
 
-		if ((is_numeric($entry)) && (!is_string($entry))) {
+		if ((is_numeric($entry)) && ( ! is_string($entry))) {
 			if (($entry < 0) || ($entry > 1)) {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
 			$mArgs = array();
 			foreach ($aArgs as $arg) {
 				// Is it a numeric value?
-				if ((is_numeric($arg)) && (!is_string($arg))) {
+				if ((is_numeric($arg)) && ( ! is_string($arg))) {
 					$mArgs[] = $arg;
 				}
 			}
@@ -2623,14 +2623,14 @@ 
 			if ($mValueCount > 0) {
 				sort($mArgs);
 				$count = self::COUNT($mArgs);
-				$index = $entry * ($count-1);
+				$index = $entry * ($count - 1);
 				$iBase = floor($index);
 				if ($index == $iBase) {
 					return $mArgs[$index];
 				} else {
 					$iNext = $iBase + 1;
 					$iProportion = $index - $iBase;
-					return $mArgs[$iBase] + (($mArgs[$iNext] - $mArgs[$iBase]) * $iProportion) ;
+					return $mArgs[$iBase] + (($mArgs[$iNext] - $mArgs[$iBase]) * $iProportion);
 				}
 			}
 		}
@@ -2648,17 +2648,17 @@ 
 	 * @param	number				The number of significant digits for the returned percentage value.
 	 * @return	float
 	 */
-	public static function PERCENTRANK($valueSet,$value,$significance=3) {
-		$valueSet	= PHPExcel_Calculation_Functions::flattenArray($valueSet);
-		$value		= PHPExcel_Calculation_Functions::flattenSingleValue($value);
-		$significance	= (is_null($significance))	? 3 :	(integer) PHPExcel_Calculation_Functions::flattenSingleValue($significance);
+	public static function PERCENTRANK($valueSet, $value, $significance = 3) {
+		$valueSet = PHPExcel_Calculation_Functions::flattenArray($valueSet);
+		$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
+		$significance = (is_null($significance)) ? 3 : (integer) PHPExcel_Calculation_Functions::flattenSingleValue($significance);
 
-		foreach($valueSet as $key => $valueEntry) {
-			if (!is_numeric($valueEntry)) {
+		foreach ($valueSet as $key => $valueEntry) {
+			if ( ! is_numeric($valueEntry)) {
 				unset($valueSet[$key]);
 			}
 		}
-		sort($valueSet,SORT_NUMERIC);
+		sort($valueSet, SORT_NUMERIC);
 		$valueCount = count($valueSet);
 		if ($valueCount == 0) {
 			return PHPExcel_Calculation_Functions::NaN();
@@ -2669,7 +2669,7 @@ 
 			return PHPExcel_Calculation_Functions::NA();
 		}
 
-		$pos = array_search($value,$valueSet);
+		$pos = array_search($value, $valueSet);
 		if ($pos === False) {
 			$pos = 0;
 			$testValue = $valueSet[0];
@@ -2680,7 +2680,7 @@ 
 			$pos += (($value - $valueSet[$pos]) / ($testValue - $valueSet[$pos]));
 		}
 
-		return round($pos / $valueAdjustor,$significance);
+		return round($pos / $valueAdjustor, $significance);
 	}	//	function PERCENTRANK()
 
 
@@ -2697,9 +2697,9 @@ 
 	 * @param	int		$numInSet	Number of objects in each permutation
 	 * @return	int		Number of permutations
 	 */
-	public static function PERMUT($numObjs,$numInSet) {
-		$numObjs	= PHPExcel_Calculation_Functions::flattenSingleValue($numObjs);
-		$numInSet	= PHPExcel_Calculation_Functions::flattenSingleValue($numInSet);
+	public static function PERMUT($numObjs, $numInSet) {
+		$numObjs = PHPExcel_Calculation_Functions::flattenSingleValue($numObjs);
+		$numInSet = PHPExcel_Calculation_Functions::flattenSingleValue($numInSet);
 
 		if ((is_numeric($numObjs)) && (is_numeric($numInSet))) {
 			$numInSet = floor($numInSet);
@@ -2726,8 +2726,8 @@ 
 	 *
 	 */
 	public static function POISSON($value, $mean, $cumulative) {
-		$value	= PHPExcel_Calculation_Functions::flattenSingleValue($value);
-		$mean	= PHPExcel_Calculation_Functions::flattenSingleValue($mean);
+		$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
+		$mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
 
 		if ((is_numeric($value)) && (is_numeric($mean))) {
 			if (($value <= 0) || ($mean <= 0)) {
@@ -2737,11 +2737,11 @@ 
 				if ($cumulative) {
 					$summer = 0;
 					for ($i = 0; $i <= floor($value); ++$i) {
-						$summer += pow($mean,$i) / PHPExcel_Calculation_MathTrig::FACT($i);
+						$summer += pow($mean, $i) / PHPExcel_Calculation_MathTrig::FACT($i);
 					}
-					return exp(0-$mean) * $summer;
+					return exp(0 - $mean) * $summer;
 				} else {
-					return (exp(0-$mean) * pow($mean,$value)) / PHPExcel_Calculation_MathTrig::FACT($value);
+					return (exp(0 - $mean) * pow($mean, $value)) / PHPExcel_Calculation_MathTrig::FACT($value);
 				}
 			}
 		}
@@ -2769,12 +2769,12 @@ 
 		// Calculate
 		$entry = floor(array_pop($aArgs));
 
-		if ((is_numeric($entry)) && (!is_string($entry))) {
+		if ((is_numeric($entry)) && ( ! is_string($entry))) {
 			$entry /= 4;
 			if (($entry < 0) || ($entry > 1)) {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
-			return self::PERCENTILE($aArgs,$entry);
+			return self::PERCENTILE($aArgs, $entry);
 		}
 		return PHPExcel_Calculation_Functions::VALUE();
 	}	//	function QUARTILE()
@@ -2790,23 +2790,23 @@ 
 	 * @param	mixed				Order to sort the values in the value set
 	 * @return	float
 	 */
-	public static function RANK($value,$valueSet,$order=0) {
+	public static function RANK($value, $valueSet, $order = 0) {
 		$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
 		$valueSet = PHPExcel_Calculation_Functions::flattenArray($valueSet);
-		$order	= (is_null($order))	? 0 :	(integer) PHPExcel_Calculation_Functions::flattenSingleValue($order);
+		$order	= (is_null($order)) ? 0 : (integer) PHPExcel_Calculation_Functions::flattenSingleValue($order);
 
-		foreach($valueSet as $key => $valueEntry) {
-			if (!is_numeric($valueEntry)) {
+		foreach ($valueSet as $key => $valueEntry) {
+			if ( ! is_numeric($valueEntry)) {
 				unset($valueSet[$key]);
 			}
 		}
 
 		if ($order == 0) {
-			rsort($valueSet,SORT_NUMERIC);
+			rsort($valueSet, SORT_NUMERIC);
 		} else {
-			sort($valueSet,SORT_NUMERIC);
+			sort($valueSet, SORT_NUMERIC);
 		}
-		$pos = array_search($value,$valueSet);
+		$pos = array_search($value, $valueSet);
 		if ($pos === False) {
 			return PHPExcel_Calculation_Functions::NA();
 		}
@@ -2824,8 +2824,8 @@ 
 	 * @param	array of mixed		Data Series X
 	 * @return	float
 	 */
-	public static function RSQ($yValues,$xValues) {
-		if (!self::_checkTrendArrays($yValues,$xValues)) {
+	public static function RSQ($yValues, $xValues) {
+		if ( ! self::_checkTrendArrays($yValues, $xValues)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 		$yValueCount = count($yValues);
@@ -2837,7 +2837,7 @@ 
 			return PHPExcel_Calculation_Functions::DIV0();
 		}
 
-		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
+		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR, $yValues, $xValues);
 		return $bestFitLinear->getGoodnessOfFit();
 	}	//	function RSQ()
 
@@ -2862,11 +2862,11 @@ 
 		// Loop through arguments
 		foreach ($aArgs as $k => $arg) {
 			if ((is_bool($arg)) &&
-				(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
+				( ! PHPExcel_Calculation_Functions::isMatrixValue($k))) {
 			} else {
 				// Is it a numeric value?
-				if ((is_numeric($arg)) && (!is_string($arg))) {
-					$summer += pow((($arg - $mean) / $stdDev),3) ;
+				if ((is_numeric($arg)) && ( ! is_string($arg))) {
+					$summer += pow((($arg - $mean) / $stdDev), 3);
 					++$count;
 				}
 			}
@@ -2874,7 +2874,7 @@ 
 
 		// Return
 		if ($count > 2) {
-			return $summer * ($count / (($count-1) * ($count-2)));
+			return $summer * ($count / (($count - 1) * ($count - 2)));
 		}
 		return PHPExcel_Calculation_Functions::DIV0();
 	}	//	function SKEW()
@@ -2889,8 +2889,8 @@ 
 	 * @param	array of mixed		Data Series X
 	 * @return	float
 	 */
-	public static function SLOPE($yValues,$xValues) {
-		if (!self::_checkTrendArrays($yValues,$xValues)) {
+	public static function SLOPE($yValues, $xValues) {
+		if ( ! self::_checkTrendArrays($yValues, $xValues)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 		$yValueCount = count($yValues);
@@ -2902,7 +2902,7 @@ 
 			return PHPExcel_Calculation_Functions::DIV0();
 		}
 
-		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
+		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR, $yValues, $xValues);
 		return $bestFitLinear->getSlope();
 	}	//	function SLOPE()
 
@@ -2928,11 +2928,11 @@ 
 		// Calculate
 		$entry = array_pop($aArgs);
 
-		if ((is_numeric($entry)) && (!is_string($entry))) {
+		if ((is_numeric($entry)) && ( ! is_string($entry))) {
 			$mArgs = array();
 			foreach ($aArgs as $arg) {
 				// Is it a numeric value?
-				if ((is_numeric($arg)) && (!is_string($arg))) {
+				if ((is_numeric($arg)) && ( ! is_string($arg))) {
 					$mArgs[] = $arg;
 				}
 			}
@@ -2958,16 +2958,16 @@ 
 	 * @param	float	$stdDev		Standard Deviation
 	 * @return	float	Standardized value
 	 */
-	public static function STANDARDIZE($value,$mean,$stdDev) {
-		$value	= PHPExcel_Calculation_Functions::flattenSingleValue($value);
-		$mean	= PHPExcel_Calculation_Functions::flattenSingleValue($mean);
-		$stdDev	= PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
+	public static function STANDARDIZE($value, $mean, $stdDev) {
+		$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
+		$mean = PHPExcel_Calculation_Functions::flattenSingleValue($mean);
+		$stdDev = PHPExcel_Calculation_Functions::flattenSingleValue($stdDev);
 
 		if ((is_numeric($value)) && (is_numeric($mean)) && (is_numeric($stdDev))) {
 			if ($stdDev <= 0) {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
-			return ($value - $mean) / $stdDev ;
+			return ($value - $mean) / $stdDev;
 		}
 		return PHPExcel_Calculation_Functions::VALUE();
 	}	//	function STANDARDIZE()
@@ -2994,19 +2994,19 @@ 
 		$returnValue = null;
 
 		$aMean = self::AVERAGE($aArgs);
-		if (!is_null($aMean)) {
+		if ( ! is_null($aMean)) {
 			$aCount = -1;
 			foreach ($aArgs as $k => $arg) {
 				if ((is_bool($arg)) &&
-					((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
+					(( ! PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
 					$arg = (integer) $arg;
 				}
 				// Is it a numeric value?
-				if ((is_numeric($arg)) && (!is_string($arg))) {
+				if ((is_numeric($arg)) && ( ! is_string($arg))) {
 					if (is_null($returnValue)) {
-						$returnValue = pow(($arg - $aMean),2);
+						$returnValue = pow(($arg - $aMean), 2);
 					} else {
-						$returnValue += pow(($arg - $aMean),2);
+						$returnValue += pow(($arg - $aMean), 2);
 					}
 					++$aCount;
 				}
@@ -3041,11 +3041,11 @@ 
 		$returnValue = null;
 
 		$aMean = self::AVERAGEA($aArgs);
-		if (!is_null($aMean)) {
+		if ( ! is_null($aMean)) {
 			$aCount = -1;
 			foreach ($aArgs as $k => $arg) {
 				if ((is_bool($arg)) &&
-					(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
+					( ! PHPExcel_Calculation_Functions::isMatrixValue($k))) {
 				} else {
 					// Is it a numeric value?
 					if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {
@@ -3055,9 +3055,9 @@ 
 							$arg = 0;
 						}
 						if (is_null($returnValue)) {
-							$returnValue = pow(($arg - $aMean),2);
+							$returnValue = pow(($arg - $aMean), 2);
 						} else {
-							$returnValue += pow(($arg - $aMean),2);
+							$returnValue += pow(($arg - $aMean), 2);
 						}
 						++$aCount;
 					}
@@ -3093,19 +3093,19 @@ 
 		$returnValue = null;
 
 		$aMean = self::AVERAGE($aArgs);
-		if (!is_null($aMean)) {
+		if ( ! is_null($aMean)) {
 			$aCount = 0;
 			foreach ($aArgs as $k => $arg) {
 				if ((is_bool($arg)) &&
-					((!PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
+					(( ! PHPExcel_Calculation_Functions::isCellValue($k)) || (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE))) {
 					$arg = (integer) $arg;
 				}
 				// Is it a numeric value?
-				if ((is_numeric($arg)) && (!is_string($arg))) {
+				if ((is_numeric($arg)) && ( ! is_string($arg))) {
 					if (is_null($returnValue)) {
-						$returnValue = pow(($arg - $aMean),2);
+						$returnValue = pow(($arg - $aMean), 2);
 					} else {
-						$returnValue += pow(($arg - $aMean),2);
+						$returnValue += pow(($arg - $aMean), 2);
 					}
 					++$aCount;
 				}
@@ -3140,11 +3140,11 @@ 
 		$returnValue = null;
 
 		$aMean = self::AVERAGEA($aArgs);
-		if (!is_null($aMean)) {
+		if ( ! is_null($aMean)) {
 			$aCount = 0;
 			foreach ($aArgs as $k => $arg) {
 				if ((is_bool($arg)) &&
-					(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
+					( ! PHPExcel_Calculation_Functions::isMatrixValue($k))) {
 				} else {
 					// Is it a numeric value?
 					if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {
@@ -3154,9 +3154,9 @@ 
 							$arg = 0;
 						}
 						if (is_null($returnValue)) {
-							$returnValue = pow(($arg - $aMean),2);
+							$returnValue = pow(($arg - $aMean), 2);
 						} else {
-							$returnValue += pow(($arg - $aMean),2);
+							$returnValue += pow(($arg - $aMean), 2);
 						}
 						++$aCount;
 					}
@@ -3181,8 +3181,8 @@ 
 	 * @param	array of mixed		Data Series X
 	 * @return	float
 	 */
-	public static function STEYX($yValues,$xValues) {
-		if (!self::_checkTrendArrays($yValues,$xValues)) {
+	public static function STEYX($yValues, $xValues) {
+		if ( ! self::_checkTrendArrays($yValues, $xValues)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 		$yValueCount = count($yValues);
@@ -3194,7 +3194,7 @@ 
 			return PHPExcel_Calculation_Functions::DIV0();
 		}
 
-		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues);
+		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR, $yValues, $xValues);
 		return $bestFitLinear->getStdevOfResiduals();
 	}	//	function STEYX()
 
@@ -3211,7 +3211,7 @@ 
 	 */
 	public static function TDIST($value, $degrees, $tails) {
 		$value		= PHPExcel_Calculation_Functions::flattenSingleValue($value);
-		$degrees	= floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
+		$degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
 		$tails		= floor(PHPExcel_Calculation_Functions::flattenSingleValue($tails));
 
 		if ((is_numeric($value)) && (is_numeric($degrees)) && (is_numeric($tails))) {
@@ -3228,7 +3228,7 @@ 
 			//	Algorithms", editied by P Griffiths and I D Hill (1985; Ellis
 			//	Horwood Ltd.; W. Sussex, England).
 			$tterm = $degrees;
-			$ttheta = atan2($value,sqrt($tterm));
+			$ttheta = atan2($value, sqrt($tterm));
 			$tc = cos($ttheta);
 			$ts = sin($ttheta);
 			$tsum = 0;
@@ -3270,15 +3270,15 @@ 
 	 * @return	float
 	 */
 	public static function TINV($probability, $degrees) {
-		$probability	= PHPExcel_Calculation_Functions::flattenSingleValue($probability);
-		$degrees		= floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
+		$probability = PHPExcel_Calculation_Functions::flattenSingleValue($probability);
+		$degrees = floor(PHPExcel_Calculation_Functions::flattenSingleValue($degrees));
 
 		if ((is_numeric($probability)) && (is_numeric($degrees))) {
 			$xLo = 100;
 			$xHi = 0;
 
 			$x = $xNew = 1;
-			$dx	= 1;
+			$dx = 1;
 			$i = 0;
 
 			while ((abs($dx) > PRECISION) && ($i++ < MAX_ITERATIONS)) {
@@ -3309,7 +3309,7 @@ 
 			if ($i == MAX_ITERATIONS) {
 				return PHPExcel_Calculation_Functions::NA();
 			}
-			return round($x,12);
+			return round($x, 12);
 		}
 		return PHPExcel_Calculation_Functions::VALUE();
 	}	//	function TINV()
@@ -3326,19 +3326,19 @@ 
 	 * @param	boolean				A logical value specifying whether to force the intersect to equal 0.
 	 * @return	array of float
 	 */
-	public static function TREND($yValues,$xValues=array(),$newValues=array(),$const=True) {
+	public static function TREND($yValues, $xValues = array(), $newValues = array(), $const = True) {
 		$yValues = PHPExcel_Calculation_Functions::flattenArray($yValues);
 		$xValues = PHPExcel_Calculation_Functions::flattenArray($xValues);
 		$newValues = PHPExcel_Calculation_Functions::flattenArray($newValues);
-		$const	= (is_null($const))	? True :	(boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
+		$const = (is_null($const)) ? True : (boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
 
-		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR,$yValues,$xValues,$const);
+		$bestFitLinear = trendClass::calculate(trendClass::TREND_LINEAR, $yValues, $xValues, $const);
 		if (empty($newValues)) {
 			$newValues = $bestFitLinear->getXValues();
 		}
 
 		$returnArray = array();
-		foreach($newValues as $xValue) {
+		foreach ($newValues as $xValue) {
 			$returnArray[0][] = $bestFitLinear->getValueOfYForX($xValue);
 		}
 
@@ -3368,20 +3368,20 @@ 
 		// Calculate
 		$percent = array_pop($aArgs);
 
-		if ((is_numeric($percent)) && (!is_string($percent))) {
+		if ((is_numeric($percent)) && ( ! is_string($percent))) {
 			if (($percent < 0) || ($percent > 1)) {
 				return PHPExcel_Calculation_Functions::NaN();
 			}
 			$mArgs = array();
 			foreach ($aArgs as $arg) {
 				// Is it a numeric value?
-				if ((is_numeric($arg)) && (!is_string($arg))) {
+				if ((is_numeric($arg)) && ( ! is_string($arg))) {
 					$mArgs[] = $arg;
 				}
 			}
 			$discard = floor(self::COUNT($mArgs) * $percent / 2);
 			sort($mArgs);
-			for ($i=0; $i < $discard; ++$i) {
+			for ($i = 0; $i < $discard; ++$i) {
 				array_pop($mArgs);
 				array_shift($mArgs);
 			}
@@ -3416,7 +3416,7 @@ 
 		foreach ($aArgs as $arg) {
 			if (is_bool($arg)) { $arg = (integer) $arg; }
 			// Is it a numeric value?
-			if ((is_numeric($arg)) && (!is_string($arg))) {
+			if ((is_numeric($arg)) && ( ! is_string($arg))) {
 				$summerA += ($arg * $arg);
 				$summerB += $arg;
 				++$aCount;
@@ -3460,7 +3460,7 @@ 
 				(PHPExcel_Calculation_Functions::isValue($k))) {
 				return PHPExcel_Calculation_Functions::VALUE();
 			} elseif ((is_string($arg)) &&
-				(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
+				( ! PHPExcel_Calculation_Functions::isMatrixValue($k))) {
 			} else {
 				// Is it a numeric value?
 				if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {
@@ -3511,7 +3511,7 @@ 
 		foreach ($aArgs as $arg) {
 			if (is_bool($arg)) { $arg = (integer) $arg; }
 			// Is it a numeric value?
-			if ((is_numeric($arg)) && (!is_string($arg))) {
+			if ((is_numeric($arg)) && ( ! is_string($arg))) {
 				$summerA += ($arg * $arg);
 				$summerB += $arg;
 				++$aCount;
@@ -3555,7 +3555,7 @@ 
 				(PHPExcel_Calculation_Functions::isValue($k))) {
 				return PHPExcel_Calculation_Functions::VALUE();
 			} elseif ((is_string($arg)) &&
-				(!PHPExcel_Calculation_Functions::isMatrixValue($k))) {
+				( ! PHPExcel_Calculation_Functions::isMatrixValue($k))) {
 			} else {
 				// Is it a numeric value?
 				if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) & ($arg != '')))) {
@@ -3597,7 +3597,7 @@ 
 	public static function WEIBULL($value, $alpha, $beta, $cumulative) {
 		$value	= PHPExcel_Calculation_Functions::flattenSingleValue($value);
 		$alpha	= PHPExcel_Calculation_Functions::flattenSingleValue($alpha);
-		$beta	= PHPExcel_Calculation_Functions::flattenSingleValue($beta);
+		$beta = PHPExcel_Calculation_Functions::flattenSingleValue($beta);
 
 		if ((is_numeric($value)) && (is_numeric($alpha)) && (is_numeric($beta))) {
 			if (($value < 0) || ($alpha <= 0) || ($beta <= 0)) {
@@ -3605,9 +3605,9 @@ 
 			}
 			if ((is_numeric($cumulative)) || (is_bool($cumulative))) {
 				if ($cumulative) {
-					return 1 - exp(0 - pow($value / $beta,$alpha));
+					return 1 - exp(0 - pow($value / $beta, $alpha));
 				} else {
-					return ($alpha / pow($beta,$alpha)) * pow($value,$alpha - 1) * exp(0 - pow($value / $beta,$alpha));
+					return ($alpha / pow($beta, $alpha)) * pow($value, $alpha - 1) * exp(0 - pow($value / $beta, $alpha));
 				}
 			}
 		}
@@ -3628,9 +3628,9 @@ 
 	 * @return	float
 	 *
 	 */
-	public static function ZTEST($dataSet, $m0, $sigma=null) {
-		$dataSet	= PHPExcel_Calculation_Functions::flattenArrayIndexed($dataSet);
-		$m0			= PHPExcel_Calculation_Functions::flattenSingleValue($m0);
+	public static function ZTEST($dataSet, $m0, $sigma = null) {
+		$dataSet = PHPExcel_Calculation_Functions::flattenArrayIndexed($dataSet);
+		$m0 = PHPExcel_Calculation_Functions::flattenSingleValue($m0);
 		$sigma		= PHPExcel_Calculation_Functions::flattenSingleValue($sigma);
 
 		if (is_null($sigma)) {
@@ -3638,7 +3638,7 @@ 
 		}
 		$n = count($dataSet);
 
-		return 1 - self::NORMSDIST((self::AVERAGE($dataSet) - $m0)/($sigma/SQRT($n)));
+		return 1 - self::NORMSDIST((self::AVERAGE($dataSet) - $m0) / ($sigma / SQRT($n)));
 	}	//	function ZTEST()
 
 }	//	class PHPExcel_Calculation_Statistical

Braces +12 added lines, -5 removed lines

@@ -396,8 +396,9 @@ 
 			if ($y <= $lg_frtbig) {
 				$res = $lg_c[6];
 				$ysq = $y * $y;
-				for ($i = 0; $i < 6; ++$i)
-					$res = $res / $ysq + $lg_c[$i];
+				for ($i = 0; $i < 6; ++$i) {
+									$res = $res / $ysq + $lg_c[$i];
+				}
 				}
 				$res /= $y;
 				$corr = log($y);
@@ -440,7 +441,9 @@ 
 	//	Private implementation of the Gamma function
 	//
 	private static function _gamma($data) {
-		if ($data == 0.0) return 0;
+		if ($data == 0.0) {
+			return 0;
+		}
 
 		static $p0 = 1.000000000190015;
 		static $p = array ( 1 => 76.18009172947146,
@@ -1957,7 +1960,9 @@ 
 	public static function LINEST($yValues,$xValues=null,$const=True,$stats=False) {
 		$const	= (is_null($const))	? True :	(boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
 		$stats	= (is_null($stats))	? False :	(boolean) PHPExcel_Calculation_Functions::flattenSingleValue($stats);
-		if (is_null($xValues)) $xValues = range(1,count(PHPExcel_Calculation_Functions::flattenArray($yValues)));
+		if (is_null($xValues)) {
+			$xValues = range(1,count(PHPExcel_Calculation_Functions::flattenArray($yValues)));
+		}
 
 		if (!self::_checkTrendArrays($yValues,$xValues)) {
 			return PHPExcel_Calculation_Functions::VALUE();
@@ -2010,7 +2015,9 @@ 
 	public static function LOGEST($yValues,$xValues=null,$const=True,$stats=False) {
 		$const	= (is_null($const))	? True :	(boolean) PHPExcel_Calculation_Functions::flattenSingleValue($const);
 		$stats	= (is_null($stats))	? False :	(boolean) PHPExcel_Calculation_Functions::flattenSingleValue($stats);
-		if (is_null($xValues)) $xValues = range(1,count(PHPExcel_Calculation_Functions::flattenArray($yValues)));
+		if (is_null($xValues)) {
+			$xValues = range(1,count(PHPExcel_Calculation_Functions::flattenArray($yValues)));
+		}
 
 		if (!self::_checkTrendArrays($yValues,$xValues)) {
 			return PHPExcel_Calculation_Functions::VALUE();