reginaldojunior / winners

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

Doc Comments +6 added lines, -5 removed lines

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

Spacing +285 added lines, -285 removed lines

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

Braces +15 added lines, -5 removed lines

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

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

Doc Comments +28 added lines, -17 removed lines

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

Spacing +194 added lines, -194 removed lines

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

Braces +54 added lines, -19 removed lines

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

Indentation +1 added lines, -1 removed lines

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

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

Doc Comments +2 added lines, -2 removed lines

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

Indentation +68 added lines, -68 removed lines

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

Spacing +14 added lines, -14 removed lines

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

Braces +3 added lines, -1 removed lines

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

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

Doc Comments +5 added lines, -7 removed lines

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

Spacing +12 added lines, -12 removed lines

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

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

Doc Comments +4 added lines, -4 removed lines

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

Indentation +8 added lines, -8 removed lines

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

Spacing +103 added lines, -103 removed lines

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

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

Doc Comments +10 added lines, -19 removed lines

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

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

Doc Comments +4 added lines, -46 removed lines

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

Spacing +287 added lines, -287 removed lines

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

Braces +12 added lines, -5 removed lines

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

app/Vendor/PHPExcel/PHPExcel/Calculation/TextData.php

Doc Comments +7 added lines, -12 removed lines

@@ -69,7 +69,7 @@ 
 	 * CHARACTER
 	 *
 	 * @param	string	$character	Value
-	 * @return	int
+	 * @return	string
 	 */
 	public static function CHARACTER($character) {
 		$character	= PHPExcel_Calculation_Functions::flattenSingleValue($character);
@@ -89,7 +89,6 @@ 
 	/**
 	 * TRIMNONPRINTABLE
 	 *
-	 * @param	mixed	$value	Value to check
 	 * @return	string
 	 */
 	public static function TRIMNONPRINTABLE($stringValue = '') {
@@ -113,7 +112,6 @@ 
 	/**
 	 * TRIMSPACES
 	 *
-	 * @param	mixed	$value	Value to check
 	 * @return	string
 	 */
 	public static function TRIMSPACES($stringValue = '') {
@@ -133,7 +131,7 @@ 
 	/**
 	 * ASCIICODE
 	 *
-	 * @param	string	$character	Value
+	 * @param	string	$characters	Value
 	 * @return	int
 	 */
 	public static function ASCIICODE($characters) {
@@ -192,7 +190,7 @@ 
 	 * This function converts a number to text using currency format, with the decimals rounded to the specified place.
 	 * The format used is $#,##0.00_);($#,##0.00)..
 	 *
-	 * @param	float	$value			The value to format
+	 * @param	integer	$value			The value to format
 	 * @param	int		$decimals		The number of digits to display to the right of the decimal point.
 	 *									If decimals is negative, number is rounded to the left of the decimal point.
 	 *									If you omit decimals, it is assumed to be 2
@@ -291,7 +289,7 @@ 
 	 * FIXEDFORMAT
 	 *
 	 * @param	mixed	$value	Value to check
-	 * @return	boolean
+	 * @return	string
 	 */
 	public static function FIXEDFORMAT($value, $decimals = 2, $no_commas = FALSE) {
 		$value		= PHPExcel_Calculation_Functions::flattenSingleValue($value);
@@ -401,8 +399,7 @@ 
 	 * STRINGLENGTH
 	 *
 	 * @param	string	$value	Value
-	 * @param	int		$chars	Number of characters
-	 * @return	string
+	 * @return	integer
 	 */
 	public static function STRINGLENGTH($value = '') {
 		$value		= PHPExcel_Calculation_Functions::flattenSingleValue($value);
@@ -491,7 +488,6 @@ 
 	/**
 	 * REPLACE
 	 *
-	 * @param	string	$value	Value
 	 * @param	int		$start	Start character
 	 * @param	int		$chars	Number of characters
 	 * @return	string
@@ -559,8 +555,7 @@ 
 	/**
 	 * RETURNSTRING
 	 *
-	 * @param	mixed	$value	Value to check
-	 * @return	boolean
+	 * @return	string|null
 	 */
 	public static function RETURNSTRING($testValue = '') {
 		$testValue	= PHPExcel_Calculation_Functions::flattenSingleValue($testValue);
@@ -576,7 +571,7 @@ 
 	 * TEXTFORMAT
 	 *
 	 * @param	mixed	$value	Value to check
-	 * @return	boolean
+	 * @return	string
 	 */
 	public static function TEXTFORMAT($value,$format) {
 		$value	= PHPExcel_Calculation_Functions::flattenSingleValue($value);

Spacing +60 added lines, -60 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');
 }
 
 
@@ -48,18 +48,18 @@ 
 	private static $_invalidChars = Null;
 
 	private static function _uniord($c) {
-		if (ord($c{0}) >=0 && ord($c{0}) <= 127)
+		if (ord($c{0}) >= 0 && ord($c{0}) <= 127)
 			return ord($c{0});
 		if (ord($c{0}) >= 192 && ord($c{0}) <= 223)
-			return (ord($c{0})-192)*64 + (ord($c{1})-128);
+			return (ord($c{0}) - 192) * 64 + (ord($c{1}) - 128);
 		if (ord($c{0}) >= 224 && ord($c{0}) <= 239)
-			return (ord($c{0})-224)*4096 + (ord($c{1})-128)*64 + (ord($c{2})-128);
+			return (ord($c{0}) - 224) * 4096 + (ord($c{1}) - 128) * 64 + (ord($c{2}) - 128);
 		if (ord($c{0}) >= 240 && ord($c{0}) <= 247)
-			return (ord($c{0})-240)*262144 + (ord($c{1})-128)*4096 + (ord($c{2})-128)*64 + (ord($c{3})-128);
+			return (ord($c{0}) - 240) * 262144 + (ord($c{1}) - 128) * 4096 + (ord($c{2}) - 128) * 64 + (ord($c{3}) - 128);
 		if (ord($c{0}) >= 248 && ord($c{0}) <= 251)
-			return (ord($c{0})-248)*16777216 + (ord($c{1})-128)*262144 + (ord($c{2})-128)*4096 + (ord($c{3})-128)*64 + (ord($c{4})-128);
+			return (ord($c{0}) - 248) * 16777216 + (ord($c{1}) - 128) * 262144 + (ord($c{2}) - 128) * 4096 + (ord($c{3}) - 128) * 64 + (ord($c{4}) - 128);
 		if (ord($c{0}) >= 252 && ord($c{0}) <= 253)
-			return (ord($c{0})-252)*1073741824 + (ord($c{1})-128)*16777216 + (ord($c{2})-128)*262144 + (ord($c{3})-128)*4096 + (ord($c{4})-128)*64 + (ord($c{5})-128);
+			return (ord($c{0}) - 252) * 1073741824 + (ord($c{1}) - 128) * 16777216 + (ord($c{2}) - 128) * 262144 + (ord($c{3}) - 128) * 4096 + (ord($c{4}) - 128) * 64 + (ord($c{5}) - 128);
 		if (ord($c{0}) >= 254 && ord($c{0}) <= 255) //error
 			return PHPExcel_Calculation_Functions::VALUE();
 		return 0;
@@ -72,9 +72,9 @@ 
 	 * @return	int
 	 */
 	public static function CHARACTER($character) {
-		$character	= PHPExcel_Calculation_Functions::flattenSingleValue($character);
+		$character = PHPExcel_Calculation_Functions::flattenSingleValue($character);
 
-		if ((!is_numeric($character)) || ($character < 0)) {
+		if (( ! is_numeric($character)) || ($character < 0)) {
 			return PHPExcel_Calculation_Functions::VALUE();
 		}
 
@@ -93,18 +93,18 @@ 
 	 * @return	string
 	 */
 	public static function TRIMNONPRINTABLE($stringValue = '') {
-		$stringValue	= PHPExcel_Calculation_Functions::flattenSingleValue($stringValue);
+		$stringValue = PHPExcel_Calculation_Functions::flattenSingleValue($stringValue);
 
 		if (is_bool($stringValue)) {
 			return ($stringValue) ? PHPExcel_Calculation::getTRUE() : PHPExcel_Calculation::getFALSE();
 		}
 
 		if (self::$_invalidChars == Null) {
-			self::$_invalidChars = range(chr(0),chr(31));
+			self::$_invalidChars = range(chr(0), chr(31));
 		}
 
 		if (is_string($stringValue) || is_numeric($stringValue)) {
-			return str_replace(self::$_invalidChars,'',trim($stringValue,"\x00..\x1F"));
+			return str_replace(self::$_invalidChars, '', trim($stringValue, "\x00..\x1F"));
 		}
 		return NULL;
 	}	//	function TRIMNONPRINTABLE()
@@ -117,14 +117,14 @@ 
 	 * @return	string
 	 */
 	public static function TRIMSPACES($stringValue = '') {
-		$stringValue	= PHPExcel_Calculation_Functions::flattenSingleValue($stringValue);
+		$stringValue = PHPExcel_Calculation_Functions::flattenSingleValue($stringValue);
 
 		if (is_bool($stringValue)) {
 			return ($stringValue) ? PHPExcel_Calculation::getTRUE() : PHPExcel_Calculation::getFALSE();
 		}
 
 		if (is_string($stringValue) || is_numeric($stringValue)) {
-			return trim(preg_replace('/ +/',' ',trim($stringValue,' ')));
+			return trim(preg_replace('/ +/', ' ', trim($stringValue, ' ')));
 		}
 		return NULL;
 	}	//	function TRIMSPACES()
@@ -139,7 +139,7 @@ 
 	public static function ASCIICODE($characters) {
 		if (($characters === NULL) || ($characters === ''))
 			return PHPExcel_Calculation_Functions::VALUE();
-		$characters	= PHPExcel_Calculation_Functions::flattenSingleValue($characters);
+		$characters = PHPExcel_Calculation_Functions::flattenSingleValue($characters);
 		if (is_bool($characters)) {
 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
 				$characters = (int) $characters;
@@ -199,24 +199,24 @@ 
 	 * @return	string
 	 */
 	public static function DOLLAR($value = 0, $decimals = 2) {
-		$value		= PHPExcel_Calculation_Functions::flattenSingleValue($value);
-		$decimals	= is_null($decimals) ? 0 : PHPExcel_Calculation_Functions::flattenSingleValue($decimals);
+		$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
+		$decimals = is_null($decimals) ? 0 : PHPExcel_Calculation_Functions::flattenSingleValue($decimals);
 
 		// Validate parameters
-		if (!is_numeric($value) || !is_numeric($decimals)) {
+		if ( ! is_numeric($value) || ! is_numeric($decimals)) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
 		$decimals = floor($decimals);
 
 		if ($decimals > 0) {
-			return money_format('%.'.$decimals.'n',$value);
+			return money_format('%.'.$decimals.'n', $value);
 		} else {
-			$round = pow(10,abs($decimals));
-			if ($value < 0) { $round = 0-$round; }
-			$value = PHPExcel_Calculation_MathTrig::MROUND($value,$round);
+			$round = pow(10, abs($decimals));
+			if ($value < 0) { $round = 0 - $round; }
+			$value = PHPExcel_Calculation_MathTrig::MROUND($value, $round);
 			//	The implementation of money_format used if the standard PHP function is not available can't handle decimal places of 0,
 			//		so we display to 1 dp and chop off that character and the decimal separator using substr
-			return substr(money_format('%.1n',$value),0,-2);
+			return substr(money_format('%.1n', $value), 0, -2);
 		}
 	}	//	function DOLLAR()
 
@@ -229,19 +229,19 @@ 
 	 * @param	int		$offset		Offset within $haystack
 	 * @return	string
 	 */
-	public static function SEARCHSENSITIVE($needle,$haystack,$offset=1) {
+	public static function SEARCHSENSITIVE($needle, $haystack, $offset = 1) {
 		$needle		= PHPExcel_Calculation_Functions::flattenSingleValue($needle);
-		$haystack	= PHPExcel_Calculation_Functions::flattenSingleValue($haystack);
+		$haystack = PHPExcel_Calculation_Functions::flattenSingleValue($haystack);
 		$offset		= PHPExcel_Calculation_Functions::flattenSingleValue($offset);
 
-		if (!is_bool($needle)) {
+		if ( ! is_bool($needle)) {
 			if (is_bool($haystack)) {
 				$haystack = ($haystack) ? PHPExcel_Calculation::getTRUE() : PHPExcel_Calculation::getFALSE();
 			}
 
 			if (($offset > 0) && (strlen($haystack) > $offset)) {
 				if (function_exists('mb_strpos')) {
-					$pos = mb_strpos($haystack, $needle, --$offset,'UTF-8');
+					$pos = mb_strpos($haystack, $needle, --$offset, 'UTF-8');
 				} else {
 					$pos = strpos($haystack, $needle, --$offset);
 				}
@@ -262,19 +262,19 @@ 
 	 * @param	int		$offset		Offset within $haystack
 	 * @return	string
 	 */
-	public static function SEARCHINSENSITIVE($needle,$haystack,$offset=1) {
+	public static function SEARCHINSENSITIVE($needle, $haystack, $offset = 1) {
 		$needle		= PHPExcel_Calculation_Functions::flattenSingleValue($needle);
-		$haystack	= PHPExcel_Calculation_Functions::flattenSingleValue($haystack);
+		$haystack = PHPExcel_Calculation_Functions::flattenSingleValue($haystack);
 		$offset		= PHPExcel_Calculation_Functions::flattenSingleValue($offset);
 
-		if (!is_bool($needle)) {
+		if ( ! is_bool($needle)) {
 			if (is_bool($haystack)) {
 				$haystack = ($haystack) ? PHPExcel_Calculation::getTRUE() : PHPExcel_Calculation::getFALSE();
 			}
 
 			if (($offset > 0) && (strlen($haystack) > $offset)) {
 				if (function_exists('mb_stripos')) {
-					$pos = mb_stripos($haystack, $needle, --$offset,'UTF-8');
+					$pos = mb_stripos($haystack, $needle, --$offset, 'UTF-8');
 				} else {
 					$pos = stripos($haystack, $needle, --$offset);
 				}
@@ -294,20 +294,20 @@ 
 	 * @return	boolean
 	 */
 	public static function FIXEDFORMAT($value, $decimals = 2, $no_commas = FALSE) {
-		$value		= PHPExcel_Calculation_Functions::flattenSingleValue($value);
-		$decimals	= PHPExcel_Calculation_Functions::flattenSingleValue($decimals);
-		$no_commas	= PHPExcel_Calculation_Functions::flattenSingleValue($no_commas);
+		$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
+		$decimals = PHPExcel_Calculation_Functions::flattenSingleValue($decimals);
+		$no_commas = PHPExcel_Calculation_Functions::flattenSingleValue($no_commas);
 
 		// Validate parameters
-		if (!is_numeric($value) || !is_numeric($decimals)) {
+		if ( ! is_numeric($value) || ! is_numeric($decimals)) {
 			return PHPExcel_Calculation_Functions::NaN();
 		}
 		$decimals = floor($decimals);
 
-		$valueResult = round($value,$decimals);
+		$valueResult = round($value, $decimals);
 		if ($decimals < 0) { $decimals = 0; }
-		if (!$no_commas) {
-			$valueResult = number_format($valueResult,$decimals);
+		if ( ! $no_commas) {
+			$valueResult = number_format($valueResult, $decimals);
 		}
 
 		return (string) $valueResult;
@@ -428,7 +428,7 @@ 
 	 * @return	string
 	 */
 	public static function LOWERCASE($mixedCaseString) {
-		$mixedCaseString	= PHPExcel_Calculation_Functions::flattenSingleValue($mixedCaseString);
+		$mixedCaseString = PHPExcel_Calculation_Functions::flattenSingleValue($mixedCaseString);
 
 		if (is_bool($mixedCaseString)) {
 			$mixedCaseString = ($mixedCaseString) ? PHPExcel_Calculation::getTRUE() : PHPExcel_Calculation::getFALSE();
@@ -451,7 +451,7 @@ 
 	 * @return	string
 	 */
 	public static function UPPERCASE($mixedCaseString) {
-		$mixedCaseString	= PHPExcel_Calculation_Functions::flattenSingleValue($mixedCaseString);
+		$mixedCaseString = PHPExcel_Calculation_Functions::flattenSingleValue($mixedCaseString);
 
 		if (is_bool($mixedCaseString)) {
 			$mixedCaseString = ($mixedCaseString) ? PHPExcel_Calculation::getTRUE() : PHPExcel_Calculation::getFALSE();
@@ -474,7 +474,7 @@ 
 	 * @return	string
 	 */
 	public static function PROPERCASE($mixedCaseString) {
-		$mixedCaseString	= PHPExcel_Calculation_Functions::flattenSingleValue($mixedCaseString);
+		$mixedCaseString = PHPExcel_Calculation_Functions::flattenSingleValue($mixedCaseString);
 
 		if (is_bool($mixedCaseString)) {
 			$mixedCaseString = ($mixedCaseString) ? PHPExcel_Calculation::getTRUE() : PHPExcel_Calculation::getFALSE();
@@ -502,8 +502,8 @@ 
 		$chars		= PHPExcel_Calculation_Functions::flattenSingleValue($chars);
 		$newText	= PHPExcel_Calculation_Functions::flattenSingleValue($newText);
 
-		$left = self::LEFT($oldText,$start-1);
-		$right = self::RIGHT($oldText,self::STRINGLENGTH($oldText)-($start+$chars)+1);
+		$left = self::LEFT($oldText, $start - 1);
+		$right = self::RIGHT($oldText, self::STRINGLENGTH($oldText) - ($start + $chars) + 1);
 
 		return $left.$newText.$right;
 	}	//	function REPLACE()
@@ -519,24 +519,24 @@ 
 	 * @return	string
 	 */
 	public static function SUBSTITUTE($text = '', $fromText = '', $toText = '', $instance = 0) {
-		$text		= PHPExcel_Calculation_Functions::flattenSingleValue($text);
+		$text = PHPExcel_Calculation_Functions::flattenSingleValue($text);
 		$fromText	= PHPExcel_Calculation_Functions::flattenSingleValue($fromText);
-		$toText		= PHPExcel_Calculation_Functions::flattenSingleValue($toText);
+		$toText = PHPExcel_Calculation_Functions::flattenSingleValue($toText);
 		$instance	= floor(PHPExcel_Calculation_Functions::flattenSingleValue($instance));
 
 		if ($instance == 0) {
-			if(function_exists('mb_str_replace')) {
-				return mb_str_replace($fromText,$toText,$text);
+			if (function_exists('mb_str_replace')) {
+				return mb_str_replace($fromText, $toText, $text);
 			} else {
-				return str_replace($fromText,$toText,$text);
+				return str_replace($fromText, $toText, $text);
 			}
 		} else {
 			$pos = -1;
-			while($instance > 0) {
+			while ($instance > 0) {
 				if (function_exists('mb_strpos')) {
-					$pos = mb_strpos($text, $fromText, $pos+1, 'UTF-8');
+					$pos = mb_strpos($text, $fromText, $pos + 1, 'UTF-8');
 				} else {
-					$pos = strpos($text, $fromText, $pos+1);
+					$pos = strpos($text, $fromText, $pos + 1);
 				}
 				if ($pos === false) {
 					break;
@@ -545,9 +545,9 @@ 
 			}
 			if ($pos !== false) {
 				if (function_exists('mb_strlen')) {
-					return self::REPLACE($text,++$pos,mb_strlen($fromText, 'UTF-8'),$toText);
+					return self::REPLACE($text, ++$pos, mb_strlen($fromText, 'UTF-8'), $toText);
 				} else {
-					return self::REPLACE($text,++$pos,strlen($fromText),$toText);
+					return self::REPLACE($text, ++$pos, strlen($fromText), $toText);
 				}
 			}
 		}
@@ -563,7 +563,7 @@ 
 	 * @return	boolean
 	 */
 	public static function RETURNSTRING($testValue = '') {
-		$testValue	= PHPExcel_Calculation_Functions::flattenSingleValue($testValue);
+		$testValue = PHPExcel_Calculation_Functions::flattenSingleValue($testValue);
 
 		if (is_string($testValue)) {
 			return $testValue;
@@ -578,15 +578,15 @@ 
 	 * @param	mixed	$value	Value to check
 	 * @return	boolean
 	 */
-	public static function TEXTFORMAT($value,$format) {
-		$value	= PHPExcel_Calculation_Functions::flattenSingleValue($value);
+	public static function TEXTFORMAT($value, $format) {
+		$value = PHPExcel_Calculation_Functions::flattenSingleValue($value);
 		$format	= PHPExcel_Calculation_Functions::flattenSingleValue($format);
 
-		if ((is_string($value)) && (!is_numeric($value)) && PHPExcel_Shared_Date::isDateTimeFormatCode($format)) {
+		if ((is_string($value)) && ( ! is_numeric($value)) && PHPExcel_Shared_Date::isDateTimeFormatCode($format)) {
 			$value = PHPExcel_Calculation_DateTime::DATEVALUE($value);
 		}
 
-		return (string) PHPExcel_Style_NumberFormat::toFormattedString($value,$format);
+		return (string) PHPExcel_Style_NumberFormat::toFormattedString($value, $format);
 	}	//	function TEXTFORMAT()
 
 }	//	class PHPExcel_Calculation_TextData

Braces +24 added lines, -15 removed lines

@@ -48,20 +48,28 @@ 
 	private static $_invalidChars = Null;
 
 	private static function _uniord($c) {
-		if (ord($c{0}) >=0 && ord($c{0}) <= 127)
-			return ord($c{0});
-		if (ord($c{0}) >= 192 && ord($c{0}) <= 223)
-			return (ord($c{0})-192)*64 + (ord($c{1})-128);
-		if (ord($c{0}) >= 224 && ord($c{0}) <= 239)
-			return (ord($c{0})-224)*4096 + (ord($c{1})-128)*64 + (ord($c{2})-128);
-		if (ord($c{0}) >= 240 && ord($c{0}) <= 247)
-			return (ord($c{0})-240)*262144 + (ord($c{1})-128)*4096 + (ord($c{2})-128)*64 + (ord($c{3})-128);
-		if (ord($c{0}) >= 248 && ord($c{0}) <= 251)
-			return (ord($c{0})-248)*16777216 + (ord($c{1})-128)*262144 + (ord($c{2})-128)*4096 + (ord($c{3})-128)*64 + (ord($c{4})-128);
-		if (ord($c{0}) >= 252 && ord($c{0}) <= 253)
-			return (ord($c{0})-252)*1073741824 + (ord($c{1})-128)*16777216 + (ord($c{2})-128)*262144 + (ord($c{3})-128)*4096 + (ord($c{4})-128)*64 + (ord($c{5})-128);
-		if (ord($c{0}) >= 254 && ord($c{0}) <= 255) //error
+		if (ord($c{0}) >=0 && ord($c{0}) <= 127) {
+					return ord($c{0});
+		}
+		if (ord($c{0}) >= 192 && ord($c{0}) <= 223) {
+					return (ord($c{0})-192)*64 + (ord($c{1})-128);
+		}
+		if (ord($c{0}) >= 224 && ord($c{0}) <= 239) {
+					return (ord($c{0})-224)*4096 + (ord($c{1})-128)*64 + (ord($c{2})-128);
+		}
+		if (ord($c{0}) >= 240 && ord($c{0}) <= 247) {
+					return (ord($c{0})-240)*262144 + (ord($c{1})-128)*4096 + (ord($c{2})-128)*64 + (ord($c{3})-128);
+		}
+		if (ord($c{0}) >= 248 && ord($c{0}) <= 251) {
+					return (ord($c{0})-248)*16777216 + (ord($c{1})-128)*262144 + (ord($c{2})-128)*4096 + (ord($c{3})-128)*64 + (ord($c{4})-128);
+		}
+		if (ord($c{0}) >= 252 && ord($c{0}) <= 253) {
+					return (ord($c{0})-252)*1073741824 + (ord($c{1})-128)*16777216 + (ord($c{2})-128)*262144 + (ord($c{3})-128)*4096 + (ord($c{4})-128)*64 + (ord($c{5})-128);
+		}
+		if (ord($c{0}) >= 254 && ord($c{0}) <= 255) {
+			//error
 			return PHPExcel_Calculation_Functions::VALUE();
+		}
 		return 0;
 	}	//	function _uniord()
 
@@ -137,8 +145,9 @@ 
 	 * @return	int
 	 */
 	public static function ASCIICODE($characters) {
-		if (($characters === NULL) || ($characters === ''))
-			return PHPExcel_Calculation_Functions::VALUE();
+		if (($characters === NULL) || ($characters === '')) {
+					return PHPExcel_Calculation_Functions::VALUE();
+		}
 		$characters	= PHPExcel_Calculation_Functions::flattenSingleValue($characters);
 		if (is_bool($characters)) {
 			if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {

app/Vendor/PHPExcel/PHPExcel/Cell.php

Doc Comments +6 added lines, -3 removed lines

@@ -102,7 +102,7 @@ 
 	/**
 	 * Send notification to the cache controller
 	 *
-	 * @return void
+	 * @return PHPExcel_Cell
 	 **/
 	public function notifyCacheController() {
 		$this->_parent->getCellCacheController()->updateCacheData($this);
@@ -113,6 +113,9 @@ 
 		$this->_parent = null;
 	}
 
+	/**
+	 * @param PHPExcel_Worksheet|null $parent
+	 */
 	public function attach($parent) {
 		$this->_parent = $parent;
 	}
@@ -498,7 +501,7 @@ 
 	 * Coordinate from string
 	 *
 	 * @param	string	$pCoordinateString
-	 * @return	array	Array containing column and row (indexes 0 and 1)
+	 * @return	string[]	Array containing column and row (indexes 0 and 1)
 	 * @throws	Exception
 	 */
 	public static function coordinateFromString($pCoordinateString = 'A1')
@@ -652,7 +655,7 @@ 
 	 * Calculate range boundaries
 	 *
 	 * @param	string	$pRange		Cell range (e.g. A1:A1)
-	 * @return	array	Range boundaries (staring Column, starting Row, Final Column, Final Row)
+	 * @return	integer	Range boundaries (staring Column, starting Row, Final Column, Final Row)
 	 */
 	public static function getRangeBoundaries($pRange = 'A1:A1')
 	{

Indentation +2 added lines, -2 removed lines

@@ -203,8 +203,8 @@
 	public function getFormattedValue()
 	{
 		return (string) PHPExcel_Style_NumberFormat::toFormattedString( $this->getCalculatedValue(),
-						         $this->_parent->getParent()->getCellXfByIndex($this->getXfIndex())->getNumberFormat()->getFormatCode()
-			            );
+								 $this->_parent->getParent()->getCellXfByIndex($this->getXfIndex())->getNumberFormat()->getFormatCode()
+						);
 	}
 
 	/**

Spacing +50 added lines, -50 removed lines

@@ -146,7 +146,7 @@ 
 				$pDataType = PHPExcel_Cell_DataType::TYPE_STRING;
 			$this->_dataType = $pDataType;
 		} else {
-			if (!self::getValueBinder()->bindValue($this, $pValue)) {
+			if ( ! self::getValueBinder()->bindValue($this, $pValue)) {
 				throw new Exception("Value could not be bound to cell.");
 			}
 		}
@@ -182,7 +182,7 @@ 
 	 */
 	public function getCoordinate()
 	{
-		return $this->_column . $this->_row;
+		return $this->_column.$this->_row;
 	}
 
 	/**
@@ -202,7 +202,7 @@ 
 	 */
 	public function getFormattedValue()
 	{
-		return (string) PHPExcel_Style_NumberFormat::toFormattedString( $this->getCalculatedValue(),
+		return (string) PHPExcel_Style_NumberFormat::toFormattedString($this->getCalculatedValue(),
 						         $this->_parent->getParent()->getCellXfByIndex($this->getXfIndex())->getNumberFormat()->getFormatCode()
 			            );
 	}
@@ -217,7 +217,7 @@ 
 	 */
 	public function setValue($pValue = null)
 	{
-		if (!self::getValueBinder()->bindValue($this, $pValue)) {
+		if ( ! self::getValueBinder()->bindValue($this, $pValue)) {
 			throw new Exception("Value could not be bound to cell.");
 		}
 		return $this;
@@ -244,15 +244,15 @@ 
 				break;
 
 			case PHPExcel_Cell_DataType::TYPE_NUMERIC:
-				$this->_value = (float)$pValue;
+				$this->_value = (float) $pValue;
 				break;
 
 			case PHPExcel_Cell_DataType::TYPE_FORMULA:
-				$this->_value = (string)$pValue;
+				$this->_value = (string) $pValue;
 				break;
 
 			case PHPExcel_Cell_DataType::TYPE_BOOL:
-				$this->_value = (bool)$pValue;
+				$this->_value = (bool) $pValue;
 				break;
 
 			case PHPExcel_Cell_DataType::TYPE_ERROR:
@@ -260,7 +260,7 @@ 
 				break;
 
 			default:
-				throw new Exception('Invalid datatype: ' . $pDataType);
+				throw new Exception('Invalid datatype: '.$pDataType);
 				break;
 		}
 
@@ -275,15 +275,15 @@ 
 	 *
 	 * @return mixed
 	 */
-	public function getCalculatedValue($resetLog=true)
+	public function getCalculatedValue($resetLog = true)
 	{
 //		echo 'Cell '.$this->getCoordinate().' value is a '.$this->_dataType.' with a value of '.$this->getValue().'<br />';
 		if ($this->_dataType == PHPExcel_Cell_DataType::TYPE_FORMULA) {
 			try {
 //				echo 'Cell value for '.$this->getCoordinate().' is a formula: Calculating value<br />';
-				$result = PHPExcel_Calculation::getInstance()->calculateCellValue($this,$resetLog);
+				$result = PHPExcel_Calculation::getInstance()->calculateCellValue($this, $resetLog);
 //				echo $this->getCoordinate().' calculation result is '.$result.'<br />';
-			} catch ( Exception $ex ) {
+			} catch (Exception $ex) {
 				if (($ex->getMessage() === 'Unable to access External Workbook') && ($this->_calculatedValue !== NULL)) {
 //					echo 'Returning fallback value of '.$this->_calculatedValue.' for cell '.$this->getCoordinate().'<br />';
 					return $this->_calculatedValue; // Fallback for calculations referencing external files.
@@ -367,7 +367,7 @@ 
 	 */
 	public function hasDataValidation()
 	{
-		if (!isset($this->_parent)) {
+		if ( ! isset($this->_parent)) {
 			throw new Exception('Cannot check for data validation when cell is not bound to a worksheet');
 		}
 
@@ -381,7 +381,7 @@ 
 	 */
 	public function getDataValidation()
 	{
-		if (!isset($this->_parent)) {
+		if ( ! isset($this->_parent)) {
 			throw new Exception('Cannot get data validation for cell that is not bound to a worksheet');
 		}
 
@@ -397,7 +397,7 @@ 
 	 */
 	public function setDataValidation(PHPExcel_Cell_DataValidation $pDataValidation = null)
 	{
-		if (!isset($this->_parent)) {
+		if ( ! isset($this->_parent)) {
 			throw new Exception('Cannot set data validation for cell that is not bound to a worksheet');
 		}
 
@@ -413,7 +413,7 @@ 
 	 */
 	public function hasHyperlink()
 	{
-		if (!isset($this->_parent)) {
+		if ( ! isset($this->_parent)) {
 			throw new Exception('Cannot check for hyperlink when cell is not bound to a worksheet');
 		}
 
@@ -428,7 +428,7 @@ 
 	 */
 	public function getHyperlink()
 	{
-		if (!isset($this->_parent)) {
+		if ( ! isset($this->_parent)) {
 			throw new Exception('Cannot get hyperlink for cell that is not bound to a worksheet');
 		}
 
@@ -444,7 +444,7 @@ 
 	 */
 	public function setHyperlink(PHPExcel_Cell_Hyperlink $pHyperlink = null)
 	{
-		if (!isset($this->_parent)) {
+		if ( ! isset($this->_parent)) {
 			throw new Exception('Cannot set hyperlink for cell that is not bound to a worksheet');
 		}
 
@@ -482,11 +482,11 @@ 
 	 */
 	public function isInRange($pRange = 'A1:A1')
 	{
-		list($rangeStart,$rangeEnd) = PHPExcel_Cell::rangeBoundaries($pRange);
+		list($rangeStart, $rangeEnd) = PHPExcel_Cell::rangeBoundaries($pRange);
 
 		// Translate properties
-		$myColumn	= PHPExcel_Cell::columnIndexFromString($this->getColumn());
-		$myRow		= $this->getRow();
+		$myColumn = PHPExcel_Cell::columnIndexFromString($this->getColumn());
+		$myRow = $this->getRow();
 
 		// Verify if cell is in range
 		return (($rangeStart[0] <= $myColumn) && ($rangeEnd[0] >= $myColumn) &&
@@ -504,8 +504,8 @@ 
 	public static function coordinateFromString($pCoordinateString = 'A1')
 	{
 		if (preg_match("/^([$]?[A-Z]{1,3})([$]?\d{1,7})$/", $pCoordinateString, $matches)) {
-			return array($matches[1],$matches[2]);
-		} elseif ((strpos($pCoordinateString,':') !== false) || (strpos($pCoordinateString,',') !== false)) {
+			return array($matches[1], $matches[2]);
+		} elseif ((strpos($pCoordinateString, ':') !== false) || (strpos($pCoordinateString, ',') !== false)) {
 			throw new Exception('Cell coordinate string can not be a range of cells.');
 		} elseif ($pCoordinateString == '') {
 			throw new Exception('Cell coordinate can not be zero-length string.');
@@ -523,7 +523,7 @@ 
 	 */
 	public static function absoluteReference($pCoordinateString = 'A1')
 	{
-		if (strpos($pCoordinateString,':') === false && strpos($pCoordinateString,',') === false) {
+		if (strpos($pCoordinateString, ':') === false && strpos($pCoordinateString, ',') === false) {
 			// Create absolute coordinate
 			if (ctype_digit($pCoordinateString)) {
 				return '$'.$pCoordinateString;
@@ -545,20 +545,20 @@ 
 	 */
 	public static function absoluteCoordinate($pCoordinateString = 'A1')
 	{
-		if (strpos($pCoordinateString,':') === false && strpos($pCoordinateString,',') === false) {
+		if (strpos($pCoordinateString, ':') === false && strpos($pCoordinateString, ',') === false) {
 			// Create absolute coordinate
 			$worksheet = '';
-			$cellAddress = explode('!',$pCoordinateString);
+			$cellAddress = explode('!', $pCoordinateString);
 			if (count($cellAddress) == 2) {
-				list($worksheet,$pCoordinateString) = $cellAddress;
+				list($worksheet, $pCoordinateString) = $cellAddress;
 			}
 
 			list($column, $row) = PHPExcel_Cell::coordinateFromString($pCoordinateString);
-			if ($column[0] == '$')	$column = substr($column,1);
-			if ($row[0] == '$')		$row = substr($row,1);
+			if ($column[0] == '$')	$column = substr($column, 1);
+			if ($row[0] == '$')		$row = substr($row, 1);
 			if ($worksheet > '')
 				$worksheet .= '!';
-			return $worksheet . '$' . $column . '$' . $row;
+			return $worksheet.'$'.$column.'$'.$row;
 		} else {
 			throw new Exception("Coordinate string should not be a cell range.");
 		}
@@ -590,7 +590,7 @@ 
 	public static function buildRange($pRange)
 	{
 		// Verify range
-		if (!is_array($pRange) || empty($pRange) || !is_array($pRange[0])) {
+		if ( ! is_array($pRange) || empty($pRange) || ! is_array($pRange[0])) {
 			throw new Exception('Range does not contain any information.');
 		}
 
@@ -625,11 +625,11 @@ 
 
 		// Calculate range outer borders
 		$rangeStart = PHPExcel_Cell::coordinateFromString($rangeA);
-		$rangeEnd	= PHPExcel_Cell::coordinateFromString($rangeB);
+		$rangeEnd = PHPExcel_Cell::coordinateFromString($rangeB);
 
 		// Translate column into index
-		$rangeStart[0]	= PHPExcel_Cell::columnIndexFromString($rangeStart[0]);
-		$rangeEnd[0]	= PHPExcel_Cell::columnIndexFromString($rangeEnd[0]);
+		$rangeStart[0] = PHPExcel_Cell::columnIndexFromString($rangeStart[0]);
+		$rangeEnd[0] = PHPExcel_Cell::columnIndexFromString($rangeEnd[0]);
 
 		return array($rangeStart, $rangeEnd);
 	}
@@ -643,9 +643,9 @@ 
 	public static function rangeDimension($pRange = 'A1:A1')
 	{
 		// Calculate range outer borders
-		list($rangeStart,$rangeEnd) = PHPExcel_Cell::rangeBoundaries($pRange);
+		list($rangeStart, $rangeEnd) = PHPExcel_Cell::rangeBoundaries($pRange);
 
-		return array( ($rangeEnd[0] - $rangeStart[0] + 1), ($rangeEnd[1] - $rangeStart[1] + 1) );
+		return array(($rangeEnd[0] - $rangeStart[0] + 1), ($rangeEnd[1] - $rangeStart[1] + 1));
 	}
 
 	/**
@@ -666,7 +666,7 @@ 
 			list($rangeA, $rangeB) = explode(':', $pRange);
 		}
 
-		return array( self::coordinateFromString($rangeA), self::coordinateFromString($rangeB));
+		return array(self::coordinateFromString($rangeA), self::coordinateFromString($rangeB));
 	}
 
 	/**
@@ -699,18 +699,18 @@ 
 		//	We also use the language construct isset() rather than the more costly strlen() function to match the length of $pString
 		//		for improved performance
 		if (isset($pString{0})) {
-			if (!isset($pString{1})) {
+			if ( ! isset($pString{1})) {
 				$_indexCache[$pString] = $_columnLookup[$pString];
 				return $_indexCache[$pString];
-			} elseif(!isset($pString{2})) {
+			} elseif ( ! isset($pString{2})) {
 				$_indexCache[$pString] = $_columnLookup[$pString{0}] * 26 + $_columnLookup[$pString{1}];
 				return $_indexCache[$pString];
-			} elseif(!isset($pString{3})) {
+			} elseif ( ! isset($pString{3})) {
 				$_indexCache[$pString] = $_columnLookup[$pString{0}] * 676 + $_columnLookup[$pString{1}] * 26 + $_columnLookup[$pString{2}];
 				return $_indexCache[$pString];
 			}
 		}
-		throw new Exception("Column string index can not be " . ((isset($pString{0})) ? "longer than 3 characters" : "empty") . ".");
+		throw new Exception("Column string index can not be ".((isset($pString{0})) ? "longer than 3 characters" : "empty").".");
 	}
 
 	/**
@@ -726,16 +726,16 @@ 
 		//		though it's additional memory overhead
 		static $_indexCache = array();
 
-		if (!isset($_indexCache[$pColumnIndex])) {
+		if ( ! isset($_indexCache[$pColumnIndex])) {
 			// Determine column string
 			if ($pColumnIndex < 26) {
 				$_indexCache[$pColumnIndex] = chr(65 + $pColumnIndex);
 			} elseif ($pColumnIndex < 702) {
-				$_indexCache[$pColumnIndex] = chr(64 + ($pColumnIndex / 26)) .
+				$_indexCache[$pColumnIndex] = chr(64 + ($pColumnIndex / 26)).
 											  chr(65 + $pColumnIndex % 26);
 			} else {
-				$_indexCache[$pColumnIndex] = chr(64 + (($pColumnIndex - 26) / 676)) .
-											  chr(65 + ((($pColumnIndex - 26) % 676) / 26)) .
+				$_indexCache[$pColumnIndex] = chr(64 + (($pColumnIndex - 26) / 676)).
+											  chr(65 + ((($pColumnIndex - 26) % 676) / 26)).
 											  chr(65 + $pColumnIndex % 26);
 			}
 		}
@@ -756,24 +756,24 @@ 
 		$cellBlocks = explode(' ', str_replace('$', '', strtoupper($pRange)));
 		foreach ($cellBlocks as $cellBlock) {
 			// Single cell?
-			if (strpos($cellBlock,':') === false && strpos($cellBlock,',') === false) {
+			if (strpos($cellBlock, ':') === false && strpos($cellBlock, ',') === false) {
 				$returnValue[] = $cellBlock;
 				continue;
 			}
 
 			// Range...
 			$ranges = PHPExcel_Cell::splitRange($cellBlock);
-			foreach($ranges as $range) {
+			foreach ($ranges as $range) {
 				// Single cell?
-				if (!isset($range[1])) {
+				if ( ! isset($range[1])) {
 					$returnValue[] = $range[0];
 					continue;
 				}
 
 				// Range...
-				list($rangeStart, $rangeEnd)	= $range;
-				list($startCol, $startRow)	= sscanf($rangeStart,'%[A-Z]%d');
-				list($endCol, $endRow)		= sscanf($rangeEnd,'%[A-Z]%d');
+				list($rangeStart, $rangeEnd) = $range;
+				list($startCol, $startRow) = sscanf($rangeStart, '%[A-Z]%d');
+				list($endCol, $endRow) = sscanf($rangeEnd, '%[A-Z]%d');
 				$endCol++;
 
 				// Current data

Braces +18 added lines, -10 removed lines

@@ -142,8 +142,9 @@ 
 
 		// Set datatype?
 		if ($pDataType !== null) {
-			if ($pDataType == PHPExcel_Cell_DataType::TYPE_STRING2)
-				$pDataType = PHPExcel_Cell_DataType::TYPE_STRING;
+			if ($pDataType == PHPExcel_Cell_DataType::TYPE_STRING2) {
+							$pDataType = PHPExcel_Cell_DataType::TYPE_STRING;
+			}
 			$this->_dataType = $pDataType;
 		} else {
 			if (!self::getValueBinder()->bindValue($this, $pValue)) {
@@ -352,8 +353,9 @@ 
 	 */
 	public function setDataType($pDataType = PHPExcel_Cell_DataType::TYPE_STRING)
 	{
-		if ($pDataType == PHPExcel_Cell_DataType::TYPE_STRING2)
-			$pDataType = PHPExcel_Cell_DataType::TYPE_STRING;
+		if ($pDataType == PHPExcel_Cell_DataType::TYPE_STRING2) {
+					$pDataType = PHPExcel_Cell_DataType::TYPE_STRING;
+		}
 
 		$this->_dataType = $pDataType;
 
@@ -554,10 +556,15 @@ 
 			}
 
 			list($column, $row) = PHPExcel_Cell::coordinateFromString($pCoordinateString);
-			if ($column[0] == '$')	$column = substr($column,1);
-			if ($row[0] == '$')		$row = substr($row,1);
-			if ($worksheet > '')
-				$worksheet .= '!';
+			if ($column[0] == '$') {
+				$column = substr($column,1);
+			}
+			if ($row[0] == '$') {
+				$row = substr($row,1);
+			}
+			if ($worksheet > '') {
+							$worksheet .= '!';
+			}
 			return $worksheet . '$' . $column . '$' . $row;
 		} else {
 			throw new Exception("Coordinate string should not be a cell range.");
@@ -683,8 +690,9 @@ 
 		//		though it's additional memory overhead
 		static $_indexCache = array();
 
-		if (isset($_indexCache[$pString]))
-			return $_indexCache[$pString];
+		if (isset($_indexCache[$pString])) {
+					return $_indexCache[$pString];
+		}
 
 		//	It's surprising how costly the strtoupper() and ord() calls actually are, so we use a lookup array rather than use ord()
 		//		and make it case insensitive to get rid of the strtoupper() as well. Because it's a static, there's no significant