reginaldojunior / winners

app/Vendor/PHPExcel/PHPExcel/CachedObjectStorage/SQLite.php

Doc Comments +1 added lines, -1 removed lines

@@ -73,7 +73,7 @@
      *
      * @param	string			$pCoord		Coordinate address of the cell to update
      * @param	PHPExcel_Cell	$cell		Cell to update
-	 * @return	void
+	 * @return	PHPExcel_Cell
      * @throws	Exception
      */
 	public function addCacheData($pCoord, PHPExcel_Cell $cell) {

Indentation +26 added lines, -26 removed lines

@@ -49,13 +49,13 @@ 
 	 */
 	private $_DBHandle = null;
 
-    /**
-     * Store cell data in cache for the current cell object if it's "dirty",
-     *     and the 'nullify' the current cell object
-     *
+	/**
+	 * Store cell data in cache for the current cell object if it's "dirty",
+	 *     and the 'nullify' the current cell object
+	 *
 	 * @return	void
-     * @throws	Exception
-     */
+	 * @throws	Exception
+	 */
 	private function _storeData() {
 		if ($this->_currentCellIsDirty) {
 			$this->_currentObject->detach();
@@ -68,14 +68,14 @@ 
 	}	//	function _storeData()
 
 
-    /**
-     * Add or Update a cell in cache identified by coordinate address
-     *
-     * @param	string			$pCoord		Coordinate address of the cell to update
-     * @param	PHPExcel_Cell	$cell		Cell to update
+	/**
+	 * Add or Update a cell in cache identified by coordinate address
+	 *
+	 * @param	string			$pCoord		Coordinate address of the cell to update
+	 * @param	PHPExcel_Cell	$cell		Cell to update
 	 * @return	void
-     * @throws	Exception
-     */
+	 * @throws	Exception
+	 */
 	public function addCacheData($pCoord, PHPExcel_Cell $cell) {
 		if (($pCoord !== $this->_currentObjectID) && ($this->_currentObjectID !== null)) {
 			$this->_storeData();
@@ -89,13 +89,13 @@ 
 	}	//	function addCacheData()
 
 
-    /**
-     * Get cell at a specific coordinate
-     *
-     * @param 	string 			$pCoord		Coordinate of the cell
-     * @throws 	Exception
-     * @return 	PHPExcel_Cell 	Cell that was found, or null if not found
-     */
+	/**
+	 * Get cell at a specific coordinate
+	 *
+	 * @param 	string 			$pCoord		Coordinate of the cell
+	 * @throws 	Exception
+	 * @return 	PHPExcel_Cell 	Cell that was found, or null if not found
+	 */
 	public function getCacheData($pCoord) {
 		if ($pCoord === $this->_currentObjectID) {
 			return $this->_currentObject;
@@ -148,12 +148,12 @@ 
 	}	//	function isDataSet()
 
 
-    /**
-     * Delete a cell in cache identified by coordinate address
-     *
-     * @param	string			$pCoord		Coordinate address of the cell to delete
-     * @throws	Exception
-     */
+	/**
+	 * Delete a cell in cache identified by coordinate address
+	 *
+	 * @param	string			$pCoord		Coordinate address of the cell to delete
+	 * @throws	Exception
+	 */
 	public function deleteCacheData($pCoord) {
 		if ($pCoord === $this->_currentObjectID) {
 			$this->_currentObject->detach();

Spacing +12 added lines, -12 removed lines

@@ -60,7 +60,7 @@ 
 		if ($this->_currentCellIsDirty) {
 			$this->_currentObject->detach();
 
-			if (!$this->_DBHandle->queryExec("INSERT OR REPLACE INTO kvp_".$this->_TableName." VALUES('".$this->_currentObjectID."','".sqlite_escape_string(serialize($this->_currentObject))."')"))
+			if ( ! $this->_DBHandle->queryExec("INSERT OR REPLACE INTO kvp_".$this->_TableName." VALUES('".$this->_currentObjectID."','".sqlite_escape_string(serialize($this->_currentObject))."')"))
 				throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
 			$this->_currentCellIsDirty = false;
 		}
@@ -103,7 +103,7 @@ 
 		$this->_storeData();
 
 		$query = "SELECT value FROM kvp_".$this->_TableName." WHERE id='".$pCoord."'";
-		$cellResultSet = $this->_DBHandle->query($query,SQLITE_ASSOC);
+		$cellResultSet = $this->_DBHandle->query($query, SQLITE_ASSOC);
 		if ($cellResultSet === false) {
 			throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
 		} elseif ($cellResultSet->numRows() == 0) {
@@ -137,7 +137,7 @@ 
 
 		//	Check if the requested entry exists in the cache
 		$query = "SELECT id FROM kvp_".$this->_TableName." WHERE id='".$pCoord."'";
-		$cellResultSet = $this->_DBHandle->query($query,SQLITE_ASSOC);
+		$cellResultSet = $this->_DBHandle->query($query, SQLITE_ASSOC);
 		if ($cellResultSet === false) {
 			throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
 		} elseif ($cellResultSet->numRows() == 0) {
@@ -162,7 +162,7 @@ 
 
 		//	Check if the requested entry exists in the cache
 		$query = "DELETE FROM kvp_".$this->_TableName." WHERE id='".$pCoord."'";
-		if (!$this->_DBHandle->queryExec($query))
+		if ( ! $this->_DBHandle->queryExec($query))
 			throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
 
 		$this->_currentCellIsDirty = false;
@@ -176,12 +176,12 @@ 
 	 */
 	public function getCellList() {
 		$query = "SELECT id FROM kvp_".$this->_TableName;
-		$cellIdsResult = $this->_DBHandle->unbufferedQuery($query,SQLITE_ASSOC);
+		$cellIdsResult = $this->_DBHandle->unbufferedQuery($query, SQLITE_ASSOC);
 		if ($cellIdsResult === false)
 			throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
 
 		$cellKeys = array();
-		foreach($cellIdsResult as $row) {
+		foreach ($cellIdsResult as $row) {
 			$cellKeys[] = $row['id'];
 		}
 
@@ -197,8 +197,8 @@ 
 	 */
 	public function copyCellCollection(PHPExcel_Worksheet $parent) {
 		//	Get a new id for the new table name
-		$tableName = str_replace('.','_',$this->_getUniqueID());
-		if (!$this->_DBHandle->queryExec('CREATE TABLE kvp_'.$tableName.' (id VARCHAR(12) PRIMARY KEY, value BLOB)
+		$tableName = str_replace('.', '_', $this->_getUniqueID());
+		if ( ! $this->_DBHandle->queryExec('CREATE TABLE kvp_'.$tableName.' (id VARCHAR(12) PRIMARY KEY, value BLOB)
 													AS SELECT * FROM kvp_'.$this->_TableName))
 			throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
 
@@ -213,7 +213,7 @@ 
 	 * @return	void
 	 */
 	public function unsetWorksheetCells() {
-		if(!is_null($this->_currentObject)) {
+		if ( ! is_null($this->_currentObject)) {
 			$this->_currentObject->detach();
 			$this->_currentObject = $this->_currentObjectID = null;
 		}
@@ -233,13 +233,13 @@ 
 	public function __construct(PHPExcel_Worksheet $parent) {
 		parent::__construct($parent);
 		if (is_null($this->_DBHandle)) {
-			$this->_TableName = str_replace('.','_',$this->_getUniqueID());
+			$this->_TableName = str_replace('.', '_', $this->_getUniqueID());
 			$_DBName = ':memory:';
 
 			$this->_DBHandle = new SQLiteDatabase($_DBName);
 			if ($this->_DBHandle === false)
 				throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
-			if (!$this->_DBHandle->queryExec('CREATE TABLE kvp_'.$this->_TableName.' (id VARCHAR(12) PRIMARY KEY, value BLOB)'))
+			if ( ! $this->_DBHandle->queryExec('CREATE TABLE kvp_'.$this->_TableName.' (id VARCHAR(12) PRIMARY KEY, value BLOB)'))
 				throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
 		}
 	}	//	function __construct()
@@ -260,7 +260,7 @@ 
 	 * @return	boolean
 	 */
 	public static function cacheMethodIsAvailable() {
-		if (!function_exists('sqlite_open')) {
+		if ( ! function_exists('sqlite_open')) {
 			return false;
 		}
 

Braces +18 added lines, -12 removed lines

@@ -60,8 +60,9 @@ 
 		if ($this->_currentCellIsDirty) {
 			$this->_currentObject->detach();
 
-			if (!$this->_DBHandle->queryExec("INSERT OR REPLACE INTO kvp_".$this->_TableName." VALUES('".$this->_currentObjectID."','".sqlite_escape_string(serialize($this->_currentObject))."')"))
-				throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
+			if (!$this->_DBHandle->queryExec("INSERT OR REPLACE INTO kvp_".$this->_TableName." VALUES('".$this->_currentObjectID."','".sqlite_escape_string(serialize($this->_currentObject))."')")) {
+							throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
+			}
 			$this->_currentCellIsDirty = false;
 		}
 		$this->_currentObjectID = $this->_currentObject = null;
@@ -162,8 +163,9 @@ 
 
 		//	Check if the requested entry exists in the cache
 		$query = "DELETE FROM kvp_".$this->_TableName." WHERE id='".$pCoord."'";
-		if (!$this->_DBHandle->queryExec($query))
-			throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
+		if (!$this->_DBHandle->queryExec($query)) {
+					throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
+		}
 
 		$this->_currentCellIsDirty = false;
 	}	//	function deleteCacheData()
@@ -177,8 +179,9 @@ 
 	public function getCellList() {
 		$query = "SELECT id FROM kvp_".$this->_TableName;
 		$cellIdsResult = $this->_DBHandle->unbufferedQuery($query,SQLITE_ASSOC);
-		if ($cellIdsResult === false)
-			throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
+		if ($cellIdsResult === false) {
+					throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
+		}
 
 		$cellKeys = array();
 		foreach($cellIdsResult as $row) {
@@ -199,8 +202,9 @@ 
 		//	Get a new id for the new table name
 		$tableName = str_replace('.','_',$this->_getUniqueID());
 		if (!$this->_DBHandle->queryExec('CREATE TABLE kvp_'.$tableName.' (id VARCHAR(12) PRIMARY KEY, value BLOB)
-													AS SELECT * FROM kvp_'.$this->_TableName))
-			throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
+													AS SELECT * FROM kvp_'.$this->_TableName)) {
+					throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
+		}
 
 		//	Copy the existing cell cache file
 		$this->_TableName = $tableName;
@@ -237,10 +241,12 @@ 
 			$_DBName = ':memory:';
 
 			$this->_DBHandle = new SQLiteDatabase($_DBName);
-			if ($this->_DBHandle === false)
-				throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
-			if (!$this->_DBHandle->queryExec('CREATE TABLE kvp_'.$this->_TableName.' (id VARCHAR(12) PRIMARY KEY, value BLOB)'))
-				throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
+			if ($this->_DBHandle === false) {
+							throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
+			}
+			if (!$this->_DBHandle->queryExec('CREATE TABLE kvp_'.$this->_TableName.' (id VARCHAR(12) PRIMARY KEY, value BLOB)')) {
+							throw new Exception(sqlite_error_string($this->_DBHandle->lastError()));
+			}
 		}
 	}	//	function __construct()
 

app/Vendor/PHPExcel/PHPExcel/CachedObjectStorage/SQLite3.php

Doc Comments +1 added lines, -1 removed lines

@@ -77,7 +77,7 @@
      *
      * @param	string			$pCoord		Coordinate address of the cell to update
      * @param	PHPExcel_Cell	$cell		Cell to update
-	 * @return	void
+	 * @return	PHPExcel_Cell
      * @throws	Exception
      */
 	public function addCacheData($pCoord, PHPExcel_Cell $cell) {

Indentation +26 added lines, -26 removed lines

@@ -49,13 +49,13 @@ 
 	 */
 	private $_DBHandle = null;
 
-    /**
-     * Store cell data in cache for the current cell object if it's "dirty",
-     *     and the 'nullify' the current cell object
-     *
+	/**
+	 * Store cell data in cache for the current cell object if it's "dirty",
+	 *     and the 'nullify' the current cell object
+	 *
 	 * @return	void
-     * @throws	Exception
-     */
+	 * @throws	Exception
+	 */
 	private function _storeData() {
 		if ($this->_currentCellIsDirty) {
 			$this->_currentObject->detach();
@@ -72,14 +72,14 @@ 
 	}	//	function _storeData()
 
 
-    /**
-     * Add or Update a cell in cache identified by coordinate address
-     *
-     * @param	string			$pCoord		Coordinate address of the cell to update
-     * @param	PHPExcel_Cell	$cell		Cell to update
+	/**
+	 * Add or Update a cell in cache identified by coordinate address
+	 *
+	 * @param	string			$pCoord		Coordinate address of the cell to update
+	 * @param	PHPExcel_Cell	$cell		Cell to update
 	 * @return	void
-     * @throws	Exception
-     */
+	 * @throws	Exception
+	 */
 	public function addCacheData($pCoord, PHPExcel_Cell $cell) {
 		if (($pCoord !== $this->_currentObjectID) && ($this->_currentObjectID !== null)) {
 			$this->_storeData();
@@ -93,13 +93,13 @@ 
 	}	//	function addCacheData()
 
 
-    /**
-     * Get cell at a specific coordinate
-     *
-     * @param 	string 			$pCoord		Coordinate of the cell
-     * @throws 	Exception
-     * @return 	PHPExcel_Cell 	Cell that was found, or null if not found
-     */
+	/**
+	 * Get cell at a specific coordinate
+	 *
+	 * @param 	string 			$pCoord		Coordinate of the cell
+	 * @throws 	Exception
+	 * @return 	PHPExcel_Cell 	Cell that was found, or null if not found
+	 */
 	public function getCacheData($pCoord) {
 		if ($pCoord === $this->_currentObjectID) {
 			return $this->_currentObject;
@@ -151,12 +151,12 @@ 
 	}	//	function isDataSet()
 
 
-    /**
-     *	Delete a cell in cache identified by coordinate address
-     *
-     * @param	string			$pCoord		Coordinate address of the cell to delete
-     * @throws	Exception
-     */
+	/**
+	 *	Delete a cell in cache identified by coordinate address
+	 *
+	 * @param	string			$pCoord		Coordinate address of the cell to delete
+	 * @throws	Exception
+	 */
 	public function deleteCacheData($pCoord) {
 		if ($pCoord === $this->_currentObjectID) {
 			$this->_currentObject->detach();

Spacing +9 added lines, -9 removed lines

@@ -61,8 +61,8 @@ 
 			$this->_currentObject->detach();
 
 			$query = $this->_DBHandle->prepare("INSERT OR REPLACE INTO kvp_".$this->_TableName." VALUES(:id,:data)");
-			$query->bindValue('id',$this->_currentObjectID,SQLITE3_TEXT);
-			$query->bindValue('data',serialize($this->_currentObject),SQLITE3_BLOB);
+			$query->bindValue('id', $this->_currentObjectID, SQLITE3_TEXT);
+			$query->bindValue('data', serialize($this->_currentObject), SQLITE3_BLOB);
 			$result = $query->execute();
 			if ($result === false)
 				throw new Exception($this->_DBHandle->lastErrorMsg());
@@ -201,8 +201,8 @@ 
 	 */
 	public function copyCellCollection(PHPExcel_Worksheet $parent) {
 		//	Get a new id for the new table name
-		$tableName = str_replace('.','_',$this->_getUniqueID());
-		if (!$this->_DBHandle->exec('CREATE TABLE kvp_'.$tableName.' (id VARCHAR(12) PRIMARY KEY, value BLOB)
+		$tableName = str_replace('.', '_', $this->_getUniqueID());
+		if ( ! $this->_DBHandle->exec('CREATE TABLE kvp_'.$tableName.' (id VARCHAR(12) PRIMARY KEY, value BLOB)
 		                                       AS SELECT * FROM kvp_'.$this->_TableName))
 			throw new Exception($this->_DBHandle->lastErrorMsg());
 
@@ -217,7 +217,7 @@ 
 	 * @return	void
 	 */
 	public function unsetWorksheetCells() {
-		if(!is_null($this->_currentObject)) {
+		if ( ! is_null($this->_currentObject)) {
 			$this->_currentObject->detach();
 			$this->_currentObject = $this->_currentObjectID = null;
 		}
@@ -237,13 +237,13 @@ 
 	public function __construct(PHPExcel_Worksheet $parent) {
 		parent::__construct($parent);
 		if (is_null($this->_DBHandle)) {
-			$this->_TableName = str_replace('.','_',$this->_getUniqueID());
+			$this->_TableName = str_replace('.', '_', $this->_getUniqueID());
 			$_DBName = ':memory:';
 
 			$this->_DBHandle = new SQLite3($_DBName);
 			if ($this->_DBHandle === false)
 				throw new Exception($this->_DBHandle->lastErrorMsg());
-			if (!$this->_DBHandle->exec('CREATE TABLE kvp_'.$this->_TableName.' (id VARCHAR(12) PRIMARY KEY, value BLOB)'))
+			if ( ! $this->_DBHandle->exec('CREATE TABLE kvp_'.$this->_TableName.' (id VARCHAR(12) PRIMARY KEY, value BLOB)'))
 				throw new Exception($this->_DBHandle->lastErrorMsg());
 		}
 	}	//	function __construct()
@@ -253,7 +253,7 @@ 
 	 * Destroy this cell collection
 	 */
 	public function __destruct() {
-		if (!is_null($this->_DBHandle)) {
+		if ( ! is_null($this->_DBHandle)) {
 			$this->_DBHandle->close();
 		}
 		$this->_DBHandle = null;
@@ -267,7 +267,7 @@ 
 	 * @return	boolean
 	 */
 	public static function cacheMethodIsAvailable() {
-		if (!class_exists('SQLite3')) {
+		if ( ! class_exists('SQLite3')) {
 			return false;
 		}
 

Braces +18 added lines, -12 removed lines

@@ -64,8 +64,9 @@ 
 			$query->bindValue('id',$this->_currentObjectID,SQLITE3_TEXT);
 			$query->bindValue('data',serialize($this->_currentObject),SQLITE3_BLOB);
 			$result = $query->execute();
-			if ($result === false)
-				throw new Exception($this->_DBHandle->lastErrorMsg());
+			if ($result === false) {
+							throw new Exception($this->_DBHandle->lastErrorMsg());
+			}
 			$this->_currentCellIsDirty = false;
 		}
 		$this->_currentObjectID = $this->_currentObject = null;
@@ -166,8 +167,9 @@ 
 		//	Check if the requested entry exists in the cache
 		$query = "DELETE FROM kvp_".$this->_TableName." WHERE id='".$pCoord."'";
 		$result = $this->_DBHandle->exec($query);
-		if ($result === false)
-			throw new Exception($this->_DBHandle->lastErrorMsg());
+		if ($result === false) {
+					throw new Exception($this->_DBHandle->lastErrorMsg());
+		}
 
 		$this->_currentCellIsDirty = false;
 	}	//	function deleteCacheData()
@@ -181,8 +183,9 @@ 
 	public function getCellList() {
 		$query = "SELECT id FROM kvp_".$this->_TableName;
 		$cellIdsResult = $this->_DBHandle->query($query);
-		if ($cellIdsResult === false)
-			throw new Exception($this->_DBHandle->lastErrorMsg());
+		if ($cellIdsResult === false) {
+					throw new Exception($this->_DBHandle->lastErrorMsg());
+		}
 
 		$cellKeys = array();
 		while ($row = $cellIdsResult->fetchArray(SQLITE3_ASSOC)) {
@@ -203,8 +206,9 @@ 
 		//	Get a new id for the new table name
 		$tableName = str_replace('.','_',$this->_getUniqueID());
 		if (!$this->_DBHandle->exec('CREATE TABLE kvp_'.$tableName.' (id VARCHAR(12) PRIMARY KEY, value BLOB)
-		                                       AS SELECT * FROM kvp_'.$this->_TableName))
-			throw new Exception($this->_DBHandle->lastErrorMsg());
+		                                       AS SELECT * FROM kvp_'.$this->_TableName)) {
+					throw new Exception($this->_DBHandle->lastErrorMsg());
+		}
 
 		//	Copy the existing cell cache file
 		$this->_TableName = $tableName;
@@ -241,10 +245,12 @@ 
 			$_DBName = ':memory:';
 
 			$this->_DBHandle = new SQLite3($_DBName);
-			if ($this->_DBHandle === false)
-				throw new Exception($this->_DBHandle->lastErrorMsg());
-			if (!$this->_DBHandle->exec('CREATE TABLE kvp_'.$this->_TableName.' (id VARCHAR(12) PRIMARY KEY, value BLOB)'))
-				throw new Exception($this->_DBHandle->lastErrorMsg());
+			if ($this->_DBHandle === false) {
+							throw new Exception($this->_DBHandle->lastErrorMsg());
+			}
+			if (!$this->_DBHandle->exec('CREATE TABLE kvp_'.$this->_TableName.' (id VARCHAR(12) PRIMARY KEY, value BLOB)')) {
+							throw new Exception($this->_DBHandle->lastErrorMsg());
+			}
 		}
 	}	//	function __construct()
 

app/Vendor/PHPExcel/PHPExcel/CachedObjectStorage/Wincache.php

Doc Comments +1 added lines, -1 removed lines

@@ -85,7 +85,7 @@
 	 *
 	 * @param	string			$pCoord		Coordinate address of the cell to update
 	 * @param	PHPExcel_Cell	$cell		Cell to update
-	 * @return	void
+	 * @return	PHPExcel_Cell
 	 * @throws	Exception
 	 */
 	public function addCacheData($pCoord, PHPExcel_Cell $cell) {

Indentation +6 added lines, -6 removed lines

@@ -50,13 +50,13 @@
 	private $_cacheTime = 600;
 
 
-    /**
-     * Store cell data in cache for the current cell object if it's "dirty",
-     *     and the 'nullify' the current cell object
-     *
+	/**
+	 * Store cell data in cache for the current cell object if it's "dirty",
+	 *     and the 'nullify' the current cell object
+	 *
 	 * @return	void
-     * @throws	Exception
-     */
+	 * @throws	Exception
+	 */
 	private function _storeData() {
 		if ($this->_currentCellIsDirty) {
 			$this->_currentObject->detach();

Spacing +10 added lines, -10 removed lines

@@ -63,12 +63,12 @@ 
 
 			$obj = serialize($this->_currentObject);
 			if (wincache_ucache_exists($this->_cachePrefix.$this->_currentObjectID.'.cache')) {
-				if (!wincache_ucache_set($this->_cachePrefix.$this->_currentObjectID.'.cache', $obj, $this->_cacheTime)) {
+				if ( ! wincache_ucache_set($this->_cachePrefix.$this->_currentObjectID.'.cache', $obj, $this->_cacheTime)) {
 					$this->__destruct();
 					throw new Exception('Failed to store cell '.$this->_currentObjectID.' in WinCache');
 				}
 			} else {
-				if (!wincache_ucache_add($this->_cachePrefix.$this->_currentObjectID.'.cache', $obj, $this->_cacheTime)) {
+				if ( ! wincache_ucache_add($this->_cachePrefix.$this->_currentObjectID.'.cache', $obj, $this->_cacheTime)) {
 					$this->__destruct();
 					throw new Exception('Failed to store cell '.$this->_currentObjectID.' in WinCache');
 				}
@@ -191,9 +191,9 @@ 
 		parent::copyCellCollection($parent);
 		//	Get a new id for the new file name
 		$baseUnique = $this->_getUniqueID();
-		$newCachePrefix = substr(md5($baseUnique),0,8).'.';
+		$newCachePrefix = substr(md5($baseUnique), 0, 8).'.';
 		$cacheList = $this->getCellList();
-		foreach($cacheList as $cellID) {
+		foreach ($cacheList as $cellID) {
 			if ($cellID != $this->_currentObjectID) {
 				$success = false;
 				$obj = wincache_ucache_get($this->_cachePrefix.$cellID.'.cache', $success);
@@ -202,7 +202,7 @@ 
 					parent::deleteCacheData($cellID);
 					throw new Exception('Cell entry '.$cellID.' no longer exists in Wincache');
 				}
-				if (!wincache_ucache_add($newCachePrefix.$cellID.'.cache', $obj, $this->_cacheTime)) {
+				if ( ! wincache_ucache_add($newCachePrefix.$cellID.'.cache', $obj, $this->_cacheTime)) {
 					$this->__destruct();
 					throw new Exception('Failed to store cell '.$cellID.' in Wincache');
 				}
@@ -218,7 +218,7 @@ 
 	 * @return	void
 	 */
 	public function unsetWorksheetCells() {
-		if(!is_null($this->_currentObject)) {
+		if ( ! is_null($this->_currentObject)) {
 			$this->_currentObject->detach();
 			$this->_currentObject = $this->_currentObjectID = null;
 		}
@@ -240,11 +240,11 @@ 
 	 * @param	array of mixed		$arguments	Additional initialisation arguments
 	 */
 	public function __construct(PHPExcel_Worksheet $parent, $arguments) {
-		$cacheTime	= (isset($arguments['cacheTime']))	? $arguments['cacheTime']	: 600;
+		$cacheTime = (isset($arguments['cacheTime'])) ? $arguments['cacheTime'] : 600;
 
 		if (is_null($this->_cachePrefix)) {
 			$baseUnique = $this->_getUniqueID();
-			$this->_cachePrefix = substr(md5($baseUnique),0,8).'.';
+			$this->_cachePrefix = substr(md5($baseUnique), 0, 8).'.';
 			$this->_cacheTime = $cacheTime;
 
 			parent::__construct($parent);
@@ -257,7 +257,7 @@ 
 	 */
 	public function __destruct() {
 		$cacheList = $this->getCellList();
-		foreach($cacheList as $cellID) {
+		foreach ($cacheList as $cellID) {
 			wincache_ucache_delete($this->_cachePrefix.$cellID.'.cache');
 		}
 	}	//	function __destruct()
@@ -270,7 +270,7 @@ 
 	 * @return	boolean
 	 */
 	public static function cacheMethodIsAvailable() {
-		if (!function_exists('wincache_ucache_add')) {
+		if ( ! function_exists('wincache_ucache_add')) {
 			return false;
 		}
 

app/Vendor/PHPExcel/PHPExcel/CachedObjectStorageFactory.php

Doc Comments +1 added lines, -1 removed lines

@@ -142,7 +142,7 @@
 	/**
 	 * Return the current cache storage class
 	 *
-	 * @return PHPExcel_CachedObjectStorage_ICache|NULL
+	 * @return string|null
 	 **/
 	public static function getCacheStorageClass()
 	{

Spacing +18 added lines, -18 removed lines

@@ -36,16 +36,16 @@ 
  */
 class PHPExcel_CachedObjectStorageFactory
 {
-	const cache_in_memory				= 'Memory';
-	const cache_in_memory_gzip			= 'MemoryGZip';
-	const cache_in_memory_serialized	= 'MemorySerialized';
-	const cache_igbinary				= 'Igbinary';
+	const cache_in_memory = 'Memory';
+	const cache_in_memory_gzip = 'MemoryGZip';
+	const cache_in_memory_serialized = 'MemorySerialized';
+	const cache_igbinary = 'Igbinary';
 	const cache_to_discISAM				= 'DiscISAM';
-	const cache_to_apc					= 'APC';
+	const cache_to_apc = 'APC';
 	const cache_to_memcache				= 'Memcache';
 	const cache_to_phpTemp				= 'PHPTemp';
 	const cache_to_wincache				= 'Wincache';
-	const cache_to_sqlite				= 'SQLite';
+	const cache_to_sqlite = 'SQLite';
 	const cache_to_sqlite3				= 'SQLite3';
 
 
@@ -98,17 +98,17 @@ 
 													),
 		self::cache_igbinary				=> array(
 													),
-		self::cache_to_phpTemp				=> array( 'memoryCacheSize'	=> '1MB'
+		self::cache_to_phpTemp				=> array('memoryCacheSize'	=> '1MB'
 													),
-		self::cache_to_discISAM				=> array( 'dir'				=> NULL
+		self::cache_to_discISAM				=> array('dir'				=> NULL
 													),
-		self::cache_to_apc					=> array( 'cacheTime'		=> 600
+		self::cache_to_apc					=> array('cacheTime'		=> 600
 													),
-		self::cache_to_memcache				=> array( 'memcacheServer'	=> 'localhost',
+		self::cache_to_memcache				=> array('memcacheServer'	=> 'localhost',
 													  'memcachePort'	=> 11211,
 													  'cacheTime'		=> 600
 													),
-		self::cache_to_wincache				=> array( 'cacheTime'		=> 600
+		self::cache_to_wincache				=> array('cacheTime'		=> 600
 													),
 		self::cache_to_sqlite				=> array(
 													),
@@ -172,8 +172,8 @@ 
 	public static function getCacheStorageMethods()
 	{
 		$activeMethods = array();
-		foreach(self::$_storageMethods as $storageMethod) {
-			$cacheStorageClass = 'PHPExcel_CachedObjectStorage_' . $storageMethod;
+		foreach (self::$_storageMethods as $storageMethod) {
+			$cacheStorageClass = 'PHPExcel_CachedObjectStorage_'.$storageMethod;
 			if (call_user_func(array($cacheStorageClass, 'cacheMethodIsAvailable'))) {
 				$activeMethods[] = $storageMethod;
 			}
@@ -192,25 +192,25 @@ 
 	 **/
 	public static function initialize($method = self::cache_in_memory, $arguments = array())
 	{
-		if (!in_array($method,self::$_storageMethods)) {
+		if ( ! in_array($method, self::$_storageMethods)) {
 			return FALSE;
 		}
 
 		$cacheStorageClass = 'PHPExcel_CachedObjectStorage_'.$method;
-		if (!call_user_func(array( $cacheStorageClass,
+		if ( ! call_user_func(array($cacheStorageClass,
 								   'cacheMethodIsAvailable'))) {
 			return FALSE;
 		}
 
 		self::$_storageMethodParameters[$method] = self::$_storageMethodDefaultParameters[$method];
-		foreach($arguments as $k => $v) {
+		foreach ($arguments as $k => $v) {
 			if (isset(self::$_storageMethodParameters[$method][$k])) {
 				self::$_storageMethodParameters[$method][$k] = $v;
 			}
 		}
 
 		if (self::$_cacheStorageMethod === NULL) {
-			self::$_cacheStorageClass = 'PHPExcel_CachedObjectStorage_' . $method;
+			self::$_cacheStorageClass = 'PHPExcel_CachedObjectStorage_'.$method;
 			self::$_cacheStorageMethod = $method;
 		}
 		return TRUE;
@@ -231,7 +231,7 @@ 
 		}
 
 		if ($cacheMethodIsAvailable) {
-			$instance = new self::$_cacheStorageClass( $parent,
+			$instance = new self::$_cacheStorageClass($parent,
 													   self::$_storageMethodParameters[self::$_cacheStorageMethod]
 													 );
 			if ($instance !== NULL) {

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
 	 */

Indentation +25 added lines, -25 removed lines

@@ -1,29 +1,29 @@ 
 <?php
 /**
- * PHPExcel
- *
- * Copyright (c) 2006 - 2012 PHPExcel
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- *
- * @category	PHPExcel
- * @package		PHPExcel_Calculation
- * @copyright	Copyright (c) 2006 - 2012 PHPExcel (http://www.codeplex.com/PHPExcel)
- * @license		http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
- * @version		1.7.7, 2012-05-19
- */
+	 * PHPExcel
+	 *
+	 * Copyright (c) 2006 - 2012 PHPExcel
+	 *
+	 * This library is free software; you can redistribute it and/or
+	 * modify it under the terms of the GNU Lesser General Public
+	 * License as published by the Free Software Foundation; either
+	 * version 2.1 of the License, or (at your option) any later version.
+	 *
+	 * This library is distributed in the hope that it will be useful,
+	 * but WITHOUT ANY WARRANTY; without even the implied warranty of
+	 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+	 * Lesser General Public License for more details.
+	 *
+	 * You should have received a copy of the GNU Lesser General Public
+	 * License along with this library; if not, write to the Free Software
+	 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+	 *
+	 * @category	PHPExcel
+	 * @package		PHPExcel_Calculation
+	 * @copyright	Copyright (c) 2006 - 2012 PHPExcel (http://www.codeplex.com/PHPExcel)
+	 * @license		http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+	 * @version		1.7.7, 2012-05-19
+	 */
 
 
 /** PHPExcel root directory */
@@ -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;
 		}

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();

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();