reginaldojunior / winners

app/Vendor/PHPExcel/PHPExcel/Shared/JAMA/examples/Stats.php

Doc Comments +7 added lines, -6 removed lines

@@ -184,6 +184,7 @@ 
      * @access public
      * @param   array   $arr    the data set
      * @param   optional    int $opt    data format: STATS_DATA_CUMMULATIVE or STATS_DATA_SIMPLE (default)
+     * @param integer $opt
      * @return  mixed   true on success, a PEAR_Error object otherwise
      */
     function setData($arr, $opt=STATS_DATA_SIMPLE) {/*{{{*/
@@ -512,7 +513,7 @@ 
      * Handles cummulative data sets correctly
      *
      * @access  public
-     * @param   numeric $n  the exponent
+     * @param   integer $n  the exponent
      * @return  mixed   the sum on success, a PEAR_Error object otherwise
      * @see calc()
      * @see sum()
@@ -560,7 +561,7 @@ 
      * Handles cummulative data sets correctly
      *
      * @access  public
-     * @param   numeric $n  the exponent
+     * @param   integer $n  the exponent
      * @return  mixed   the product on success, a PEAR_Error object otherwise
      * @see product()
      */
@@ -707,7 +708,7 @@ 
      *
      * @access  public
      * @param   numeric $mean   the fixed mean value
-     * @return  mixed   the variance on success, a PEAR_Error object otherwise
+     * @return  double   the variance on success, a PEAR_Error object otherwise
      * @see __sumdiff()
      * @see count()
      * @see variance()
@@ -1381,7 +1382,7 @@ 
      * @todo need to double check generality of the algorithm
      *
      * @access public
-     * @param numeric $p the percentile to estimate, e.g. 25 for 25th percentile
+     * @param integer $p the percentile to estimate, e.g. 25 for 25th percentile
      * @return mixed a numeric value on success, a PEAR_Error otherwise
      * @see quartiles()
      * @see median()
@@ -1416,7 +1417,7 @@ 
      * Utility function to calculate: SUM { (xi - mean)^n }
      *
      * @access private
-     * @param   numeric $power  the exponent
+     * @param   integer $power  the exponent
      * @param   optional    double   $mean   the data set mean value
      * @return  mixed   the sum on success, a PEAR_Error object otherwise
      *
@@ -1536,7 +1537,7 @@ 
      *
      * @access private
      * @param mixed $v value to be formatted
-     * @param boolean $returnErrorObject whether the raw PEAR_Error (when true, default),
+     * @param boolean $useErrorObject whether the raw PEAR_Error (when true, default),
      *                  or only the error message will be returned (when false)
      * @return mixed if the value is a PEAR_Error object, and $useErrorObject
      *              is false, then a string with the error message will be returned,

Indentation +1479 added lines, -1479 removed lines

@@ -117,1485 +117,1485 @@
 * @package Math_Stats
 */
 class Base {/*{{{*/
-    // properties /*{{{*/
-
-    /**
-     * The simple or cummulative data set.
-     * Null by default.
-     *
-     * @access  private
-     * @var array
-     */
-    public $_data = null;
-
-    /**
-     * Expanded data set. Only set when cummulative data
-     * is being used. Null by default.
-     *
-     * @access  private
-     * @var array
-     */
-    public $_dataExpanded = null;
-
-    /**
-     * Flag for data type, one of STATS_DATA_SIMPLE or
-     * STATS_DATA_CUMMULATIVE. Null by default.
-     *
-     * @access  private
-     * @var int
-     */
-    public $_dataOption = null;
-
-    /**
-     * Flag for null handling options. One of STATS_REJECT_NULL,
-     * STATS_IGNORE_NULL or STATS_USE_NULL_AS_ZERO
-     *
-     * @access  private
-     * @var int
-     */
-    public $_nullOption;
-
-    /**
-     * Array for caching result values, should be reset
-     * when using setData()
-     *
-     * @access private
-     * @var array
-     */
-    public $_calculatedValues = array();
-
-    /*}}}*/
-
-    /**
-     * Constructor for the class
-     *
-     * @access  public
-     * @param   optional    int $nullOption how to handle null values
-     * @return  object  Math_Stats
-     */
-    function Math_Stats($nullOption=STATS_REJECT_NULL) {/*{{{*/
-        $this->_nullOption = $nullOption;
-    }/*}}}*/
-
-    /**
-     * Sets and verifies the data, checking for nulls and using
-     * the current null handling option
-     *
-     * @access public
-     * @param   array   $arr    the data set
-     * @param   optional    int $opt    data format: STATS_DATA_CUMMULATIVE or STATS_DATA_SIMPLE (default)
-     * @return  mixed   true on success, a PEAR_Error object otherwise
-     */
-    function setData($arr, $opt=STATS_DATA_SIMPLE) {/*{{{*/
-        if (!is_array($arr)) {
-            return PEAR::raiseError('invalid data, an array of numeric data was expected');
-        }
-        $this->_data = null;
-        $this->_dataExpanded = null;
-        $this->_dataOption = null;
-        $this->_calculatedValues = array();
-        if ($opt == STATS_DATA_SIMPLE) {
-            $this->_dataOption = $opt;
-            $this->_data = array_values($arr);
-        } else if ($opt == STATS_DATA_CUMMULATIVE) {
-            $this->_dataOption = $opt;
-            $this->_data = $arr;
-            $this->_dataExpanded = array();
-        }
-        return $this->_validate();
-    }/*}}}*/
-
-    /**
-     * Returns the data which might have been modified
-     * according to the current null handling options.
-     *
-     * @access  public
-     * @param boolean $expanded whether to return a expanded list, default is false
-     * @return  mixed   array of data on success, a PEAR_Error object otherwise
-     * @see _validate()
-     */
-    function getData($expanded=false) {/*{{{*/
-        if ($this->_data == null) {
-            return PEAR::raiseError('data has not been set');
-        }
-        if ($this->_dataOption == STATS_DATA_CUMMULATIVE && $expanded) {
-            return $this->_dataExpanded;
-        } else {
-            return $this->_data;
-        }
-    }/*}}}*/
-
-    /**
-     * Sets the null handling option.
-     * Must be called before assigning a new data set containing null values
-     *
-     * @access  public
-     * @return  mixed   true on success, a PEAR_Error object otherwise
-     * @see _validate()
-     */
-    function setNullOption($nullOption) {/*{{{*/
-        if ($nullOption == STATS_REJECT_NULL
-            || $nullOption == STATS_IGNORE_NULL
-            || $nullOption == STATS_USE_NULL_AS_ZERO) {
-            $this->_nullOption = $nullOption;
-            return true;
-        } else {
-            return PEAR::raiseError('invalid null handling option expecting: '.
-                        'STATS_REJECT_NULL, STATS_IGNORE_NULL or STATS_USE_NULL_AS_ZERO');
-        }
-    }/*}}}*/
-
-    /**
-     * Transforms the data by substracting each entry from the mean and
-     * dividing by its standard deviation. This will reset all pre-calculated
-     * values to their original (unset) defaults.
-     *
-     * @access public
-     * @return mixed true on success, a PEAR_Error object otherwise
-     * @see mean()
-     * @see stDev()
-     * @see setData()
-     */
-    function studentize() {/*{{{*/
-        $mean = $this->mean();
-        if (PEAR::isError($mean)) {
-            return $mean;
-        }
-        $std = $this->stDev();
-        if (PEAR::isError($std)) {
-            return $std;
-        }
-        if ($std == 0) {
-            return PEAR::raiseError('cannot studentize data, standard deviation is zero.');
-        }
-        $arr  = array();
-        if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-            foreach ($this->_data as $val=>$freq) {
-                $newval = ($val - $mean) / $std;
-                $arr["$newval"] = $freq;
-            }
-        } else {
-            foreach ($this->_data as $val) {
-                $newval = ($val - $mean) / $std;
-                $arr[] = $newval;
-            }
-        }
-        return $this->setData($arr, $this->_dataOption);
-    }/*}}}*/
-
-    /**
-     * Transforms the data by substracting each entry from the mean.
-     * This will reset all pre-calculated values to their original (unset) defaults.
-     *
-     * @access public
-     * @return mixed true on success, a PEAR_Error object otherwise
-     * @see mean()
-     * @see setData()
-     */
-    function center() {/*{{{*/
-        $mean = $this->mean();
-        if (PEAR::isError($mean)) {
-            return $mean;
-        }
-        $arr  = array();
-        if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-            foreach ($this->_data as $val=>$freq) {
-                $newval = $val - $mean;
-                $arr["$newval"] = $freq;
-            }
-        } else {
-            foreach ($this->_data as $val) {
-                $newval = $val - $mean;
-                $arr[] = $newval;
-            }
-        }
-        return $this->setData($arr, $this->_dataOption);
-    }/*}}}*/
-
-    /**
-     * Calculates the basic or full statistics for the data set
-     *
-     * @access  public
-     * @param   int $mode   one of STATS_BASIC or STATS_FULL
-     * @param boolean $returnErrorObject whether the raw PEAR_Error (when true, default),
-     *                  or only the error message will be returned (when false), if an error happens.
-     * @return  mixed   an associative array of statistics on success, a PEAR_Error object otherwise
-     * @see calcBasic()
-     * @see calcFull()
-     */
-    function calc($mode, $returnErrorObject=true) {/*{{{*/
-        if ($this->_data == null) {
-            return PEAR::raiseError('data has not been set');
-        }
-        if ($mode == STATS_BASIC) {
-            return $this->calcBasic($returnErrorObject);
-        } elseif ($mode == STATS_FULL) {
-            return $this->calcFull($returnErrorObject);
-        } else {
-            return PEAR::raiseError('incorrect mode, expected STATS_BASIC or STATS_FULL');
-        }
-    }/*}}}*/
-
-    /**
-     * Calculates a basic set of statistics
-     *
-     * @access  public
-     * @param boolean $returnErrorObject whether the raw PEAR_Error (when true, default),
-     *                  or only the error message will be returned (when false), if an error happens.
-     * @return  mixed   an associative array of statistics on success, a PEAR_Error object otherwise
-     * @see calc()
-     * @see calcFull()
-     */
-    function calcBasic($returnErrorObject=true) {/*{{{*/
-            return array (
-                'min' => $this->__format($this->min(), $returnErrorObject),
-                'max' => $this->__format($this->max(), $returnErrorObject),
-                'sum' => $this->__format($this->sum(), $returnErrorObject),
-                'sum2' => $this->__format($this->sum2(), $returnErrorObject),
-                'count' => $this->__format($this->count(), $returnErrorObject),
-                'mean' => $this->__format($this->mean(), $returnErrorObject),
-                'stdev' => $this->__format($this->stDev(), $returnErrorObject),
-                'variance' => $this->__format($this->variance(), $returnErrorObject),
-                'range' => $this->__format($this->range(), $returnErrorObject)
-            );
-    }/*}}}*/
-
-    /**
-     * Calculates a full set of statistics
-     *
-     * @access  public
-     * @param boolean $returnErrorObject whether the raw PEAR_Error (when true, default),
-     *                  or only the error message will be returned (when false), if an error happens.
-     * @return  mixed   an associative array of statistics on success, a PEAR_Error object otherwise
-     * @see calc()
-     * @see calcBasic()
-     */
-    function calcFull($returnErrorObject=true) {/*{{{*/
-            return array (
-                'min' => $this->__format($this->min(), $returnErrorObject),
-                'max' => $this->__format($this->max(), $returnErrorObject),
-                'sum' => $this->__format($this->sum(), $returnErrorObject),
-                'sum2' => $this->__format($this->sum2(), $returnErrorObject),
-                'count' => $this->__format($this->count(), $returnErrorObject),
-                'mean' => $this->__format($this->mean(), $returnErrorObject),
-                'median' => $this->__format($this->median(), $returnErrorObject),
-                'mode' => $this->__format($this->mode(), $returnErrorObject),
-                'midrange' => $this->__format($this->midrange(), $returnErrorObject),
-                'geometric_mean' => $this->__format($this->geometricMean(), $returnErrorObject),
-                'harmonic_mean' => $this->__format($this->harmonicMean(), $returnErrorObject),
-                'stdev' => $this->__format($this->stDev(), $returnErrorObject),
-                'absdev' => $this->__format($this->absDev(), $returnErrorObject),
-                'variance' => $this->__format($this->variance(), $returnErrorObject),
-                'range' => $this->__format($this->range(), $returnErrorObject),
-                'std_error_of_mean' => $this->__format($this->stdErrorOfMean(), $returnErrorObject),
-                'skewness' => $this->__format($this->skewness(), $returnErrorObject),
-                'kurtosis' => $this->__format($this->kurtosis(), $returnErrorObject),
-                'coeff_of_variation' => $this->__format($this->coeffOfVariation(), $returnErrorObject),
-                'sample_central_moments' => array (
-                            1 => $this->__format($this->sampleCentralMoment(1), $returnErrorObject),
-                            2 => $this->__format($this->sampleCentralMoment(2), $returnErrorObject),
-                            3 => $this->__format($this->sampleCentralMoment(3), $returnErrorObject),
-                            4 => $this->__format($this->sampleCentralMoment(4), $returnErrorObject),
-                            5 => $this->__format($this->sampleCentralMoment(5), $returnErrorObject)
-                            ),
-                'sample_raw_moments' => array (
-                            1 => $this->__format($this->sampleRawMoment(1), $returnErrorObject),
-                            2 => $this->__format($this->sampleRawMoment(2), $returnErrorObject),
-                            3 => $this->__format($this->sampleRawMoment(3), $returnErrorObject),
-                            4 => $this->__format($this->sampleRawMoment(4), $returnErrorObject),
-                            5 => $this->__format($this->sampleRawMoment(5), $returnErrorObject)
-                            ),
-                'frequency' => $this->__format($this->frequency(), $returnErrorObject),
-                'quartiles' => $this->__format($this->quartiles(), $returnErrorObject),
-                'interquartile_range' => $this->__format($this->interquartileRange(), $returnErrorObject),
-                'interquartile_mean' => $this->__format($this->interquartileMean(), $returnErrorObject),
-                'quartile_deviation' => $this->__format($this->quartileDeviation(), $returnErrorObject),
-                'quartile_variation_coefficient' => $this->__format($this->quartileVariationCoefficient(), $returnErrorObject),
-                'quartile_skewness_coefficient' => $this->__format($this->quartileSkewnessCoefficient(), $returnErrorObject)
-            );
-    }/*}}}*/
-
-    /**
-     * Calculates the minimum of a data set.
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @return  mixed   the minimum value on success, a PEAR_Error object otherwise
-     * @see calc()
-     * @see max()
-     */
-    function min() {/*{{{*/
-        if ($this->_data == null) {
-            return PEAR::raiseError('data has not been set');
-        }
-        if (!array_key_exists('min', $this->_calculatedValues)) {
-            if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-                $min = min(array_keys($this->_data));
-            } else {
-                $min = min($this->_data);
-            }
-            $this->_calculatedValues['min'] = $min;
-        }
-        return $this->_calculatedValues['min'];
-    }/*}}}*/
-
-    /**
-     * Calculates the maximum of a data set.
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @return  mixed   the maximum value on success, a PEAR_Error object otherwise
-     * @see calc()
-     * @see min()
-     */
-    function max() {/*{{{*/
-        if ($this->_data == null) {
-            return PEAR::raiseError('data has not been set');
-        }
-        if (!array_key_exists('max', $this->_calculatedValues)) {
-            if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-                $max = max(array_keys($this->_data));
-            } else {
-                $max = max($this->_data);
-            }
-            $this->_calculatedValues['max'] = $max;
-        }
-        return $this->_calculatedValues['max'];
-    }/*}}}*/
-
-    /**
-     * Calculates SUM { xi }
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @return  mixed   the sum on success, a PEAR_Error object otherwise
-     * @see calc()
-     * @see sum2()
-     * @see sumN()
-     */
-    function sum() {/*{{{*/
-        if (!array_key_exists('sum', $this->_calculatedValues)) {
-            $sum = $this->sumN(1);
-            if (PEAR::isError($sum)) {
-                return $sum;
-            } else {
-                $this->_calculatedValues['sum'] = $sum;
-            }
-        }
-        return $this->_calculatedValues['sum'];
-    }/*}}}*/
-
-    /**
-     * Calculates SUM { (xi)^2 }
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @return  mixed   the sum on success, a PEAR_Error object otherwise
-     * @see calc()
-     * @see sum()
-     * @see sumN()
-     */
-    function sum2() {/*{{{*/
-        if (!array_key_exists('sum2', $this->_calculatedValues)) {
-            $sum2 = $this->sumN(2);
-            if (PEAR::isError($sum2)) {
-                return $sum2;
-            } else {
-                $this->_calculatedValues['sum2'] = $sum2;
-            }
-        }
-        return $this->_calculatedValues['sum2'];
-    }/*}}}*/
-
-    /**
-     * Calculates SUM { (xi)^n }
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @param   numeric $n  the exponent
-     * @return  mixed   the sum on success, a PEAR_Error object otherwise
-     * @see calc()
-     * @see sum()
-     * @see sum2()
-     */
-    function sumN($n) {/*{{{*/
-        if ($this->_data == null) {
-            return PEAR::raiseError('data has not been set');
-        }
-        $sumN = 0;
-        if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-            foreach($this->_data as $val=>$freq) {
-                $sumN += $freq * pow((double)$val, (double)$n);
-            }
-        } else {
-            foreach($this->_data as $val) {
-                $sumN += pow((double)$val, (double)$n);
-            }
-        }
-        return $sumN;
-    }/*}}}*/
-
-    /**
-     * Calculates PROD { (xi) }, (the product of all observations)
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @return  mixed   the product on success, a PEAR_Error object otherwise
-     * @see productN()
-     */
-    function product() {/*{{{*/
-        if (!array_key_exists('product', $this->_calculatedValues)) {
-            $product = $this->productN(1);
-            if (PEAR::isError($product)) {
-                return $product;
-            } else {
-                $this->_calculatedValues['product'] = $product;
-            }
-        }
-        return $this->_calculatedValues['product'];
-    }/*}}}*/
-
-    /**
-     * Calculates PROD { (xi)^n }, which is the product of all observations
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @param   numeric $n  the exponent
-     * @return  mixed   the product on success, a PEAR_Error object otherwise
-     * @see product()
-     */
-    function productN($n) {/*{{{*/
-        if ($this->_data == null) {
-            return PEAR::raiseError('data has not been set');
-        }
-        $prodN = 1.0;
-        if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-            foreach($this->_data as $val=>$freq) {
-                if ($val == 0) {
-                    return 0.0;
-                }
-                $prodN *= $freq * pow((double)$val, (double)$n);
-            }
-        } else {
-            foreach($this->_data as $val) {
-                if ($val == 0) {
-                    return 0.0;
-                }
-                $prodN *= pow((double)$val, (double)$n);
-            }
-        }
-        return $prodN;
-
-    }/*}}}*/
-
-    /**
-     * Calculates the number of data points in the set
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @return  mixed   the count on success, a PEAR_Error object otherwise
-     * @see calc()
-     */
-    function count() {/*{{{*/
-        if ($this->_data == null) {
-            return PEAR::raiseError('data has not been set');
-        }
-        if (!array_key_exists('count', $this->_calculatedValues)) {
-            if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-                $count = count($this->_dataExpanded);
-            } else {
-                $count = count($this->_data);
-            }
-            $this->_calculatedValues['count'] = $count;
-        }
-        return $this->_calculatedValues['count'];
-    }/*}}}*/
-
-    /**
-     * Calculates the mean (average) of the data points in the set
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @return  mixed   the mean value on success, a PEAR_Error object otherwise
-     * @see calc()
-     * @see sum()
-     * @see count()
-     */
-    function mean() {/*{{{*/
-        if (!array_key_exists('mean', $this->_calculatedValues)) {
-            $sum = $this->sum();
-            if (PEAR::isError($sum)) {
-                return $sum;
-            }
-            $count = $this->count();
-            if (PEAR::isError($count)) {
-                return $count;
-            }
-            $this->_calculatedValues['mean'] = $sum / $count;
-        }
-        return $this->_calculatedValues['mean'];
-    }/*}}}*/
-
-    /**
-     * Calculates the range of the data set = max - min
-     *
-     * @access public
-     * @return mixed the value of the range on success, a PEAR_Error object otherwise.
-     */
-    function range() {/*{{{*/
-        if (!array_key_exists('range', $this->_calculatedValues)) {
-            $min = $this->min();
-            if (PEAR::isError($min)) {
-                return $min;
-            }
-            $max = $this->max();
-            if (PEAR::isError($max)) {
-                return $max;
-            }
-            $this->_calculatedValues['range'] = $max - $min;
-        }
-        return $this->_calculatedValues['range'];
-
-    }/*}}}*/
-
-    /**
-     * Calculates the variance (unbiased) of the data points in the set
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @return  mixed   the variance value on success, a PEAR_Error object otherwise
-     * @see calc()
-     * @see __sumdiff()
-     * @see count()
-     */
-    function variance() {/*{{{*/
-        if (!array_key_exists('variance', $this->_calculatedValues)) {
-            $variance = $this->__calcVariance();
-            if (PEAR::isError($variance)) {
-                return $variance;
-            }
-            $this->_calculatedValues['variance'] = $variance;
-        }
-        return $this->_calculatedValues['variance'];
-    }/*}}}*/
-
-    /**
-     * Calculates the standard deviation (unbiased) of the data points in the set
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @return  mixed   the standard deviation on success, a PEAR_Error object otherwise
-     * @see calc()
-     * @see variance()
-     */
-    function stDev() {/*{{{*/
-        if (!array_key_exists('stDev', $this->_calculatedValues)) {
-            $variance = $this->variance();
-            if (PEAR::isError($variance)) {
-                return $variance;
-            }
-            $this->_calculatedValues['stDev'] = sqrt($variance);
-        }
-        return $this->_calculatedValues['stDev'];
-    }/*}}}*/
-
-    /**
-     * Calculates the variance (unbiased) of the data points in the set
-     * given a fixed mean (average) value. Not used in calcBasic(), calcFull()
-     * or calc().
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @param   numeric $mean   the fixed mean value
-     * @return  mixed   the variance on success, a PEAR_Error object otherwise
-     * @see __sumdiff()
-     * @see count()
-     * @see variance()
-     */
-    function varianceWithMean($mean) {/*{{{*/
-        return $this->__calcVariance($mean);
-    }/*}}}*/
-
-    /**
-     * Calculates the standard deviation (unbiased) of the data points in the set
-     * given a fixed mean (average) value. Not used in calcBasic(), calcFull()
-     * or calc().
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @param   numeric $mean   the fixed mean value
-     * @return  mixed   the standard deviation on success, a PEAR_Error object otherwise
-     * @see varianceWithMean()
-     * @see stDev()
-     */
-    function stDevWithMean($mean) {/*{{{*/
-        $varianceWM = $this->varianceWithMean($mean);
-        if (PEAR::isError($varianceWM)) {
-            return $varianceWM;
-        }
-        return sqrt($varianceWM);
-    }/*}}}*/
-
-    /**
-     * Calculates the absolute deviation of the data points in the set
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @return  mixed   the absolute deviation on success, a PEAR_Error object otherwise
-     * @see calc()
-     * @see __sumabsdev()
-     * @see count()
-     * @see absDevWithMean()
-     */
-    function absDev() {/*{{{*/
-        if (!array_key_exists('absDev', $this->_calculatedValues)) {
-            $absDev = $this->__calcAbsoluteDeviation();
-            if (PEAR::isError($absdev)) {
-                return $absdev;
-            }
-            $this->_calculatedValues['absDev'] = $absDev;
-        }
-        return $this->_calculatedValues['absDev'];
-    }/*}}}*/
-
-    /**
-     * Calculates the absolute deviation of the data points in the set
-     * given a fixed mean (average) value. Not used in calcBasic(), calcFull()
-     * or calc().
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @param   numeric $mean   the fixed mean value
-     * @return  mixed   the absolute deviation on success, a PEAR_Error object otherwise
-     * @see __sumabsdev()
-     * @see absDev()
-     */
-    function absDevWithMean($mean) {/*{{{*/
-        return $this->__calcAbsoluteDeviation($mean);
-    }/*}}}*/
-
-    /**
-     * Calculates the skewness of the data distribution in the set
-     * The skewness measures the degree of asymmetry of a distribution,
-     * and is related to the third central moment of a distribution.
-     * A normal distribution has a skewness = 0
-     * A distribution with a tail off towards the high end of the scale
-     * (positive skew) has a skewness > 0
-     * A distribution with a tail off towards the low end of the scale
-     * (negative skew) has a skewness < 0
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @return  mixed   the skewness value on success, a PEAR_Error object otherwise
-     * @see __sumdiff()
-     * @see count()
-     * @see stDev()
-     * @see calc()
-     */
-    function skewness() {/*{{{*/
-        if (!array_key_exists('skewness', $this->_calculatedValues)) {
-            $count = $this->count();
-            if (PEAR::isError($count)) {
-                return $count;
-            }
-            $stDev = $this->stDev();
-            if (PEAR::isError($stDev)) {
-                return $stDev;
-            }
-            $sumdiff3 = $this->__sumdiff(3);
-            if (PEAR::isError($sumdiff3)) {
-                return $sumdiff3;
-            }
-            $this->_calculatedValues['skewness'] = ($sumdiff3 / ($count * pow($stDev, 3)));
-        }
-        return $this->_calculatedValues['skewness'];
-    }/*}}}*/
-
-    /**
-     * Calculates the kurtosis of the data distribution in the set
-     * The kurtosis measures the degrees of peakedness of a distribution.
-     * It is also called the "excess" or "excess coefficient", and is
-     * a normalized form of the fourth central moment of a distribution.
-     * A normal distributions has kurtosis = 0
-     * A narrow and peaked (leptokurtic) distribution has a
-     * kurtosis > 0
-     * A flat and wide (platykurtic) distribution has a kurtosis < 0
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @return  mixed   the kurtosis value on success, a PEAR_Error object otherwise
-     * @see __sumdiff()
-     * @see count()
-     * @see stDev()
-     * @see calc()
-     */
-    function kurtosis() {/*{{{*/
-        if (!array_key_exists('kurtosis', $this->_calculatedValues)) {
-            $count = $this->count();
-            if (PEAR::isError($count)) {
-                return $count;
-            }
-            $stDev = $this->stDev();
-            if (PEAR::isError($stDev)) {
-                return $stDev;
-            }
-            $sumdiff4 = $this->__sumdiff(4);
-            if (PEAR::isError($sumdiff4)) {
-                return $sumdiff4;
-            }
-            $this->_calculatedValues['kurtosis'] = ($sumdiff4 / ($count * pow($stDev, 4))) - 3;
-        }
-        return $this->_calculatedValues['kurtosis'];
-    }/*}}}*/
-
-    /**
-     * Calculates the median of a data set.
-     * The median is the value such that half of the points are below it
-     * in a sorted data set.
-     * If the number of values is odd, it is the middle item.
-     * If the number of values is even, is the average of the two middle items.
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @return  mixed   the median value on success, a PEAR_Error object otherwise
-     * @see count()
-     * @see calc()
-     */
-    function median() {/*{{{*/
-        if ($this->_data == null) {
-            return PEAR::raiseError('data has not been set');
-        }
-        if (!array_key_exists('median', $this->_calculatedValues)) {
-            if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-                $arr =& $this->_dataExpanded;
-            } else {
-                $arr =& $this->_data;
-            }
-            $n = $this->count();
-            if (PEAR::isError($n)) {
-                return $n;
-            }
-            $h = intval($n / 2);
-            if ($n % 2 == 0) {
-                $median = ($arr[$h] + $arr[$h - 1]) / 2;
-            } else {
-                $median = $arr[$h + 1];
-            }
-            $this->_calculatedValues['median'] = $median;
-        }
-        return $this->_calculatedValues['median'];
-    }/*}}}*/
-
-    /**
-     * Calculates the mode of a data set.
-     * The mode is the value with the highest frequency in the data set.
-     * There can be more than one mode.
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @return  mixed   an array of mode value on success, a PEAR_Error object otherwise
-     * @see frequency()
-     * @see calc()
-     */
-    function mode() {/*{{{*/
-        if ($this->_data == null) {
-            return PEAR::raiseError('data has not been set');
-        }
-        if (!array_key_exists('mode', $this->_calculatedValues)) {
-            if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-                $arr = $this->_data;
-            } else {
-                $arr = $this->frequency();
-            }
-            arsort($arr);
-            $mcount = 1;
-            foreach ($arr as $val=>$freq) {
-                if ($mcount == 1) {
-                    $mode = array($val);
-                    $mfreq = $freq;
-                    ++$mcount;
-                    continue;
-                }
-                if ($mfreq == $freq)
-                    $mode[] = $val;
-                if ($mfreq > $freq)
-                    break;
-            }
-            $this->_calculatedValues['mode'] = $mode;
-        }
-        return $this->_calculatedValues['mode'];
-    }/*}}}*/
-
-    /**
-     * Calculates the midrange of a data set.
-     * The midrange is the average of the minimum and maximum of the data set.
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @return  mixed   the midrange value on success, a PEAR_Error object otherwise
-     * @see min()
-     * @see max()
-     * @see calc()
-     */
-    function midrange() {/*{{{*/
-        if (!array_key_exists('midrange', $this->_calculatedValues)) {
-            $min = $this->min();
-            if (PEAR::isError($min)) {
-                return $min;
-            }
-            $max = $this->max();
-            if (PEAR::isError($max)) {
-                return $max;
-            }
-            $this->_calculatedValues['midrange'] = (($max + $min) / 2);
-        }
-        return $this->_calculatedValues['midrange'];
-    }/*}}}*/
-
-    /**
-     * Calculates the geometrical mean of the data points in the set
-     * Handles cummulative data sets correctly
-     *
-     * @access public
-     * @return mixed the geometrical mean value on success, a PEAR_Error object otherwise
-     * @see calc()
-     * @see product()
-     * @see count()
-     */
-    function geometricMean() {/*{{{*/
-        if (!array_key_exists('geometricMean', $this->_calculatedValues)) {
-            $count = $this->count();
-            if (PEAR::isError($count)) {
-                return $count;
-            }
-            $prod = $this->product();
-            if (PEAR::isError($prod)) {
-                return $prod;
-            }
-            if ($prod == 0.0) {
-                return 0.0;
-            }
-            if ($prod < 0) {
-                return PEAR::raiseError('The product of the data set is negative, geometric mean undefined.');
-            }
-            $this->_calculatedValues['geometricMean'] = pow($prod , 1 / $count);
-        }
-        return $this->_calculatedValues['geometricMean'];
-    }/*}}}*/
-
-    /**
-     * Calculates the harmonic mean of the data points in the set
-     * Handles cummulative data sets correctly
-     *
-     * @access public
-     * @return mixed the harmonic mean value on success, a PEAR_Error object otherwise
-     * @see calc()
-     * @see count()
-     */
-    function harmonicMean() {/*{{{*/
-        if ($this->_data == null) {
-            return PEAR::raiseError('data has not been set');
-        }
-        if (!array_key_exists('harmonicMean', $this->_calculatedValues)) {
-            $count = $this->count();
-            if (PEAR::isError($count)) {
-                return $count;
-            }
-            $invsum = 0.0;
-            if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-                foreach($this->_data as $val=>$freq) {
-                    if ($val == 0) {
-                        return PEAR::raiseError('cannot calculate a '.
-                                'harmonic mean with data values of zero.');
-                    }
-                    $invsum += $freq / $val;
-                }
-            } else {
-                foreach($this->_data as $val) {
-                    if ($val == 0) {
-                        return PEAR::raiseError('cannot calculate a '.
-                                'harmonic mean with data values of zero.');
-                    }
-                    $invsum += 1 / $val;
-                }
-            }
-            $this->_calculatedValues['harmonicMean'] = $count / $invsum;
-        }
-        return $this->_calculatedValues['harmonicMean'];
-    }/*}}}*/
-
-    /**
-     * Calculates the nth central moment (m{n}) of a data set.
-     *
-     * The definition of a sample central moment is:
-     *
-     *     m{n} = 1/N * SUM { (xi - avg)^n }
-     *
-     * where: N = sample size, avg = sample mean.
-     *
-     * @access public
-     * @param integer $n moment to calculate
-     * @return mixed the numeric value of the moment on success, PEAR_Error otherwise
-     */
-    function sampleCentralMoment($n) {/*{{{*/
-        if (!is_int($n) || $n < 1) {
-            return PEAR::isError('moment must be a positive integer >= 1.');
-        }
-
-        if ($n == 1) {
-            return 0;
-        }
-        $count = $this->count();
-        if (PEAR::isError($count)) {
-            return $count;
-        }
-        if ($count == 0) {
-            return PEAR::raiseError("Cannot calculate {$n}th sample moment, ".
-                    'there are zero data entries');
-        }
-        $sum = $this->__sumdiff($n);
-        if (PEAR::isError($sum)) {
-            return $sum;
-        }
-        return ($sum / $count);
-    }/*}}}*/
-
-    /**
-     * Calculates the nth raw moment (m{n}) of a data set.
-     *
-     * The definition of a sample central moment is:
-     *
-     *     m{n} = 1/N * SUM { xi^n }
-     *
-     * where: N = sample size, avg = sample mean.
-     *
-     * @access public
-     * @param integer $n moment to calculate
-     * @return mixed the numeric value of the moment on success, PEAR_Error otherwise
-     */
-    function sampleRawMoment($n) {/*{{{*/
-        if (!is_int($n) || $n < 1) {
-            return PEAR::isError('moment must be a positive integer >= 1.');
-        }
-
-        $count = $this->count();
-        if (PEAR::isError($count)) {
-            return $count;
-        }
-        if ($count == 0) {
-            return PEAR::raiseError("Cannot calculate {$n}th raw moment, ".
-                    'there are zero data entries.');
-        }
-        $sum = $this->sumN($n);
-        if (PEAR::isError($sum)) {
-            return $sum;
-        }
-        return ($sum / $count);
-    }/*}}}*/
-
-
-    /**
-     * Calculates the coefficient of variation of a data set.
-     * The coefficient of variation measures the spread of a set of data
-     * as a proportion of its mean. It is often expressed as a percentage.
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @return  mixed   the coefficient of variation on success, a PEAR_Error object otherwise
-     * @see stDev()
-     * @see mean()
-     * @see calc()
-     */
-    function coeffOfVariation() {/*{{{*/
-        if (!array_key_exists('coeffOfVariation', $this->_calculatedValues)) {
-            $mean = $this->mean();
-            if (PEAR::isError($mean)) {
-                return $mean;
-            }
-            if ($mean == 0.0) {
-                return PEAR::raiseError('cannot calculate the coefficient '.
-                        'of variation, mean of sample is zero');
-            }
-            $stDev = $this->stDev();
-            if (PEAR::isError($stDev)) {
-                return $stDev;
-            }
-
-            $this->_calculatedValues['coeffOfVariation'] = $stDev / $mean;
-        }
-        return $this->_calculatedValues['coeffOfVariation'];
-    }/*}}}*/
-
-    /**
-     * Calculates the standard error of the mean.
-     * It is the standard deviation of the sampling distribution of
-     * the mean. The formula is:
-     *
-     * S.E. Mean = SD / (N)^(1/2)
-     *
-     * This formula does not assume a normal distribution, and shows
-     * that the size of the standard error of the mean is inversely
-     * proportional to the square root of the sample size.
-     *
-     * @access  public
-     * @return  mixed   the standard error of the mean on success, a PEAR_Error object otherwise
-     * @see stDev()
-     * @see count()
-     * @see calc()
-     */
-    function stdErrorOfMean() {/*{{{*/
-        if (!array_key_exists('stdErrorOfMean', $this->_calculatedValues)) {
-            $count = $this->count();
-            if (PEAR::isError($count)) {
-                return $count;
-            }
-            $stDev = $this->stDev();
-            if (PEAR::isError($stDev)) {
-                return $stDev;
-            }
-            $this->_calculatedValues['stdErrorOfMean'] = $stDev / sqrt($count);
-        }
-        return $this->_calculatedValues['stdErrorOfMean'];
-    }/*}}}*/
-
-    /**
-     * Calculates the value frequency table of a data set.
-     * Handles cummulative data sets correctly
-     *
-     * @access  public
-     * @return  mixed   an associative array of value=>frequency items on success, a PEAR_Error object otherwise
-     * @see min()
-     * @see max()
-     * @see calc()
-     */
-    function frequency() {/*{{{*/
-        if ($this->_data == null) {
-            return PEAR::raiseError('data has not been set');
-        }
-        if (!array_key_exists('frequency', $this->_calculatedValues)) {
-            if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-                $freq = $this->_data;
-            } else {
-                $freq = array();
-                foreach ($this->_data as $val) {
-                    $freq["$val"]++;
-                }
-                ksort($freq);
-            }
-            $this->_calculatedValues['frequency'] = $freq;
-        }
-        return $this->_calculatedValues['frequency'];
-    }/*}}}*/
-
-    /**
-     * The quartiles are defined as the values that divide a sorted
-     * data set into four equal-sized subsets, and correspond to the
-     * 25th, 50th, and 75th percentiles.
-     *
-     * @access public
-     * @return mixed an associative array of quartiles on success, a PEAR_Error otherwise
-     * @see percentile()
-     */
-    function quartiles() {/*{{{*/
-        if (!array_key_exists('quartiles', $this->_calculatedValues)) {
-            $q1 = $this->percentile(25);
-            if (PEAR::isError($q1)) {
-                return $q1;
-            }
-            $q2 = $this->percentile(50);
-            if (PEAR::isError($q2)) {
-                return $q2;
-            }
-            $q3 = $this->percentile(75);
-            if (PEAR::isError($q3)) {
-                return $q3;
-            }
-            $this->_calculatedValues['quartiles'] = array (
-                                        '25' => $q1,
-                                        '50' => $q2,
-                                        '75' => $q3
-                                        );
-        }
-        return $this->_calculatedValues['quartiles'];
-    }/*}}}*/
-
-    /**
-     * The interquartile mean is defined as the mean of the values left
-     * after discarding the lower 25% and top 25% ranked values, i.e.:
-     *
-     *  interquart mean = mean(<P(25),P(75)>)
-     *
-     *  where: P = percentile
-     *
-     * @todo need to double check the equation
-     * @access public
-     * @return mixed a numeric value on success, a PEAR_Error otherwise
-     * @see quartiles()
-     */
-    function interquartileMean() {/*{{{*/
-        if (!array_key_exists('interquartileMean', $this->_calculatedValues)) {
-            $quart = $this->quartiles();
-            if (PEAR::isError($quart)) {
-                return $quart;
-            }
-            $q3 = $quart['75'];
-            $q1 = $quart['25'];
-            $sum = 0;
-            $n = 0;
-            foreach ($this->getData(true) as $val) {
-                if ($val >= $q1 && $val <= $q3) {
-                    $sum += $val;
-                    ++$n;
-                }
-            }
-            if ($n == 0) {
-                return PEAR::raiseError('error calculating interquartile mean, '.
-                                        'empty interquartile range of values.');
-            }
-            $this->_calculatedValues['interquartileMean'] = $sum / $n;
-        }
-        return $this->_calculatedValues['interquartileMean'];
-    }/*}}}*/
-
-    /**
-     * The interquartile range is the distance between the 75th and 25th
-     * percentiles. Basically the range of the middle 50% of the data set,
-     * and thus is not affected by outliers or extreme values.
-     *
-     *  interquart range = P(75) - P(25)
-     *
-     *  where: P = percentile
-     *
-     * @access public
-     * @return mixed a numeric value on success, a PEAR_Error otherwise
-     * @see quartiles()
-     */
-    function interquartileRange() {/*{{{*/
-        if (!array_key_exists('interquartileRange', $this->_calculatedValues)) {
-            $quart = $this->quartiles();
-            if (PEAR::isError($quart)) {
-                return $quart;
-            }
-            $q3 = $quart['75'];
-            $q1 = $quart['25'];
-            $this->_calculatedValues['interquartileRange'] = $q3 - $q1;
-        }
-        return $this->_calculatedValues['interquartileRange'];
-    }/*}}}*/
-
-    /**
-     * The quartile deviation is half of the interquartile range value
-     *
-     *  quart dev = (P(75) - P(25)) / 2
-     *
-     *  where: P = percentile
-     *
-     * @access public
-     * @return mixed a numeric value on success, a PEAR_Error otherwise
-     * @see quartiles()
-     * @see interquartileRange()
-     */
-    function quartileDeviation() {/*{{{*/
-        if (!array_key_exists('quartileDeviation', $this->_calculatedValues)) {
-            $iqr = $this->interquartileRange();
-            if (PEAR::isError($iqr)) {
-                return $iqr;
-            }
-            $this->_calculatedValues['quartileDeviation'] = $iqr / 2;
-        }
-        return $this->_calculatedValues['quartileDeviation'];
-    }/*}}}*/
-
-    /**
-     * The quartile variation coefficient is defines as follows:
-     *
-     *  quart var coeff = 100 * (P(75) - P(25)) / (P(75) + P(25))
-     *
-     *  where: P = percentile
-     *
-     * @todo need to double check the equation
-     * @access public
-     * @return mixed a numeric value on success, a PEAR_Error otherwise
-     * @see quartiles()
-     */
-    function quartileVariationCoefficient() {/*{{{*/
-        if (!array_key_exists('quartileVariationCoefficient', $this->_calculatedValues)) {
-            $quart = $this->quartiles();
-            if (PEAR::isError($quart)) {
-                return $quart;
-            }
-            $q3 = $quart['75'];
-            $q1 = $quart['25'];
-            $d = $q3 - $q1;
-            $s = $q3 + $q1;
-            $this->_calculatedValues['quartileVariationCoefficient'] = 100 * $d / $s;
-        }
-        return $this->_calculatedValues['quartileVariationCoefficient'];
-    }/*}}}*/
-
-    /**
-     * The quartile skewness coefficient (also known as Bowley Skewness),
-     * is defined as follows:
-     *
-     *  quart skewness coeff = (P(25) - 2*P(50) + P(75)) / (P(75) - P(25))
-     *
-     *  where: P = percentile
-     *
-     * @todo need to double check the equation
-     * @access public
-     * @return mixed a numeric value on success, a PEAR_Error otherwise
-     * @see quartiles()
-     */
-    function quartileSkewnessCoefficient() {/*{{{*/
-        if (!array_key_exists('quartileSkewnessCoefficient', $this->_calculatedValues)) {
-            $quart = $this->quartiles();
-            if (PEAR::isError($quart)) {
-                return $quart;
-            }
-            $q3 = $quart['75'];
-            $q2 = $quart['50'];
-            $q1 = $quart['25'];
-            $d = $q3 - 2*$q2 + $q1;
-            $s = $q3 - $q1;
-            $this->_calculatedValues['quartileSkewnessCoefficient'] = $d / $s;
-        }
-        return $this->_calculatedValues['quartileSkewnessCoefficient'];
-    }/*}}}*/
-
-    /**
-     * The pth percentile is the value such that p% of the a sorted data set
-     * is smaller than it, and (100 - p)% of the data is larger.
-     *
-     * A quick algorithm to pick the appropriate value from a sorted data
-     * set is as follows:
-     *
-     * - Count the number of values: n
-     * - Calculate the position of the value in the data list: i = p * (n + 1)
-     * - if i is an integer, return the data at that position
-     * - if i < 1, return the minimum of the data set
-     * - if i > n, return the maximum of the data set
-     * - otherwise, average the entries at adjacent positions to i
-     *
-     * The median is the 50th percentile value.
-     *
-     * @todo need to double check generality of the algorithm
-     *
-     * @access public
-     * @param numeric $p the percentile to estimate, e.g. 25 for 25th percentile
-     * @return mixed a numeric value on success, a PEAR_Error otherwise
-     * @see quartiles()
-     * @see median()
-     */
-    function percentile($p) {/*{{{*/
-        $count = $this->count();
-        if (PEAR::isError($count)) {
-            return $count;
-        }
-        if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-            $data =& $this->_dataExpanded;
-        } else {
-            $data =& $this->_data;
-        }
-        $obsidx = $p * ($count + 1) / 100;
-        if (intval($obsidx) == $obsidx) {
-            return $data[($obsidx - 1)];
-        } elseif ($obsidx < 1) {
-            return $data[0];
-        } elseif ($obsidx > $count) {
-            return $data[($count - 1)];
-        } else {
-            $left = floor($obsidx - 1);
-            $right = ceil($obsidx - 1);
-            return ($data[$left] + $data[$right]) / 2;
-        }
-    }/*}}}*/
-
-    // private methods
-
-    /**
-     * Utility function to calculate: SUM { (xi - mean)^n }
-     *
-     * @access private
-     * @param   numeric $power  the exponent
-     * @param   optional    double   $mean   the data set mean value
-     * @return  mixed   the sum on success, a PEAR_Error object otherwise
-     *
-     * @see stDev()
-     * @see variaceWithMean();
-     * @see skewness();
-     * @see kurtosis();
-     */
-    function __sumdiff($power, $mean=null) {/*{{{*/
-        if ($this->_data == null) {
-            return PEAR::raiseError('data has not been set');
-        }
-        if (is_null($mean)) {
-            $mean = $this->mean();
-            if (PEAR::isError($mean)) {
-                return $mean;
-            }
-        }
-        $sdiff = 0;
-        if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-            foreach ($this->_data as $val=>$freq) {
-                $sdiff += $freq * pow((double)($val - $mean), (double)$power);
-            }
-        } else {
-            foreach ($this->_data as $val)
-                $sdiff += pow((double)($val - $mean), (double)$power);
-        }
-        return $sdiff;
-    }/*}}}*/
-
-    /**
-     * Utility function to calculate the variance with or without
-     * a fixed mean
-     *
-     * @access private
-     * @param $mean the fixed mean to use, null as default
-     * @return mixed a numeric value on success, a PEAR_Error otherwise
-     * @see variance()
-     * @see varianceWithMean()
-     */
-    function __calcVariance($mean = null) {/*{{{*/
-        if ($this->_data == null) {
-            return PEAR::raiseError('data has not been set');
-        }
-        $sumdiff2 = $this->__sumdiff(2, $mean);
-        if (PEAR::isError($sumdiff2)) {
-            return $sumdiff2;
-        }
-        $count = $this->count();
-        if (PEAR::isError($count)) {
-            return $count;
-        }
-        if ($count == 1) {
-            return PEAR::raiseError('cannot calculate variance of a singe data point');
-        }
-        return  ($sumdiff2 / ($count - 1));
-    }/*}}}*/
-
-    /**
-     * Utility function to calculate the absolute deviation with or without
-     * a fixed mean
-     *
-     * @access private
-     * @param $mean the fixed mean to use, null as default
-     * @return mixed a numeric value on success, a PEAR_Error otherwise
-     * @see absDev()
-     * @see absDevWithMean()
-     */
-    function __calcAbsoluteDeviation($mean = null) {/*{{{*/
-        if ($this->_data == null) {
-            return PEAR::raiseError('data has not been set');
-        }
-        $count = $this->count();
-        if (PEAR::isError($count)) {
-            return $count;
-        }
-        $sumabsdev = $this->__sumabsdev($mean);
-        if (PEAR::isError($sumabsdev)) {
-            return $sumabsdev;
-        }
-        return $sumabsdev / $count;
-    }/*}}}*/
-
-    /**
-     * Utility function to calculate: SUM { | xi - mean | }
-     *
-     * @access  private
-     * @param   optional    double   $mean   the mean value for the set or population
-     * @return  mixed   the sum on success, a PEAR_Error object otherwise
-     *
-     * @see absDev()
-     * @see absDevWithMean()
-     */
-    function __sumabsdev($mean=null) {/*{{{*/
-        if ($this->_data == null) {
-            return PEAR::raiseError('data has not been set');
-        }
-        if (is_null($mean)) {
-            $mean = $this->mean();
-        }
-        $sdev = 0;
-        if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-            foreach ($this->_data as $val=>$freq) {
-                $sdev += $freq * abs($val - $mean);
-            }
-        } else {
-            foreach ($this->_data as $val) {
-                $sdev += abs($val - $mean);
-            }
-        }
-        return $sdev;
-    }/*}}}*/
-
-    /**
-     * Utility function to format a PEAR_Error to be used by calc(),
-     * calcBasic() and calcFull()
-     *
-     * @access private
-     * @param mixed $v value to be formatted
-     * @param boolean $returnErrorObject whether the raw PEAR_Error (when true, default),
-     *                  or only the error message will be returned (when false)
-     * @return mixed if the value is a PEAR_Error object, and $useErrorObject
-     *              is false, then a string with the error message will be returned,
-     *              otherwise the value will not be modified and returned as passed.
-     */
-    function __format($v, $useErrorObject=true) {/*{{{*/
-        if (PEAR::isError($v) && $useErrorObject == false) {
-            return $v->getMessage();
-        } else {
-            return $v;
-        }
-    }/*}}}*/
-
-    /**
-     * Utility function to validate the data and modify it
-     * according to the current null handling option
-     *
-     * @access  private
-     * @return  mixed true on success, a PEAR_Error object otherwise
-     *
-     * @see setData()
-     */
-    function _validate() {/*{{{*/
-        $flag = ($this->_dataOption == STATS_DATA_CUMMULATIVE);
-        foreach ($this->_data as $key=>$value) {
-            $d = ($flag) ? $key : $value;
-            $v = ($flag) ? $value : $key;
-            if (!is_numeric($d)) {
-                switch ($this->_nullOption) {
-                    case STATS_IGNORE_NULL :
-                        unset($this->_data["$key"]);
-                        break;
-                    case STATS_USE_NULL_AS_ZERO:
-                        if ($flag) {
-                            unset($this->_data["$key"]);
-                            $this->_data[0] += $v;
-                        } else {
-                            $this->_data[$key] = 0;
-                        }
-                        break;
-                    case STATS_REJECT_NULL :
-                    default:
-                        return PEAR::raiseError('data rejected, contains NULL values');
-                        break;
-                }
-            }
-        }
-        if ($flag) {
-            ksort($this->_data);
-            $this->_dataExpanded = array();
-            foreach ($this->_data as $val=>$freq) {
-                $this->_dataExpanded = array_pad($this->_dataExpanded, count($this->_dataExpanded) + $freq, $val);
-            }
-            sort($this->_dataExpanded);
-        } else {
-            sort($this->_data);
-        }
-        return true;
-    }/*}}}*/
+	// properties /*{{{*/
+
+	/**
+	 * The simple or cummulative data set.
+	 * Null by default.
+	 *
+	 * @access  private
+	 * @var array
+	 */
+	public $_data = null;
+
+	/**
+	 * Expanded data set. Only set when cummulative data
+	 * is being used. Null by default.
+	 *
+	 * @access  private
+	 * @var array
+	 */
+	public $_dataExpanded = null;
+
+	/**
+	 * Flag for data type, one of STATS_DATA_SIMPLE or
+	 * STATS_DATA_CUMMULATIVE. Null by default.
+	 *
+	 * @access  private
+	 * @var int
+	 */
+	public $_dataOption = null;
+
+	/**
+	 * Flag for null handling options. One of STATS_REJECT_NULL,
+	 * STATS_IGNORE_NULL or STATS_USE_NULL_AS_ZERO
+	 *
+	 * @access  private
+	 * @var int
+	 */
+	public $_nullOption;
+
+	/**
+	 * Array for caching result values, should be reset
+	 * when using setData()
+	 *
+	 * @access private
+	 * @var array
+	 */
+	public $_calculatedValues = array();
+
+	/*}}}*/
+
+	/**
+	 * Constructor for the class
+	 *
+	 * @access  public
+	 * @param   optional    int $nullOption how to handle null values
+	 * @return  object  Math_Stats
+	 */
+	function Math_Stats($nullOption=STATS_REJECT_NULL) {/*{{{*/
+		$this->_nullOption = $nullOption;
+	}/*}}}*/
+
+	/**
+	 * Sets and verifies the data, checking for nulls and using
+	 * the current null handling option
+	 *
+	 * @access public
+	 * @param   array   $arr    the data set
+	 * @param   optional    int $opt    data format: STATS_DATA_CUMMULATIVE or STATS_DATA_SIMPLE (default)
+	 * @return  mixed   true on success, a PEAR_Error object otherwise
+	 */
+	function setData($arr, $opt=STATS_DATA_SIMPLE) {/*{{{*/
+		if (!is_array($arr)) {
+			return PEAR::raiseError('invalid data, an array of numeric data was expected');
+		}
+		$this->_data = null;
+		$this->_dataExpanded = null;
+		$this->_dataOption = null;
+		$this->_calculatedValues = array();
+		if ($opt == STATS_DATA_SIMPLE) {
+			$this->_dataOption = $opt;
+			$this->_data = array_values($arr);
+		} else if ($opt == STATS_DATA_CUMMULATIVE) {
+			$this->_dataOption = $opt;
+			$this->_data = $arr;
+			$this->_dataExpanded = array();
+		}
+		return $this->_validate();
+	}/*}}}*/
+
+	/**
+	 * Returns the data which might have been modified
+	 * according to the current null handling options.
+	 *
+	 * @access  public
+	 * @param boolean $expanded whether to return a expanded list, default is false
+	 * @return  mixed   array of data on success, a PEAR_Error object otherwise
+	 * @see _validate()
+	 */
+	function getData($expanded=false) {/*{{{*/
+		if ($this->_data == null) {
+			return PEAR::raiseError('data has not been set');
+		}
+		if ($this->_dataOption == STATS_DATA_CUMMULATIVE && $expanded) {
+			return $this->_dataExpanded;
+		} else {
+			return $this->_data;
+		}
+	}/*}}}*/
+
+	/**
+	 * Sets the null handling option.
+	 * Must be called before assigning a new data set containing null values
+	 *
+	 * @access  public
+	 * @return  mixed   true on success, a PEAR_Error object otherwise
+	 * @see _validate()
+	 */
+	function setNullOption($nullOption) {/*{{{*/
+		if ($nullOption == STATS_REJECT_NULL
+			|| $nullOption == STATS_IGNORE_NULL
+			|| $nullOption == STATS_USE_NULL_AS_ZERO) {
+			$this->_nullOption = $nullOption;
+			return true;
+		} else {
+			return PEAR::raiseError('invalid null handling option expecting: '.
+						'STATS_REJECT_NULL, STATS_IGNORE_NULL or STATS_USE_NULL_AS_ZERO');
+		}
+	}/*}}}*/
+
+	/**
+	 * Transforms the data by substracting each entry from the mean and
+	 * dividing by its standard deviation. This will reset all pre-calculated
+	 * values to their original (unset) defaults.
+	 *
+	 * @access public
+	 * @return mixed true on success, a PEAR_Error object otherwise
+	 * @see mean()
+	 * @see stDev()
+	 * @see setData()
+	 */
+	function studentize() {/*{{{*/
+		$mean = $this->mean();
+		if (PEAR::isError($mean)) {
+			return $mean;
+		}
+		$std = $this->stDev();
+		if (PEAR::isError($std)) {
+			return $std;
+		}
+		if ($std == 0) {
+			return PEAR::raiseError('cannot studentize data, standard deviation is zero.');
+		}
+		$arr  = array();
+		if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
+			foreach ($this->_data as $val=>$freq) {
+				$newval = ($val - $mean) / $std;
+				$arr["$newval"] = $freq;
+			}
+		} else {
+			foreach ($this->_data as $val) {
+				$newval = ($val - $mean) / $std;
+				$arr[] = $newval;
+			}
+		}
+		return $this->setData($arr, $this->_dataOption);
+	}/*}}}*/
+
+	/**
+	 * Transforms the data by substracting each entry from the mean.
+	 * This will reset all pre-calculated values to their original (unset) defaults.
+	 *
+	 * @access public
+	 * @return mixed true on success, a PEAR_Error object otherwise
+	 * @see mean()
+	 * @see setData()
+	 */
+	function center() {/*{{{*/
+		$mean = $this->mean();
+		if (PEAR::isError($mean)) {
+			return $mean;
+		}
+		$arr  = array();
+		if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
+			foreach ($this->_data as $val=>$freq) {
+				$newval = $val - $mean;
+				$arr["$newval"] = $freq;
+			}
+		} else {
+			foreach ($this->_data as $val) {
+				$newval = $val - $mean;
+				$arr[] = $newval;
+			}
+		}
+		return $this->setData($arr, $this->_dataOption);
+	}/*}}}*/
+
+	/**
+	 * Calculates the basic or full statistics for the data set
+	 *
+	 * @access  public
+	 * @param   int $mode   one of STATS_BASIC or STATS_FULL
+	 * @param boolean $returnErrorObject whether the raw PEAR_Error (when true, default),
+	 *                  or only the error message will be returned (when false), if an error happens.
+	 * @return  mixed   an associative array of statistics on success, a PEAR_Error object otherwise
+	 * @see calcBasic()
+	 * @see calcFull()
+	 */
+	function calc($mode, $returnErrorObject=true) {/*{{{*/
+		if ($this->_data == null) {
+			return PEAR::raiseError('data has not been set');
+		}
+		if ($mode == STATS_BASIC) {
+			return $this->calcBasic($returnErrorObject);
+		} elseif ($mode == STATS_FULL) {
+			return $this->calcFull($returnErrorObject);
+		} else {
+			return PEAR::raiseError('incorrect mode, expected STATS_BASIC or STATS_FULL');
+		}
+	}/*}}}*/
+
+	/**
+	 * Calculates a basic set of statistics
+	 *
+	 * @access  public
+	 * @param boolean $returnErrorObject whether the raw PEAR_Error (when true, default),
+	 *                  or only the error message will be returned (when false), if an error happens.
+	 * @return  mixed   an associative array of statistics on success, a PEAR_Error object otherwise
+	 * @see calc()
+	 * @see calcFull()
+	 */
+	function calcBasic($returnErrorObject=true) {/*{{{*/
+			return array (
+				'min' => $this->__format($this->min(), $returnErrorObject),
+				'max' => $this->__format($this->max(), $returnErrorObject),
+				'sum' => $this->__format($this->sum(), $returnErrorObject),
+				'sum2' => $this->__format($this->sum2(), $returnErrorObject),
+				'count' => $this->__format($this->count(), $returnErrorObject),
+				'mean' => $this->__format($this->mean(), $returnErrorObject),
+				'stdev' => $this->__format($this->stDev(), $returnErrorObject),
+				'variance' => $this->__format($this->variance(), $returnErrorObject),
+				'range' => $this->__format($this->range(), $returnErrorObject)
+			);
+	}/*}}}*/
+
+	/**
+	 * Calculates a full set of statistics
+	 *
+	 * @access  public
+	 * @param boolean $returnErrorObject whether the raw PEAR_Error (when true, default),
+	 *                  or only the error message will be returned (when false), if an error happens.
+	 * @return  mixed   an associative array of statistics on success, a PEAR_Error object otherwise
+	 * @see calc()
+	 * @see calcBasic()
+	 */
+	function calcFull($returnErrorObject=true) {/*{{{*/
+			return array (
+				'min' => $this->__format($this->min(), $returnErrorObject),
+				'max' => $this->__format($this->max(), $returnErrorObject),
+				'sum' => $this->__format($this->sum(), $returnErrorObject),
+				'sum2' => $this->__format($this->sum2(), $returnErrorObject),
+				'count' => $this->__format($this->count(), $returnErrorObject),
+				'mean' => $this->__format($this->mean(), $returnErrorObject),
+				'median' => $this->__format($this->median(), $returnErrorObject),
+				'mode' => $this->__format($this->mode(), $returnErrorObject),
+				'midrange' => $this->__format($this->midrange(), $returnErrorObject),
+				'geometric_mean' => $this->__format($this->geometricMean(), $returnErrorObject),
+				'harmonic_mean' => $this->__format($this->harmonicMean(), $returnErrorObject),
+				'stdev' => $this->__format($this->stDev(), $returnErrorObject),
+				'absdev' => $this->__format($this->absDev(), $returnErrorObject),
+				'variance' => $this->__format($this->variance(), $returnErrorObject),
+				'range' => $this->__format($this->range(), $returnErrorObject),
+				'std_error_of_mean' => $this->__format($this->stdErrorOfMean(), $returnErrorObject),
+				'skewness' => $this->__format($this->skewness(), $returnErrorObject),
+				'kurtosis' => $this->__format($this->kurtosis(), $returnErrorObject),
+				'coeff_of_variation' => $this->__format($this->coeffOfVariation(), $returnErrorObject),
+				'sample_central_moments' => array (
+							1 => $this->__format($this->sampleCentralMoment(1), $returnErrorObject),
+							2 => $this->__format($this->sampleCentralMoment(2), $returnErrorObject),
+							3 => $this->__format($this->sampleCentralMoment(3), $returnErrorObject),
+							4 => $this->__format($this->sampleCentralMoment(4), $returnErrorObject),
+							5 => $this->__format($this->sampleCentralMoment(5), $returnErrorObject)
+							),
+				'sample_raw_moments' => array (
+							1 => $this->__format($this->sampleRawMoment(1), $returnErrorObject),
+							2 => $this->__format($this->sampleRawMoment(2), $returnErrorObject),
+							3 => $this->__format($this->sampleRawMoment(3), $returnErrorObject),
+							4 => $this->__format($this->sampleRawMoment(4), $returnErrorObject),
+							5 => $this->__format($this->sampleRawMoment(5), $returnErrorObject)
+							),
+				'frequency' => $this->__format($this->frequency(), $returnErrorObject),
+				'quartiles' => $this->__format($this->quartiles(), $returnErrorObject),
+				'interquartile_range' => $this->__format($this->interquartileRange(), $returnErrorObject),
+				'interquartile_mean' => $this->__format($this->interquartileMean(), $returnErrorObject),
+				'quartile_deviation' => $this->__format($this->quartileDeviation(), $returnErrorObject),
+				'quartile_variation_coefficient' => $this->__format($this->quartileVariationCoefficient(), $returnErrorObject),
+				'quartile_skewness_coefficient' => $this->__format($this->quartileSkewnessCoefficient(), $returnErrorObject)
+			);
+	}/*}}}*/
+
+	/**
+	 * Calculates the minimum of a data set.
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @return  mixed   the minimum value on success, a PEAR_Error object otherwise
+	 * @see calc()
+	 * @see max()
+	 */
+	function min() {/*{{{*/
+		if ($this->_data == null) {
+			return PEAR::raiseError('data has not been set');
+		}
+		if (!array_key_exists('min', $this->_calculatedValues)) {
+			if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
+				$min = min(array_keys($this->_data));
+			} else {
+				$min = min($this->_data);
+			}
+			$this->_calculatedValues['min'] = $min;
+		}
+		return $this->_calculatedValues['min'];
+	}/*}}}*/
+
+	/**
+	 * Calculates the maximum of a data set.
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @return  mixed   the maximum value on success, a PEAR_Error object otherwise
+	 * @see calc()
+	 * @see min()
+	 */
+	function max() {/*{{{*/
+		if ($this->_data == null) {
+			return PEAR::raiseError('data has not been set');
+		}
+		if (!array_key_exists('max', $this->_calculatedValues)) {
+			if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
+				$max = max(array_keys($this->_data));
+			} else {
+				$max = max($this->_data);
+			}
+			$this->_calculatedValues['max'] = $max;
+		}
+		return $this->_calculatedValues['max'];
+	}/*}}}*/
+
+	/**
+	 * Calculates SUM { xi }
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @return  mixed   the sum on success, a PEAR_Error object otherwise
+	 * @see calc()
+	 * @see sum2()
+	 * @see sumN()
+	 */
+	function sum() {/*{{{*/
+		if (!array_key_exists('sum', $this->_calculatedValues)) {
+			$sum = $this->sumN(1);
+			if (PEAR::isError($sum)) {
+				return $sum;
+			} else {
+				$this->_calculatedValues['sum'] = $sum;
+			}
+		}
+		return $this->_calculatedValues['sum'];
+	}/*}}}*/
+
+	/**
+	 * Calculates SUM { (xi)^2 }
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @return  mixed   the sum on success, a PEAR_Error object otherwise
+	 * @see calc()
+	 * @see sum()
+	 * @see sumN()
+	 */
+	function sum2() {/*{{{*/
+		if (!array_key_exists('sum2', $this->_calculatedValues)) {
+			$sum2 = $this->sumN(2);
+			if (PEAR::isError($sum2)) {
+				return $sum2;
+			} else {
+				$this->_calculatedValues['sum2'] = $sum2;
+			}
+		}
+		return $this->_calculatedValues['sum2'];
+	}/*}}}*/
+
+	/**
+	 * Calculates SUM { (xi)^n }
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @param   numeric $n  the exponent
+	 * @return  mixed   the sum on success, a PEAR_Error object otherwise
+	 * @see calc()
+	 * @see sum()
+	 * @see sum2()
+	 */
+	function sumN($n) {/*{{{*/
+		if ($this->_data == null) {
+			return PEAR::raiseError('data has not been set');
+		}
+		$sumN = 0;
+		if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
+			foreach($this->_data as $val=>$freq) {
+				$sumN += $freq * pow((double)$val, (double)$n);
+			}
+		} else {
+			foreach($this->_data as $val) {
+				$sumN += pow((double)$val, (double)$n);
+			}
+		}
+		return $sumN;
+	}/*}}}*/
+
+	/**
+	 * Calculates PROD { (xi) }, (the product of all observations)
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @return  mixed   the product on success, a PEAR_Error object otherwise
+	 * @see productN()
+	 */
+	function product() {/*{{{*/
+		if (!array_key_exists('product', $this->_calculatedValues)) {
+			$product = $this->productN(1);
+			if (PEAR::isError($product)) {
+				return $product;
+			} else {
+				$this->_calculatedValues['product'] = $product;
+			}
+		}
+		return $this->_calculatedValues['product'];
+	}/*}}}*/
+
+	/**
+	 * Calculates PROD { (xi)^n }, which is the product of all observations
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @param   numeric $n  the exponent
+	 * @return  mixed   the product on success, a PEAR_Error object otherwise
+	 * @see product()
+	 */
+	function productN($n) {/*{{{*/
+		if ($this->_data == null) {
+			return PEAR::raiseError('data has not been set');
+		}
+		$prodN = 1.0;
+		if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
+			foreach($this->_data as $val=>$freq) {
+				if ($val == 0) {
+					return 0.0;
+				}
+				$prodN *= $freq * pow((double)$val, (double)$n);
+			}
+		} else {
+			foreach($this->_data as $val) {
+				if ($val == 0) {
+					return 0.0;
+				}
+				$prodN *= pow((double)$val, (double)$n);
+			}
+		}
+		return $prodN;
+
+	}/*}}}*/
+
+	/**
+	 * Calculates the number of data points in the set
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @return  mixed   the count on success, a PEAR_Error object otherwise
+	 * @see calc()
+	 */
+	function count() {/*{{{*/
+		if ($this->_data == null) {
+			return PEAR::raiseError('data has not been set');
+		}
+		if (!array_key_exists('count', $this->_calculatedValues)) {
+			if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
+				$count = count($this->_dataExpanded);
+			} else {
+				$count = count($this->_data);
+			}
+			$this->_calculatedValues['count'] = $count;
+		}
+		return $this->_calculatedValues['count'];
+	}/*}}}*/
+
+	/**
+	 * Calculates the mean (average) of the data points in the set
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @return  mixed   the mean value on success, a PEAR_Error object otherwise
+	 * @see calc()
+	 * @see sum()
+	 * @see count()
+	 */
+	function mean() {/*{{{*/
+		if (!array_key_exists('mean', $this->_calculatedValues)) {
+			$sum = $this->sum();
+			if (PEAR::isError($sum)) {
+				return $sum;
+			}
+			$count = $this->count();
+			if (PEAR::isError($count)) {
+				return $count;
+			}
+			$this->_calculatedValues['mean'] = $sum / $count;
+		}
+		return $this->_calculatedValues['mean'];
+	}/*}}}*/
+
+	/**
+	 * Calculates the range of the data set = max - min
+	 *
+	 * @access public
+	 * @return mixed the value of the range on success, a PEAR_Error object otherwise.
+	 */
+	function range() {/*{{{*/
+		if (!array_key_exists('range', $this->_calculatedValues)) {
+			$min = $this->min();
+			if (PEAR::isError($min)) {
+				return $min;
+			}
+			$max = $this->max();
+			if (PEAR::isError($max)) {
+				return $max;
+			}
+			$this->_calculatedValues['range'] = $max - $min;
+		}
+		return $this->_calculatedValues['range'];
+
+	}/*}}}*/
+
+	/**
+	 * Calculates the variance (unbiased) of the data points in the set
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @return  mixed   the variance value on success, a PEAR_Error object otherwise
+	 * @see calc()
+	 * @see __sumdiff()
+	 * @see count()
+	 */
+	function variance() {/*{{{*/
+		if (!array_key_exists('variance', $this->_calculatedValues)) {
+			$variance = $this->__calcVariance();
+			if (PEAR::isError($variance)) {
+				return $variance;
+			}
+			$this->_calculatedValues['variance'] = $variance;
+		}
+		return $this->_calculatedValues['variance'];
+	}/*}}}*/
+
+	/**
+	 * Calculates the standard deviation (unbiased) of the data points in the set
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @return  mixed   the standard deviation on success, a PEAR_Error object otherwise
+	 * @see calc()
+	 * @see variance()
+	 */
+	function stDev() {/*{{{*/
+		if (!array_key_exists('stDev', $this->_calculatedValues)) {
+			$variance = $this->variance();
+			if (PEAR::isError($variance)) {
+				return $variance;
+			}
+			$this->_calculatedValues['stDev'] = sqrt($variance);
+		}
+		return $this->_calculatedValues['stDev'];
+	}/*}}}*/
+
+	/**
+	 * Calculates the variance (unbiased) of the data points in the set
+	 * given a fixed mean (average) value. Not used in calcBasic(), calcFull()
+	 * or calc().
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @param   numeric $mean   the fixed mean value
+	 * @return  mixed   the variance on success, a PEAR_Error object otherwise
+	 * @see __sumdiff()
+	 * @see count()
+	 * @see variance()
+	 */
+	function varianceWithMean($mean) {/*{{{*/
+		return $this->__calcVariance($mean);
+	}/*}}}*/
+
+	/**
+	 * Calculates the standard deviation (unbiased) of the data points in the set
+	 * given a fixed mean (average) value. Not used in calcBasic(), calcFull()
+	 * or calc().
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @param   numeric $mean   the fixed mean value
+	 * @return  mixed   the standard deviation on success, a PEAR_Error object otherwise
+	 * @see varianceWithMean()
+	 * @see stDev()
+	 */
+	function stDevWithMean($mean) {/*{{{*/
+		$varianceWM = $this->varianceWithMean($mean);
+		if (PEAR::isError($varianceWM)) {
+			return $varianceWM;
+		}
+		return sqrt($varianceWM);
+	}/*}}}*/
+
+	/**
+	 * Calculates the absolute deviation of the data points in the set
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @return  mixed   the absolute deviation on success, a PEAR_Error object otherwise
+	 * @see calc()
+	 * @see __sumabsdev()
+	 * @see count()
+	 * @see absDevWithMean()
+	 */
+	function absDev() {/*{{{*/
+		if (!array_key_exists('absDev', $this->_calculatedValues)) {
+			$absDev = $this->__calcAbsoluteDeviation();
+			if (PEAR::isError($absdev)) {
+				return $absdev;
+			}
+			$this->_calculatedValues['absDev'] = $absDev;
+		}
+		return $this->_calculatedValues['absDev'];
+	}/*}}}*/
+
+	/**
+	 * Calculates the absolute deviation of the data points in the set
+	 * given a fixed mean (average) value. Not used in calcBasic(), calcFull()
+	 * or calc().
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @param   numeric $mean   the fixed mean value
+	 * @return  mixed   the absolute deviation on success, a PEAR_Error object otherwise
+	 * @see __sumabsdev()
+	 * @see absDev()
+	 */
+	function absDevWithMean($mean) {/*{{{*/
+		return $this->__calcAbsoluteDeviation($mean);
+	}/*}}}*/
+
+	/**
+	 * Calculates the skewness of the data distribution in the set
+	 * The skewness measures the degree of asymmetry of a distribution,
+	 * and is related to the third central moment of a distribution.
+	 * A normal distribution has a skewness = 0
+	 * A distribution with a tail off towards the high end of the scale
+	 * (positive skew) has a skewness > 0
+	 * A distribution with a tail off towards the low end of the scale
+	 * (negative skew) has a skewness < 0
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @return  mixed   the skewness value on success, a PEAR_Error object otherwise
+	 * @see __sumdiff()
+	 * @see count()
+	 * @see stDev()
+	 * @see calc()
+	 */
+	function skewness() {/*{{{*/
+		if (!array_key_exists('skewness', $this->_calculatedValues)) {
+			$count = $this->count();
+			if (PEAR::isError($count)) {
+				return $count;
+			}
+			$stDev = $this->stDev();
+			if (PEAR::isError($stDev)) {
+				return $stDev;
+			}
+			$sumdiff3 = $this->__sumdiff(3);
+			if (PEAR::isError($sumdiff3)) {
+				return $sumdiff3;
+			}
+			$this->_calculatedValues['skewness'] = ($sumdiff3 / ($count * pow($stDev, 3)));
+		}
+		return $this->_calculatedValues['skewness'];
+	}/*}}}*/
+
+	/**
+	 * Calculates the kurtosis of the data distribution in the set
+	 * The kurtosis measures the degrees of peakedness of a distribution.
+	 * It is also called the "excess" or "excess coefficient", and is
+	 * a normalized form of the fourth central moment of a distribution.
+	 * A normal distributions has kurtosis = 0
+	 * A narrow and peaked (leptokurtic) distribution has a
+	 * kurtosis > 0
+	 * A flat and wide (platykurtic) distribution has a kurtosis < 0
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @return  mixed   the kurtosis value on success, a PEAR_Error object otherwise
+	 * @see __sumdiff()
+	 * @see count()
+	 * @see stDev()
+	 * @see calc()
+	 */
+	function kurtosis() {/*{{{*/
+		if (!array_key_exists('kurtosis', $this->_calculatedValues)) {
+			$count = $this->count();
+			if (PEAR::isError($count)) {
+				return $count;
+			}
+			$stDev = $this->stDev();
+			if (PEAR::isError($stDev)) {
+				return $stDev;
+			}
+			$sumdiff4 = $this->__sumdiff(4);
+			if (PEAR::isError($sumdiff4)) {
+				return $sumdiff4;
+			}
+			$this->_calculatedValues['kurtosis'] = ($sumdiff4 / ($count * pow($stDev, 4))) - 3;
+		}
+		return $this->_calculatedValues['kurtosis'];
+	}/*}}}*/
+
+	/**
+	 * Calculates the median of a data set.
+	 * The median is the value such that half of the points are below it
+	 * in a sorted data set.
+	 * If the number of values is odd, it is the middle item.
+	 * If the number of values is even, is the average of the two middle items.
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @return  mixed   the median value on success, a PEAR_Error object otherwise
+	 * @see count()
+	 * @see calc()
+	 */
+	function median() {/*{{{*/
+		if ($this->_data == null) {
+			return PEAR::raiseError('data has not been set');
+		}
+		if (!array_key_exists('median', $this->_calculatedValues)) {
+			if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
+				$arr =& $this->_dataExpanded;
+			} else {
+				$arr =& $this->_data;
+			}
+			$n = $this->count();
+			if (PEAR::isError($n)) {
+				return $n;
+			}
+			$h = intval($n / 2);
+			if ($n % 2 == 0) {
+				$median = ($arr[$h] + $arr[$h - 1]) / 2;
+			} else {
+				$median = $arr[$h + 1];
+			}
+			$this->_calculatedValues['median'] = $median;
+		}
+		return $this->_calculatedValues['median'];
+	}/*}}}*/
+
+	/**
+	 * Calculates the mode of a data set.
+	 * The mode is the value with the highest frequency in the data set.
+	 * There can be more than one mode.
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @return  mixed   an array of mode value on success, a PEAR_Error object otherwise
+	 * @see frequency()
+	 * @see calc()
+	 */
+	function mode() {/*{{{*/
+		if ($this->_data == null) {
+			return PEAR::raiseError('data has not been set');
+		}
+		if (!array_key_exists('mode', $this->_calculatedValues)) {
+			if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
+				$arr = $this->_data;
+			} else {
+				$arr = $this->frequency();
+			}
+			arsort($arr);
+			$mcount = 1;
+			foreach ($arr as $val=>$freq) {
+				if ($mcount == 1) {
+					$mode = array($val);
+					$mfreq = $freq;
+					++$mcount;
+					continue;
+				}
+				if ($mfreq == $freq)
+					$mode[] = $val;
+				if ($mfreq > $freq)
+					break;
+			}
+			$this->_calculatedValues['mode'] = $mode;
+		}
+		return $this->_calculatedValues['mode'];
+	}/*}}}*/
+
+	/**
+	 * Calculates the midrange of a data set.
+	 * The midrange is the average of the minimum and maximum of the data set.
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @return  mixed   the midrange value on success, a PEAR_Error object otherwise
+	 * @see min()
+	 * @see max()
+	 * @see calc()
+	 */
+	function midrange() {/*{{{*/
+		if (!array_key_exists('midrange', $this->_calculatedValues)) {
+			$min = $this->min();
+			if (PEAR::isError($min)) {
+				return $min;
+			}
+			$max = $this->max();
+			if (PEAR::isError($max)) {
+				return $max;
+			}
+			$this->_calculatedValues['midrange'] = (($max + $min) / 2);
+		}
+		return $this->_calculatedValues['midrange'];
+	}/*}}}*/
+
+	/**
+	 * Calculates the geometrical mean of the data points in the set
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access public
+	 * @return mixed the geometrical mean value on success, a PEAR_Error object otherwise
+	 * @see calc()
+	 * @see product()
+	 * @see count()
+	 */
+	function geometricMean() {/*{{{*/
+		if (!array_key_exists('geometricMean', $this->_calculatedValues)) {
+			$count = $this->count();
+			if (PEAR::isError($count)) {
+				return $count;
+			}
+			$prod = $this->product();
+			if (PEAR::isError($prod)) {
+				return $prod;
+			}
+			if ($prod == 0.0) {
+				return 0.0;
+			}
+			if ($prod < 0) {
+				return PEAR::raiseError('The product of the data set is negative, geometric mean undefined.');
+			}
+			$this->_calculatedValues['geometricMean'] = pow($prod , 1 / $count);
+		}
+		return $this->_calculatedValues['geometricMean'];
+	}/*}}}*/
+
+	/**
+	 * Calculates the harmonic mean of the data points in the set
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access public
+	 * @return mixed the harmonic mean value on success, a PEAR_Error object otherwise
+	 * @see calc()
+	 * @see count()
+	 */
+	function harmonicMean() {/*{{{*/
+		if ($this->_data == null) {
+			return PEAR::raiseError('data has not been set');
+		}
+		if (!array_key_exists('harmonicMean', $this->_calculatedValues)) {
+			$count = $this->count();
+			if (PEAR::isError($count)) {
+				return $count;
+			}
+			$invsum = 0.0;
+			if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
+				foreach($this->_data as $val=>$freq) {
+					if ($val == 0) {
+						return PEAR::raiseError('cannot calculate a '.
+								'harmonic mean with data values of zero.');
+					}
+					$invsum += $freq / $val;
+				}
+			} else {
+				foreach($this->_data as $val) {
+					if ($val == 0) {
+						return PEAR::raiseError('cannot calculate a '.
+								'harmonic mean with data values of zero.');
+					}
+					$invsum += 1 / $val;
+				}
+			}
+			$this->_calculatedValues['harmonicMean'] = $count / $invsum;
+		}
+		return $this->_calculatedValues['harmonicMean'];
+	}/*}}}*/
+
+	/**
+	 * Calculates the nth central moment (m{n}) of a data set.
+	 *
+	 * The definition of a sample central moment is:
+	 *
+	 *     m{n} = 1/N * SUM { (xi - avg)^n }
+	 *
+	 * where: N = sample size, avg = sample mean.
+	 *
+	 * @access public
+	 * @param integer $n moment to calculate
+	 * @return mixed the numeric value of the moment on success, PEAR_Error otherwise
+	 */
+	function sampleCentralMoment($n) {/*{{{*/
+		if (!is_int($n) || $n < 1) {
+			return PEAR::isError('moment must be a positive integer >= 1.');
+		}
+
+		if ($n == 1) {
+			return 0;
+		}
+		$count = $this->count();
+		if (PEAR::isError($count)) {
+			return $count;
+		}
+		if ($count == 0) {
+			return PEAR::raiseError("Cannot calculate {$n}th sample moment, ".
+					'there are zero data entries');
+		}
+		$sum = $this->__sumdiff($n);
+		if (PEAR::isError($sum)) {
+			return $sum;
+		}
+		return ($sum / $count);
+	}/*}}}*/
+
+	/**
+	 * Calculates the nth raw moment (m{n}) of a data set.
+	 *
+	 * The definition of a sample central moment is:
+	 *
+	 *     m{n} = 1/N * SUM { xi^n }
+	 *
+	 * where: N = sample size, avg = sample mean.
+	 *
+	 * @access public
+	 * @param integer $n moment to calculate
+	 * @return mixed the numeric value of the moment on success, PEAR_Error otherwise
+	 */
+	function sampleRawMoment($n) {/*{{{*/
+		if (!is_int($n) || $n < 1) {
+			return PEAR::isError('moment must be a positive integer >= 1.');
+		}
+
+		$count = $this->count();
+		if (PEAR::isError($count)) {
+			return $count;
+		}
+		if ($count == 0) {
+			return PEAR::raiseError("Cannot calculate {$n}th raw moment, ".
+					'there are zero data entries.');
+		}
+		$sum = $this->sumN($n);
+		if (PEAR::isError($sum)) {
+			return $sum;
+		}
+		return ($sum / $count);
+	}/*}}}*/
+
+
+	/**
+	 * Calculates the coefficient of variation of a data set.
+	 * The coefficient of variation measures the spread of a set of data
+	 * as a proportion of its mean. It is often expressed as a percentage.
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @return  mixed   the coefficient of variation on success, a PEAR_Error object otherwise
+	 * @see stDev()
+	 * @see mean()
+	 * @see calc()
+	 */
+	function coeffOfVariation() {/*{{{*/
+		if (!array_key_exists('coeffOfVariation', $this->_calculatedValues)) {
+			$mean = $this->mean();
+			if (PEAR::isError($mean)) {
+				return $mean;
+			}
+			if ($mean == 0.0) {
+				return PEAR::raiseError('cannot calculate the coefficient '.
+						'of variation, mean of sample is zero');
+			}
+			$stDev = $this->stDev();
+			if (PEAR::isError($stDev)) {
+				return $stDev;
+			}
+
+			$this->_calculatedValues['coeffOfVariation'] = $stDev / $mean;
+		}
+		return $this->_calculatedValues['coeffOfVariation'];
+	}/*}}}*/
+
+	/**
+	 * Calculates the standard error of the mean.
+	 * It is the standard deviation of the sampling distribution of
+	 * the mean. The formula is:
+	 *
+	 * S.E. Mean = SD / (N)^(1/2)
+	 *
+	 * This formula does not assume a normal distribution, and shows
+	 * that the size of the standard error of the mean is inversely
+	 * proportional to the square root of the sample size.
+	 *
+	 * @access  public
+	 * @return  mixed   the standard error of the mean on success, a PEAR_Error object otherwise
+	 * @see stDev()
+	 * @see count()
+	 * @see calc()
+	 */
+	function stdErrorOfMean() {/*{{{*/
+		if (!array_key_exists('stdErrorOfMean', $this->_calculatedValues)) {
+			$count = $this->count();
+			if (PEAR::isError($count)) {
+				return $count;
+			}
+			$stDev = $this->stDev();
+			if (PEAR::isError($stDev)) {
+				return $stDev;
+			}
+			$this->_calculatedValues['stdErrorOfMean'] = $stDev / sqrt($count);
+		}
+		return $this->_calculatedValues['stdErrorOfMean'];
+	}/*}}}*/
+
+	/**
+	 * Calculates the value frequency table of a data set.
+	 * Handles cummulative data sets correctly
+	 *
+	 * @access  public
+	 * @return  mixed   an associative array of value=>frequency items on success, a PEAR_Error object otherwise
+	 * @see min()
+	 * @see max()
+	 * @see calc()
+	 */
+	function frequency() {/*{{{*/
+		if ($this->_data == null) {
+			return PEAR::raiseError('data has not been set');
+		}
+		if (!array_key_exists('frequency', $this->_calculatedValues)) {
+			if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
+				$freq = $this->_data;
+			} else {
+				$freq = array();
+				foreach ($this->_data as $val) {
+					$freq["$val"]++;
+				}
+				ksort($freq);
+			}
+			$this->_calculatedValues['frequency'] = $freq;
+		}
+		return $this->_calculatedValues['frequency'];
+	}/*}}}*/
+
+	/**
+	 * The quartiles are defined as the values that divide a sorted
+	 * data set into four equal-sized subsets, and correspond to the
+	 * 25th, 50th, and 75th percentiles.
+	 *
+	 * @access public
+	 * @return mixed an associative array of quartiles on success, a PEAR_Error otherwise
+	 * @see percentile()
+	 */
+	function quartiles() {/*{{{*/
+		if (!array_key_exists('quartiles', $this->_calculatedValues)) {
+			$q1 = $this->percentile(25);
+			if (PEAR::isError($q1)) {
+				return $q1;
+			}
+			$q2 = $this->percentile(50);
+			if (PEAR::isError($q2)) {
+				return $q2;
+			}
+			$q3 = $this->percentile(75);
+			if (PEAR::isError($q3)) {
+				return $q3;
+			}
+			$this->_calculatedValues['quartiles'] = array (
+										'25' => $q1,
+										'50' => $q2,
+										'75' => $q3
+										);
+		}
+		return $this->_calculatedValues['quartiles'];
+	}/*}}}*/
+
+	/**
+	 * The interquartile mean is defined as the mean of the values left
+	 * after discarding the lower 25% and top 25% ranked values, i.e.:
+	 *
+	 *  interquart mean = mean(<P(25),P(75)>)
+	 *
+	 *  where: P = percentile
+	 *
+	 * @todo need to double check the equation
+	 * @access public
+	 * @return mixed a numeric value on success, a PEAR_Error otherwise
+	 * @see quartiles()
+	 */
+	function interquartileMean() {/*{{{*/
+		if (!array_key_exists('interquartileMean', $this->_calculatedValues)) {
+			$quart = $this->quartiles();
+			if (PEAR::isError($quart)) {
+				return $quart;
+			}
+			$q3 = $quart['75'];
+			$q1 = $quart['25'];
+			$sum = 0;
+			$n = 0;
+			foreach ($this->getData(true) as $val) {
+				if ($val >= $q1 && $val <= $q3) {
+					$sum += $val;
+					++$n;
+				}
+			}
+			if ($n == 0) {
+				return PEAR::raiseError('error calculating interquartile mean, '.
+										'empty interquartile range of values.');
+			}
+			$this->_calculatedValues['interquartileMean'] = $sum / $n;
+		}
+		return $this->_calculatedValues['interquartileMean'];
+	}/*}}}*/
+
+	/**
+	 * The interquartile range is the distance between the 75th and 25th
+	 * percentiles. Basically the range of the middle 50% of the data set,
+	 * and thus is not affected by outliers or extreme values.
+	 *
+	 *  interquart range = P(75) - P(25)
+	 *
+	 *  where: P = percentile
+	 *
+	 * @access public
+	 * @return mixed a numeric value on success, a PEAR_Error otherwise
+	 * @see quartiles()
+	 */
+	function interquartileRange() {/*{{{*/
+		if (!array_key_exists('interquartileRange', $this->_calculatedValues)) {
+			$quart = $this->quartiles();
+			if (PEAR::isError($quart)) {
+				return $quart;
+			}
+			$q3 = $quart['75'];
+			$q1 = $quart['25'];
+			$this->_calculatedValues['interquartileRange'] = $q3 - $q1;
+		}
+		return $this->_calculatedValues['interquartileRange'];
+	}/*}}}*/
+
+	/**
+	 * The quartile deviation is half of the interquartile range value
+	 *
+	 *  quart dev = (P(75) - P(25)) / 2
+	 *
+	 *  where: P = percentile
+	 *
+	 * @access public
+	 * @return mixed a numeric value on success, a PEAR_Error otherwise
+	 * @see quartiles()
+	 * @see interquartileRange()
+	 */
+	function quartileDeviation() {/*{{{*/
+		if (!array_key_exists('quartileDeviation', $this->_calculatedValues)) {
+			$iqr = $this->interquartileRange();
+			if (PEAR::isError($iqr)) {
+				return $iqr;
+			}
+			$this->_calculatedValues['quartileDeviation'] = $iqr / 2;
+		}
+		return $this->_calculatedValues['quartileDeviation'];
+	}/*}}}*/
+
+	/**
+	 * The quartile variation coefficient is defines as follows:
+	 *
+	 *  quart var coeff = 100 * (P(75) - P(25)) / (P(75) + P(25))
+	 *
+	 *  where: P = percentile
+	 *
+	 * @todo need to double check the equation
+	 * @access public
+	 * @return mixed a numeric value on success, a PEAR_Error otherwise
+	 * @see quartiles()
+	 */
+	function quartileVariationCoefficient() {/*{{{*/
+		if (!array_key_exists('quartileVariationCoefficient', $this->_calculatedValues)) {
+			$quart = $this->quartiles();
+			if (PEAR::isError($quart)) {
+				return $quart;
+			}
+			$q3 = $quart['75'];
+			$q1 = $quart['25'];
+			$d = $q3 - $q1;
+			$s = $q3 + $q1;
+			$this->_calculatedValues['quartileVariationCoefficient'] = 100 * $d / $s;
+		}
+		return $this->_calculatedValues['quartileVariationCoefficient'];
+	}/*}}}*/
+
+	/**
+	 * The quartile skewness coefficient (also known as Bowley Skewness),
+	 * is defined as follows:
+	 *
+	 *  quart skewness coeff = (P(25) - 2*P(50) + P(75)) / (P(75) - P(25))
+	 *
+	 *  where: P = percentile
+	 *
+	 * @todo need to double check the equation
+	 * @access public
+	 * @return mixed a numeric value on success, a PEAR_Error otherwise
+	 * @see quartiles()
+	 */
+	function quartileSkewnessCoefficient() {/*{{{*/
+		if (!array_key_exists('quartileSkewnessCoefficient', $this->_calculatedValues)) {
+			$quart = $this->quartiles();
+			if (PEAR::isError($quart)) {
+				return $quart;
+			}
+			$q3 = $quart['75'];
+			$q2 = $quart['50'];
+			$q1 = $quart['25'];
+			$d = $q3 - 2*$q2 + $q1;
+			$s = $q3 - $q1;
+			$this->_calculatedValues['quartileSkewnessCoefficient'] = $d / $s;
+		}
+		return $this->_calculatedValues['quartileSkewnessCoefficient'];
+	}/*}}}*/
+
+	/**
+	 * The pth percentile is the value such that p% of the a sorted data set
+	 * is smaller than it, and (100 - p)% of the data is larger.
+	 *
+	 * A quick algorithm to pick the appropriate value from a sorted data
+	 * set is as follows:
+	 *
+	 * - Count the number of values: n
+	 * - Calculate the position of the value in the data list: i = p * (n + 1)
+	 * - if i is an integer, return the data at that position
+	 * - if i < 1, return the minimum of the data set
+	 * - if i > n, return the maximum of the data set
+	 * - otherwise, average the entries at adjacent positions to i
+	 *
+	 * The median is the 50th percentile value.
+	 *
+	 * @todo need to double check generality of the algorithm
+	 *
+	 * @access public
+	 * @param numeric $p the percentile to estimate, e.g. 25 for 25th percentile
+	 * @return mixed a numeric value on success, a PEAR_Error otherwise
+	 * @see quartiles()
+	 * @see median()
+	 */
+	function percentile($p) {/*{{{*/
+		$count = $this->count();
+		if (PEAR::isError($count)) {
+			return $count;
+		}
+		if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
+			$data =& $this->_dataExpanded;
+		} else {
+			$data =& $this->_data;
+		}
+		$obsidx = $p * ($count + 1) / 100;
+		if (intval($obsidx) == $obsidx) {
+			return $data[($obsidx - 1)];
+		} elseif ($obsidx < 1) {
+			return $data[0];
+		} elseif ($obsidx > $count) {
+			return $data[($count - 1)];
+		} else {
+			$left = floor($obsidx - 1);
+			$right = ceil($obsidx - 1);
+			return ($data[$left] + $data[$right]) / 2;
+		}
+	}/*}}}*/
+
+	// private methods
+
+	/**
+	 * Utility function to calculate: SUM { (xi - mean)^n }
+	 *
+	 * @access private
+	 * @param   numeric $power  the exponent
+	 * @param   optional    double   $mean   the data set mean value
+	 * @return  mixed   the sum on success, a PEAR_Error object otherwise
+	 *
+	 * @see stDev()
+	 * @see variaceWithMean();
+	 * @see skewness();
+	 * @see kurtosis();
+	 */
+	function __sumdiff($power, $mean=null) {/*{{{*/
+		if ($this->_data == null) {
+			return PEAR::raiseError('data has not been set');
+		}
+		if (is_null($mean)) {
+			$mean = $this->mean();
+			if (PEAR::isError($mean)) {
+				return $mean;
+			}
+		}
+		$sdiff = 0;
+		if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
+			foreach ($this->_data as $val=>$freq) {
+				$sdiff += $freq * pow((double)($val - $mean), (double)$power);
+			}
+		} else {
+			foreach ($this->_data as $val)
+				$sdiff += pow((double)($val - $mean), (double)$power);
+		}
+		return $sdiff;
+	}/*}}}*/
+
+	/**
+	 * Utility function to calculate the variance with or without
+	 * a fixed mean
+	 *
+	 * @access private
+	 * @param $mean the fixed mean to use, null as default
+	 * @return mixed a numeric value on success, a PEAR_Error otherwise
+	 * @see variance()
+	 * @see varianceWithMean()
+	 */
+	function __calcVariance($mean = null) {/*{{{*/
+		if ($this->_data == null) {
+			return PEAR::raiseError('data has not been set');
+		}
+		$sumdiff2 = $this->__sumdiff(2, $mean);
+		if (PEAR::isError($sumdiff2)) {
+			return $sumdiff2;
+		}
+		$count = $this->count();
+		if (PEAR::isError($count)) {
+			return $count;
+		}
+		if ($count == 1) {
+			return PEAR::raiseError('cannot calculate variance of a singe data point');
+		}
+		return  ($sumdiff2 / ($count - 1));
+	}/*}}}*/
+
+	/**
+	 * Utility function to calculate the absolute deviation with or without
+	 * a fixed mean
+	 *
+	 * @access private
+	 * @param $mean the fixed mean to use, null as default
+	 * @return mixed a numeric value on success, a PEAR_Error otherwise
+	 * @see absDev()
+	 * @see absDevWithMean()
+	 */
+	function __calcAbsoluteDeviation($mean = null) {/*{{{*/
+		if ($this->_data == null) {
+			return PEAR::raiseError('data has not been set');
+		}
+		$count = $this->count();
+		if (PEAR::isError($count)) {
+			return $count;
+		}
+		$sumabsdev = $this->__sumabsdev($mean);
+		if (PEAR::isError($sumabsdev)) {
+			return $sumabsdev;
+		}
+		return $sumabsdev / $count;
+	}/*}}}*/
+
+	/**
+	 * Utility function to calculate: SUM { | xi - mean | }
+	 *
+	 * @access  private
+	 * @param   optional    double   $mean   the mean value for the set or population
+	 * @return  mixed   the sum on success, a PEAR_Error object otherwise
+	 *
+	 * @see absDev()
+	 * @see absDevWithMean()
+	 */
+	function __sumabsdev($mean=null) {/*{{{*/
+		if ($this->_data == null) {
+			return PEAR::raiseError('data has not been set');
+		}
+		if (is_null($mean)) {
+			$mean = $this->mean();
+		}
+		$sdev = 0;
+		if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
+			foreach ($this->_data as $val=>$freq) {
+				$sdev += $freq * abs($val - $mean);
+			}
+		} else {
+			foreach ($this->_data as $val) {
+				$sdev += abs($val - $mean);
+			}
+		}
+		return $sdev;
+	}/*}}}*/
+
+	/**
+	 * Utility function to format a PEAR_Error to be used by calc(),
+	 * calcBasic() and calcFull()
+	 *
+	 * @access private
+	 * @param mixed $v value to be formatted
+	 * @param boolean $returnErrorObject whether the raw PEAR_Error (when true, default),
+	 *                  or only the error message will be returned (when false)
+	 * @return mixed if the value is a PEAR_Error object, and $useErrorObject
+	 *              is false, then a string with the error message will be returned,
+	 *              otherwise the value will not be modified and returned as passed.
+	 */
+	function __format($v, $useErrorObject=true) {/*{{{*/
+		if (PEAR::isError($v) && $useErrorObject == false) {
+			return $v->getMessage();
+		} else {
+			return $v;
+		}
+	}/*}}}*/
+
+	/**
+	 * Utility function to validate the data and modify it
+	 * according to the current null handling option
+	 *
+	 * @access  private
+	 * @return  mixed true on success, a PEAR_Error object otherwise
+	 *
+	 * @see setData()
+	 */
+	function _validate() {/*{{{*/
+		$flag = ($this->_dataOption == STATS_DATA_CUMMULATIVE);
+		foreach ($this->_data as $key=>$value) {
+			$d = ($flag) ? $key : $value;
+			$v = ($flag) ? $value : $key;
+			if (!is_numeric($d)) {
+				switch ($this->_nullOption) {
+					case STATS_IGNORE_NULL :
+						unset($this->_data["$key"]);
+						break;
+					case STATS_USE_NULL_AS_ZERO:
+						if ($flag) {
+							unset($this->_data["$key"]);
+							$this->_data[0] += $v;
+						} else {
+							$this->_data[$key] = 0;
+						}
+						break;
+					case STATS_REJECT_NULL :
+					default:
+						return PEAR::raiseError('data rejected, contains NULL values');
+						break;
+				}
+			}
+		}
+		if ($flag) {
+			ksort($this->_data);
+			$this->_dataExpanded = array();
+			foreach ($this->_data as $val=>$freq) {
+				$this->_dataExpanded = array_pad($this->_dataExpanded, count($this->_dataExpanded) + $freq, $val);
+			}
+			sort($this->_dataExpanded);
+		} else {
+			sort($this->_data);
+		}
+		return true;
+	}/*}}}*/
 
 }/*}}}*/
 

Spacing +65 added lines, -65 removed lines

@@ -173,7 +173,7 @@ 
      * @param   optional    int $nullOption how to handle null values
      * @return  object  Math_Stats
      */
-    function Math_Stats($nullOption=STATS_REJECT_NULL) {/*{{{*/
+    function Math_Stats($nullOption = STATS_REJECT_NULL) {/*{{{*/
         $this->_nullOption = $nullOption;
     }/*}}}*/
 
@@ -186,8 +186,8 @@ 
      * @param   optional    int $opt    data format: STATS_DATA_CUMMULATIVE or STATS_DATA_SIMPLE (default)
      * @return  mixed   true on success, a PEAR_Error object otherwise
      */
-    function setData($arr, $opt=STATS_DATA_SIMPLE) {/*{{{*/
-        if (!is_array($arr)) {
+    function setData($arr, $opt = STATS_DATA_SIMPLE) {/*{{{*/
+        if ( ! is_array($arr)) {
             return PEAR::raiseError('invalid data, an array of numeric data was expected');
         }
         $this->_data = null;
@@ -214,7 +214,7 @@ 
      * @return  mixed   array of data on success, a PEAR_Error object otherwise
      * @see _validate()
      */
-    function getData($expanded=false) {/*{{{*/
+    function getData($expanded = false) {/*{{{*/
         if ($this->_data == null) {
             return PEAR::raiseError('data has not been set');
         }
@@ -268,7 +268,7 @@ 
         if ($std == 0) {
             return PEAR::raiseError('cannot studentize data, standard deviation is zero.');
         }
-        $arr  = array();
+        $arr = array();
         if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
             foreach ($this->_data as $val=>$freq) {
                 $newval = ($val - $mean) / $std;
@@ -297,7 +297,7 @@ 
         if (PEAR::isError($mean)) {
             return $mean;
         }
-        $arr  = array();
+        $arr = array();
         if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
             foreach ($this->_data as $val=>$freq) {
                 $newval = $val - $mean;
@@ -323,7 +323,7 @@ 
      * @see calcBasic()
      * @see calcFull()
      */
-    function calc($mode, $returnErrorObject=true) {/*{{{*/
+    function calc($mode, $returnErrorObject = true) {/*{{{*/
         if ($this->_data == null) {
             return PEAR::raiseError('data has not been set');
         }
@@ -346,8 +346,8 @@ 
      * @see calc()
      * @see calcFull()
      */
-    function calcBasic($returnErrorObject=true) {/*{{{*/
-            return array (
+    function calcBasic($returnErrorObject = true) {/*{{{*/
+            return array(
                 'min' => $this->__format($this->min(), $returnErrorObject),
                 'max' => $this->__format($this->max(), $returnErrorObject),
                 'sum' => $this->__format($this->sum(), $returnErrorObject),
@@ -370,8 +370,8 @@ 
      * @see calc()
      * @see calcBasic()
      */
-    function calcFull($returnErrorObject=true) {/*{{{*/
-            return array (
+    function calcFull($returnErrorObject = true) {/*{{{*/
+            return array(
                 'min' => $this->__format($this->min(), $returnErrorObject),
                 'max' => $this->__format($this->max(), $returnErrorObject),
                 'sum' => $this->__format($this->sum(), $returnErrorObject),
@@ -391,14 +391,14 @@ 
                 'skewness' => $this->__format($this->skewness(), $returnErrorObject),
                 'kurtosis' => $this->__format($this->kurtosis(), $returnErrorObject),
                 'coeff_of_variation' => $this->__format($this->coeffOfVariation(), $returnErrorObject),
-                'sample_central_moments' => array (
+                'sample_central_moments' => array(
                             1 => $this->__format($this->sampleCentralMoment(1), $returnErrorObject),
                             2 => $this->__format($this->sampleCentralMoment(2), $returnErrorObject),
                             3 => $this->__format($this->sampleCentralMoment(3), $returnErrorObject),
                             4 => $this->__format($this->sampleCentralMoment(4), $returnErrorObject),
                             5 => $this->__format($this->sampleCentralMoment(5), $returnErrorObject)
                             ),
-                'sample_raw_moments' => array (
+                'sample_raw_moments' => array(
                             1 => $this->__format($this->sampleRawMoment(1), $returnErrorObject),
                             2 => $this->__format($this->sampleRawMoment(2), $returnErrorObject),
                             3 => $this->__format($this->sampleRawMoment(3), $returnErrorObject),
@@ -428,7 +428,7 @@ 
         if ($this->_data == null) {
             return PEAR::raiseError('data has not been set');
         }
-        if (!array_key_exists('min', $this->_calculatedValues)) {
+        if ( ! array_key_exists('min', $this->_calculatedValues)) {
             if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
                 $min = min(array_keys($this->_data));
             } else {
@@ -452,7 +452,7 @@ 
         if ($this->_data == null) {
             return PEAR::raiseError('data has not been set');
         }
-        if (!array_key_exists('max', $this->_calculatedValues)) {
+        if ( ! array_key_exists('max', $this->_calculatedValues)) {
             if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
                 $max = max(array_keys($this->_data));
             } else {
@@ -474,7 +474,7 @@ 
      * @see sumN()
      */
     function sum() {/*{{{*/
-        if (!array_key_exists('sum', $this->_calculatedValues)) {
+        if ( ! array_key_exists('sum', $this->_calculatedValues)) {
             $sum = $this->sumN(1);
             if (PEAR::isError($sum)) {
                 return $sum;
@@ -496,7 +496,7 @@ 
      * @see sumN()
      */
     function sum2() {/*{{{*/
-        if (!array_key_exists('sum2', $this->_calculatedValues)) {
+        if ( ! array_key_exists('sum2', $this->_calculatedValues)) {
             $sum2 = $this->sumN(2);
             if (PEAR::isError($sum2)) {
                 return $sum2;
@@ -524,12 +524,12 @@ 
         }
         $sumN = 0;
         if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-            foreach($this->_data as $val=>$freq) {
-                $sumN += $freq * pow((double)$val, (double)$n);
+            foreach ($this->_data as $val=>$freq) {
+                $sumN += $freq * pow((double) $val, (double) $n);
             }
         } else {
-            foreach($this->_data as $val) {
-                $sumN += pow((double)$val, (double)$n);
+            foreach ($this->_data as $val) {
+                $sumN += pow((double) $val, (double) $n);
             }
         }
         return $sumN;
@@ -544,7 +544,7 @@ 
      * @see productN()
      */
     function product() {/*{{{*/
-        if (!array_key_exists('product', $this->_calculatedValues)) {
+        if ( ! array_key_exists('product', $this->_calculatedValues)) {
             $product = $this->productN(1);
             if (PEAR::isError($product)) {
                 return $product;
@@ -570,18 +570,18 @@ 
         }
         $prodN = 1.0;
         if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-            foreach($this->_data as $val=>$freq) {
+            foreach ($this->_data as $val=>$freq) {
                 if ($val == 0) {
                     return 0.0;
                 }
-                $prodN *= $freq * pow((double)$val, (double)$n);
+                $prodN *= $freq * pow((double) $val, (double) $n);
             }
         } else {
-            foreach($this->_data as $val) {
+            foreach ($this->_data as $val) {
                 if ($val == 0) {
                     return 0.0;
                 }
-                $prodN *= pow((double)$val, (double)$n);
+                $prodN *= pow((double) $val, (double) $n);
             }
         }
         return $prodN;
@@ -600,7 +600,7 @@ 
         if ($this->_data == null) {
             return PEAR::raiseError('data has not been set');
         }
-        if (!array_key_exists('count', $this->_calculatedValues)) {
+        if ( ! array_key_exists('count', $this->_calculatedValues)) {
             if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
                 $count = count($this->_dataExpanded);
             } else {
@@ -622,7 +622,7 @@ 
      * @see count()
      */
     function mean() {/*{{{*/
-        if (!array_key_exists('mean', $this->_calculatedValues)) {
+        if ( ! array_key_exists('mean', $this->_calculatedValues)) {
             $sum = $this->sum();
             if (PEAR::isError($sum)) {
                 return $sum;
@@ -643,7 +643,7 @@ 
      * @return mixed the value of the range on success, a PEAR_Error object otherwise.
      */
     function range() {/*{{{*/
-        if (!array_key_exists('range', $this->_calculatedValues)) {
+        if ( ! array_key_exists('range', $this->_calculatedValues)) {
             $min = $this->min();
             if (PEAR::isError($min)) {
                 return $min;
@@ -669,7 +669,7 @@ 
      * @see count()
      */
     function variance() {/*{{{*/
-        if (!array_key_exists('variance', $this->_calculatedValues)) {
+        if ( ! array_key_exists('variance', $this->_calculatedValues)) {
             $variance = $this->__calcVariance();
             if (PEAR::isError($variance)) {
                 return $variance;
@@ -689,7 +689,7 @@ 
      * @see variance()
      */
     function stDev() {/*{{{*/
-        if (!array_key_exists('stDev', $this->_calculatedValues)) {
+        if ( ! array_key_exists('stDev', $this->_calculatedValues)) {
             $variance = $this->variance();
             if (PEAR::isError($variance)) {
                 return $variance;
@@ -748,7 +748,7 @@ 
      * @see absDevWithMean()
      */
     function absDev() {/*{{{*/
-        if (!array_key_exists('absDev', $this->_calculatedValues)) {
+        if ( ! array_key_exists('absDev', $this->_calculatedValues)) {
             $absDev = $this->__calcAbsoluteDeviation();
             if (PEAR::isError($absdev)) {
                 return $absdev;
@@ -793,7 +793,7 @@ 
      * @see calc()
      */
     function skewness() {/*{{{*/
-        if (!array_key_exists('skewness', $this->_calculatedValues)) {
+        if ( ! array_key_exists('skewness', $this->_calculatedValues)) {
             $count = $this->count();
             if (PEAR::isError($count)) {
                 return $count;
@@ -830,7 +830,7 @@ 
      * @see calc()
      */
     function kurtosis() {/*{{{*/
-        if (!array_key_exists('kurtosis', $this->_calculatedValues)) {
+        if ( ! array_key_exists('kurtosis', $this->_calculatedValues)) {
             $count = $this->count();
             if (PEAR::isError($count)) {
                 return $count;
@@ -865,11 +865,11 @@ 
         if ($this->_data == null) {
             return PEAR::raiseError('data has not been set');
         }
-        if (!array_key_exists('median', $this->_calculatedValues)) {
+        if ( ! array_key_exists('median', $this->_calculatedValues)) {
             if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-                $arr =& $this->_dataExpanded;
+                $arr = & $this->_dataExpanded;
             } else {
-                $arr =& $this->_data;
+                $arr = & $this->_data;
             }
             $n = $this->count();
             if (PEAR::isError($n)) {
@@ -901,7 +901,7 @@ 
         if ($this->_data == null) {
             return PEAR::raiseError('data has not been set');
         }
-        if (!array_key_exists('mode', $this->_calculatedValues)) {
+        if ( ! array_key_exists('mode', $this->_calculatedValues)) {
             if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
                 $arr = $this->_data;
             } else {
@@ -938,7 +938,7 @@ 
      * @see calc()
      */
     function midrange() {/*{{{*/
-        if (!array_key_exists('midrange', $this->_calculatedValues)) {
+        if ( ! array_key_exists('midrange', $this->_calculatedValues)) {
             $min = $this->min();
             if (PEAR::isError($min)) {
                 return $min;
@@ -963,7 +963,7 @@ 
      * @see count()
      */
     function geometricMean() {/*{{{*/
-        if (!array_key_exists('geometricMean', $this->_calculatedValues)) {
+        if ( ! array_key_exists('geometricMean', $this->_calculatedValues)) {
             $count = $this->count();
             if (PEAR::isError($count)) {
                 return $count;
@@ -978,7 +978,7 @@ 
             if ($prod < 0) {
                 return PEAR::raiseError('The product of the data set is negative, geometric mean undefined.');
             }
-            $this->_calculatedValues['geometricMean'] = pow($prod , 1 / $count);
+            $this->_calculatedValues['geometricMean'] = pow($prod, 1 / $count);
         }
         return $this->_calculatedValues['geometricMean'];
     }/*}}}*/
@@ -996,14 +996,14 @@ 
         if ($this->_data == null) {
             return PEAR::raiseError('data has not been set');
         }
-        if (!array_key_exists('harmonicMean', $this->_calculatedValues)) {
+        if ( ! array_key_exists('harmonicMean', $this->_calculatedValues)) {
             $count = $this->count();
             if (PEAR::isError($count)) {
                 return $count;
             }
             $invsum = 0.0;
             if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-                foreach($this->_data as $val=>$freq) {
+                foreach ($this->_data as $val=>$freq) {
                     if ($val == 0) {
                         return PEAR::raiseError('cannot calculate a '.
                                 'harmonic mean with data values of zero.');
@@ -1011,7 +1011,7 @@ 
                     $invsum += $freq / $val;
                 }
             } else {
-                foreach($this->_data as $val) {
+                foreach ($this->_data as $val) {
                     if ($val == 0) {
                         return PEAR::raiseError('cannot calculate a '.
                                 'harmonic mean with data values of zero.');
@@ -1038,7 +1038,7 @@ 
      * @return mixed the numeric value of the moment on success, PEAR_Error otherwise
      */
     function sampleCentralMoment($n) {/*{{{*/
-        if (!is_int($n) || $n < 1) {
+        if ( ! is_int($n) || $n < 1) {
             return PEAR::isError('moment must be a positive integer >= 1.');
         }
 
@@ -1074,7 +1074,7 @@ 
      * @return mixed the numeric value of the moment on success, PEAR_Error otherwise
      */
     function sampleRawMoment($n) {/*{{{*/
-        if (!is_int($n) || $n < 1) {
+        if ( ! is_int($n) || $n < 1) {
             return PEAR::isError('moment must be a positive integer >= 1.');
         }
 
@@ -1107,7 +1107,7 @@ 
      * @see calc()
      */
     function coeffOfVariation() {/*{{{*/
-        if (!array_key_exists('coeffOfVariation', $this->_calculatedValues)) {
+        if ( ! array_key_exists('coeffOfVariation', $this->_calculatedValues)) {
             $mean = $this->mean();
             if (PEAR::isError($mean)) {
                 return $mean;
@@ -1144,7 +1144,7 @@ 
      * @see calc()
      */
     function stdErrorOfMean() {/*{{{*/
-        if (!array_key_exists('stdErrorOfMean', $this->_calculatedValues)) {
+        if ( ! array_key_exists('stdErrorOfMean', $this->_calculatedValues)) {
             $count = $this->count();
             if (PEAR::isError($count)) {
                 return $count;
@@ -1172,7 +1172,7 @@ 
         if ($this->_data == null) {
             return PEAR::raiseError('data has not been set');
         }
-        if (!array_key_exists('frequency', $this->_calculatedValues)) {
+        if ( ! array_key_exists('frequency', $this->_calculatedValues)) {
             if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
                 $freq = $this->_data;
             } else {
@@ -1197,7 +1197,7 @@ 
      * @see percentile()
      */
     function quartiles() {/*{{{*/
-        if (!array_key_exists('quartiles', $this->_calculatedValues)) {
+        if ( ! array_key_exists('quartiles', $this->_calculatedValues)) {
             $q1 = $this->percentile(25);
             if (PEAR::isError($q1)) {
                 return $q1;
@@ -1210,7 +1210,7 @@ 
             if (PEAR::isError($q3)) {
                 return $q3;
             }
-            $this->_calculatedValues['quartiles'] = array (
+            $this->_calculatedValues['quartiles'] = array(
                                         '25' => $q1,
                                         '50' => $q2,
                                         '75' => $q3
@@ -1233,7 +1233,7 @@ 
      * @see quartiles()
      */
     function interquartileMean() {/*{{{*/
-        if (!array_key_exists('interquartileMean', $this->_calculatedValues)) {
+        if ( ! array_key_exists('interquartileMean', $this->_calculatedValues)) {
             $quart = $this->quartiles();
             if (PEAR::isError($quart)) {
                 return $quart;
@@ -1271,7 +1271,7 @@ 
      * @see quartiles()
      */
     function interquartileRange() {/*{{{*/
-        if (!array_key_exists('interquartileRange', $this->_calculatedValues)) {
+        if ( ! array_key_exists('interquartileRange', $this->_calculatedValues)) {
             $quart = $this->quartiles();
             if (PEAR::isError($quart)) {
                 return $quart;
@@ -1296,7 +1296,7 @@ 
      * @see interquartileRange()
      */
     function quartileDeviation() {/*{{{*/
-        if (!array_key_exists('quartileDeviation', $this->_calculatedValues)) {
+        if ( ! array_key_exists('quartileDeviation', $this->_calculatedValues)) {
             $iqr = $this->interquartileRange();
             if (PEAR::isError($iqr)) {
                 return $iqr;
@@ -1319,7 +1319,7 @@ 
      * @see quartiles()
      */
     function quartileVariationCoefficient() {/*{{{*/
-        if (!array_key_exists('quartileVariationCoefficient', $this->_calculatedValues)) {
+        if ( ! array_key_exists('quartileVariationCoefficient', $this->_calculatedValues)) {
             $quart = $this->quartiles();
             if (PEAR::isError($quart)) {
                 return $quart;
@@ -1347,7 +1347,7 @@ 
      * @see quartiles()
      */
     function quartileSkewnessCoefficient() {/*{{{*/
-        if (!array_key_exists('quartileSkewnessCoefficient', $this->_calculatedValues)) {
+        if ( ! array_key_exists('quartileSkewnessCoefficient', $this->_calculatedValues)) {
             $quart = $this->quartiles();
             if (PEAR::isError($quart)) {
                 return $quart;
@@ -1355,7 +1355,7 @@ 
             $q3 = $quart['75'];
             $q2 = $quart['50'];
             $q1 = $quart['25'];
-            $d = $q3 - 2*$q2 + $q1;
+            $d = $q3 - 2 * $q2 + $q1;
             $s = $q3 - $q1;
             $this->_calculatedValues['quartileSkewnessCoefficient'] = $d / $s;
         }
@@ -1392,9 +1392,9 @@ 
             return $count;
         }
         if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
-            $data =& $this->_dataExpanded;
+            $data = & $this->_dataExpanded;
         } else {
-            $data =& $this->_data;
+            $data = & $this->_data;
         }
         $obsidx = $p * ($count + 1) / 100;
         if (intval($obsidx) == $obsidx) {
@@ -1425,7 +1425,7 @@ 
      * @see skewness();
      * @see kurtosis();
      */
-    function __sumdiff($power, $mean=null) {/*{{{*/
+    function __sumdiff($power, $mean = null) {/*{{{*/
         if ($this->_data == null) {
             return PEAR::raiseError('data has not been set');
         }
@@ -1438,11 +1438,11 @@ 
         $sdiff = 0;
         if ($this->_dataOption == STATS_DATA_CUMMULATIVE) {
             foreach ($this->_data as $val=>$freq) {
-                $sdiff += $freq * pow((double)($val - $mean), (double)$power);
+                $sdiff += $freq * pow((double) ($val - $mean), (double) $power);
             }
         } else {
             foreach ($this->_data as $val)
-                $sdiff += pow((double)($val - $mean), (double)$power);
+                $sdiff += pow((double) ($val - $mean), (double) $power);
         }
         return $sdiff;
     }/*}}}*/
@@ -1510,7 +1510,7 @@ 
      * @see absDev()
      * @see absDevWithMean()
      */
-    function __sumabsdev($mean=null) {/*{{{*/
+    function __sumabsdev($mean = null) {/*{{{*/
         if ($this->_data == null) {
             return PEAR::raiseError('data has not been set');
         }
@@ -1542,7 +1542,7 @@ 
      *              is false, then a string with the error message will be returned,
      *              otherwise the value will not be modified and returned as passed.
      */
-    function __format($v, $useErrorObject=true) {/*{{{*/
+    function __format($v, $useErrorObject = true) {/*{{{*/
         if (PEAR::isError($v) && $useErrorObject == false) {
             return $v->getMessage();
         } else {
@@ -1564,7 +1564,7 @@ 
         foreach ($this->_data as $key=>$value) {
             $d = ($flag) ? $key : $value;
             $v = ($flag) ? $value : $key;
-            if (!is_numeric($d)) {
+            if ( ! is_numeric($d)) {
                 switch ($this->_nullOption) {
                     case STATS_IGNORE_NULL :
                         unset($this->_data["$key"]);

Braces +9 added lines, -6 removed lines

@@ -916,10 +916,12 @@ 
                     ++$mcount;
                     continue;
                 }
-                if ($mfreq == $freq)
-                    $mode[] = $val;
-                if ($mfreq > $freq)
-                    break;
+                if ($mfreq == $freq) {
+                                    $mode[] = $val;
+                }
+                if ($mfreq > $freq) {
+                                    break;
+                }
             }
             $this->_calculatedValues['mode'] = $mode;
         }
@@ -1441,8 +1443,9 @@ 
                 $sdiff += $freq * pow((double)($val - $mean), (double)$power);
             }
         } else {
-            foreach ($this->_data as $val)
-                $sdiff += pow((double)($val - $mean), (double)$power);
+            foreach ($this->_data as $val) {
+                            $sdiff += pow((double)($val - $mean), (double)$power);
+            }
         }
         return $sdiff;
     }/*}}}*/

app/Vendor/PHPExcel/PHPExcel/Shared/JAMA/LUDecomposition.php

Doc Comments +4 added lines, -4 removed lines

@@ -57,7 +57,7 @@ 
 	/**
 	 *	LU Decomposition constructor.
 	 *
-	 *	@param $A Rectangular matrix
+	 *	@param PHPExcel_Shared_JAMA_Matrix $A Rectangular matrix
 	 *	@return Structure to access L, U and piv.
 	 */
 	public function __construct($A) {
@@ -123,7 +123,7 @@ 
 	/**
 	 *	Get lower triangular factor.
 	 *
-	 *	@return array Lower triangular factor
+	 *	@return PHPExcel_Shared_JAMA_Matrix Lower triangular factor
 	 */
 	public function getL() {
 		for ($i = 0; $i < $this->m; ++$i) {
@@ -144,7 +144,7 @@ 
 	/**
 	 *	Get upper triangular factor.
 	 *
-	 *	@return array Upper triangular factor
+	 *	@return PHPExcel_Shared_JAMA_Matrix Upper triangular factor
 	 */
 	public function getU() {
 		for ($i = 0; $i < $this->n; ++$i) {
@@ -183,7 +183,7 @@ 
 	/**
 	 *	Is the matrix nonsingular?
 	 *
-	 *	@return true if U, and hence A, is nonsingular.
+	 *	@return boolean if U, and hence A, is nonsingular.
 	 */
 	public function isNonsingular() {
 		for ($j = 0; $j < $this->n; ++$j) {

Spacing +8 added lines, -8 removed lines

@@ -20,8 +20,8 @@ 
  */
 class PHPExcel_Shared_JAMA_LUDecomposition {
 
-	const MatrixSingularException	= "Can only perform operation on singular matrix.";
-	const MatrixSquareException		= "Mismatched Row dimension";
+	const MatrixSingularException = "Can only perform operation on singular matrix.";
+	const MatrixSquareException = "Mismatched Row dimension";
 
 	/**
 	 *	Decomposition storage
@@ -82,7 +82,7 @@ 
 				for ($i = 0; $i < $this->m; ++$i) {
 					$LUrowi = $this->LU[$i];
 					// Most of the time is spent in the following dot product.
-					$kmax = min($i,$j);
+					$kmax = min($i, $j);
 					$s = 0.0;
 					for ($k = 0; $k < $kmax; ++$k) {
 						$s += $LUrowi[$k] * $LUcolj[$k];
@@ -91,7 +91,7 @@ 
 				}
 				// Find pivot and exchange if necessary.
 				$p = $j;
-				for ($i = $j+1; $i < $this->m; ++$i) {
+				for ($i = $j + 1; $i < $this->m; ++$i) {
 					if (abs($LUcolj[$i]) > abs($LUcolj[$p])) {
 						$p = $i;
 					}
@@ -109,7 +109,7 @@ 
 				}
 				// Compute multipliers.
 				if (($j < $this->m) && ($this->LU[$j][$j] != 0.0)) {
-					for ($i = $j+1; $i < $this->m; ++$i) {
+					for ($i = $j + 1; $i < $this->m; ++$i) {
 						$this->LU[$i][$j] /= $this->LU[$j][$j];
 					}
 				}
@@ -226,17 +226,17 @@ 
 			if ($this->isNonsingular()) {
 				// Copy right hand side with pivoting
 				$nx = $B->getColumnDimension();
-				$X  = $B->getMatrix($this->piv, 0, $nx-1);
+				$X  = $B->getMatrix($this->piv, 0, $nx - 1);
 				// Solve L*Y = B(piv,:)
 				for ($k = 0; $k < $this->n; ++$k) {
-					for ($i = $k+1; $i < $this->n; ++$i) {
+					for ($i = $k + 1; $i < $this->n; ++$i) {
 						for ($j = 0; $j < $nx; ++$j) {
 							$X->A[$i][$j] -= $X->A[$k][$j] * $this->LU[$i][$k];
 						}
 					}
 				}
 				// Solve U*X = Y;
-				for ($k = $this->n-1; $k >= 0; --$k) {
+				for ($k = $this->n - 1; $k >= 0; --$k) {
 					for ($j = 0; $j < $nx; ++$j) {
 						$X->A[$k][$j] /= $this->LU[$k][$k];
 					}

app/Vendor/PHPExcel/PHPExcel/Shared/JAMA/Matrix.php

Doc Comments +21 added lines, -41 removed lines

@@ -162,11 +162,7 @@ 
 	 *	getMatrix
 	 *
 	 *	Get a submatrix
-	 *	@param int $i0 Initial row index
-	 *	@param int $iF Final row index
-	 *	@param int $j0 Initial column index
-	 *	@param int $jF Final column index
-	 *	@return Matrix Submatrix
+	 * @return PHPExcel_Shared_JAMA_Matrix|null
 	 */
 	public function getMatrix() {
 		if (func_num_args() > 0) {
@@ -304,7 +300,7 @@ 
 	 *	Generate an identity matrix.
 	 *	@param int $m Row dimension
 	 *	@param int $n Column dimension
-	 *	@return Matrix Identity matrix
+	 *	@return PHPExcel_Shared_JAMA_Matrix Identity matrix
 	 */
 	public function identity($m = null, $n = null) {
 		return $this->diagonal($m, $n, 1);
@@ -317,8 +313,8 @@ 
 	 *	Generate a diagonal matrix
 	 *	@param int $m Row dimension
 	 *	@param int $n Column dimension
-	 *	@param mixed $c Diagonal value
-	 *	@return Matrix Diagonal matrix
+	 *	@param integer $c Diagonal value
+	 *	@return PHPExcel_Shared_JAMA_Matrix Diagonal matrix
 	 */
 	public function diagonal($m = null, $n = null, $c = 1) {
 		$R = new PHPExcel_Shared_JAMA_Matrix($m, $n);
@@ -335,7 +331,7 @@ 
 	 *	Get a submatrix by row index/range
 	 *	@param int $i0 Initial row index
 	 *	@param int $iF Final row index
-	 *	@return Matrix Submatrix
+	 *	@return PHPExcel_Shared_JAMA_Matrix|null Submatrix
 	 */
 	public function getMatrixByRow($i0 = null, $iF = null) {
 		if (is_int($i0)) {
@@ -354,9 +350,7 @@ 
 	 *	getMatrixByCol
 	 *
 	 *	Get a submatrix by column index/range
-	 *	@param int $i0 Initial column index
-	 *	@param int $iF Final column index
-	 *	@return Matrix Submatrix
+	 * @return PHPExcel_Shared_JAMA_Matrix|null
 	 */
 	public function getMatrixByCol($j0 = null, $jF = null) {
 		if (is_int($j0)) {
@@ -375,7 +369,7 @@ 
 	 *	transpose
 	 *
 	 *	Tranpose matrix
-	 *	@return Matrix Transposed matrix
+	 *	@return PHPExcel_Shared_JAMA_Matrix Transposed matrix
 	 */
 	public function transpose() {
 		$R = new PHPExcel_Shared_JAMA_Matrix($this->n, $this->m);
@@ -392,7 +386,7 @@ 
 	 *	trace
 	 *
 	 *	Sum of diagonal elements
-	 *	@return float Sum of diagonal elements
+	 *	@return integer Sum of diagonal elements
 	 */
 	public function trace() {
 		$s = 0;
@@ -418,8 +412,7 @@ 
 	 *	plus
 	 *
 	 *	A + B
-	 *	@param mixed $B Matrix/Array
-	 *	@return Matrix Sum
+	 * @return PHPExcel_Shared_JAMA_Matrix
 	 */
 	public function plus() {
 		if (func_num_args() > 0) {
@@ -454,8 +447,7 @@ 
 	 *	plusEquals
 	 *
 	 *	A = A + B
-	 *	@param mixed $B Matrix/Array
-	 *	@return Matrix Sum
+	 * @return PHPExcel_Shared_JAMA_Matrix
 	 */
 	public function plusEquals() {
 		if (func_num_args() > 0) {
@@ -504,8 +496,7 @@ 
 	 *	minus
 	 *
 	 *	A - B
-	 *	@param mixed $B Matrix/Array
-	 *	@return Matrix Sum
+	 * @return PHPExcel_Shared_JAMA_Matrix
 	 */
 	public function minus() {
 		if (func_num_args() > 0) {
@@ -540,8 +531,7 @@ 
 	 *	minusEquals
 	 *
 	 *	A = A - B
-	 *	@param mixed $B Matrix/Array
-	 *	@return Matrix Sum
+	 * @return PHPExcel_Shared_JAMA_Matrix
 	 */
 	public function minusEquals() {
 		if (func_num_args() > 0) {
@@ -591,8 +581,7 @@ 
 	 *
 	 *	Element-by-element multiplication
 	 *	Cij = Aij * Bij
-	 *	@param mixed $B Matrix/Array
-	 *	@return Matrix Matrix Cij
+	 * @return PHPExcel_Shared_JAMA_Matrix
 	 */
 	public function arrayTimes() {
 		if (func_num_args() > 0) {
@@ -628,8 +617,7 @@ 
 	 *
 	 *	Element-by-element multiplication
 	 *	Aij = Aij * Bij
-	 *	@param mixed $B Matrix/Array
-	 *	@return Matrix Matrix Aij
+	 * @return PHPExcel_Shared_JAMA_Matrix
 	 */
 	public function arrayTimesEquals() {
 		if (func_num_args() > 0) {
@@ -679,8 +667,7 @@ 
 	 *
 	 *	Element-by-element right division
 	 *	A / B
-	 *	@param Matrix $B Matrix B
-	 *	@return Matrix Division result
+	 * @return PHPExcel_Shared_JAMA_Matrix
 	 */
 	public function arrayRightDivide() {
 		if (func_num_args() > 0) {
@@ -735,8 +722,7 @@ 
 	 *
 	 *	Element-by-element right division
 	 *	Aij = Aij / Bij
-	 *	@param mixed $B Matrix/Array
-	 *	@return Matrix Matrix Aij
+	 * @return PHPExcel_Shared_JAMA_Matrix
 	 */
 	public function arrayRightDivideEquals() {
 		if (func_num_args() > 0) {
@@ -772,8 +758,7 @@ 
 	 *
 	 *	Element-by-element Left division
 	 *	A / B
-	 *	@param Matrix $B Matrix B
-	 *	@return Matrix Division result
+	 * @return PHPExcel_Shared_JAMA_Matrix
 	 */
 	public function arrayLeftDivide() {
 		if (func_num_args() > 0) {
@@ -809,8 +794,7 @@ 
 	 *
 	 *	Element-by-element Left division
 	 *	Aij = Aij / Bij
-	 *	@param mixed $B Matrix/Array
-	 *	@return Matrix Matrix Aij
+	 * @return PHPExcel_Shared_JAMA_Matrix
 	 */
 	public function arrayLeftDivideEquals() {
 		if (func_num_args() > 0) {
@@ -845,8 +829,6 @@ 
 	 *	times
 	 *
 	 *	Matrix multiplication
-	 *	@param mixed $n Matrix/Array/Scalar
-	 *	@return Matrix Product
 	 */
 	public function times() {
 		if (func_num_args() > 0) {
@@ -936,8 +918,7 @@ 
 	 *	power
 	 *
 	 *	A = A ^ B
-	 *	@param mixed $B Matrix/Array
-	 *	@return Matrix Sum
+	 * @return PHPExcel_Shared_JAMA_Matrix
 	 */
 	public function power() {
 		if (func_num_args() > 0) {
@@ -986,8 +967,7 @@ 
 	 *	concat
 	 *
 	 *	A = A & B
-	 *	@param mixed $B Matrix/Array
-	 *	@return Matrix Sum
+	 * @return PHPExcel_Shared_JAMA_Matrix
 	 */
 	public function concat() {
 		if (func_num_args() > 0) {
@@ -1020,7 +1000,7 @@ 
 	/**
 	 *	Solve A*X = B.
 	 *
-	 *	@param Matrix $B Right hand side
+	 *	@param PHPExcel_Shared_JAMA_Matrix $B Right hand side
 	 *	@return Matrix ... Solution if A is square, least squares solution otherwise
 	 */
 	public function solve($B) {

Spacing +101 added lines, -101 removed lines

@@ -4,12 +4,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');
 }
 
 
@@ -27,11 +27,11 @@ 
 class PHPExcel_Shared_JAMA_Matrix {
 
 
-	const PolymorphicArgumentException	= "Invalid argument pattern for polymorphic function.";
-	const ArgumentTypeException			= "Invalid argument type.";
-	const ArgumentBoundsException		= "Invalid argument range.";
-	const MatrixDimensionException		= "Matrix dimensions are not equal.";
-	const ArrayLengthException			= "Array length must be a multiple of m.";
+	const PolymorphicArgumentException = "Invalid argument pattern for polymorphic function.";
+	const ArgumentTypeException = "Invalid argument type.";
+	const ArgumentBoundsException = "Invalid argument range.";
+	const MatrixDimensionException = "Matrix dimensions are not equal.";
+	const ArrayLengthException = "Array length must be a multiple of m.";
 
 	/**
 	 *	Matrix storage
@@ -68,7 +68,7 @@ 
 			$args = func_get_args();
 			$match = implode(",", array_map('gettype', $args));
 
-			switch($match) {
+			switch ($match) {
 				//Rectangular matrix - m x n initialized from 2D array
 				case 'array':
 						$this->m = count($args[0]);
@@ -96,8 +96,8 @@ 
 							$this->n = 0;
 						}
 						if (($this->m * $this->n) == count($args[0])) {
-							for($i = 0; $i < $this->m; ++$i) {
-								for($j = 0; $j < $this->n; ++$j) {
+							for ($i = 0; $i < $this->m; ++$i) {
+								for ($j = 0; $j < $this->n; ++$j) {
 									$this->A[$i][$j] = $args[0][$i + $j * $this->m];
 								}
 							}
@@ -173,15 +173,15 @@ 
 			$args = func_get_args();
 			$match = implode(",", array_map('gettype', $args));
 
-			switch($match) {
+			switch ($match) {
 				//A($i0...; $j0...)
 				case 'integer,integer':
 						list($i0, $j0) = $args;
 						if ($i0 >= 0) { $m = $this->m - $i0; } else { throw new Exception(self::ArgumentBoundsException); }
 						if ($j0 >= 0) { $n = $this->n - $j0; } else { throw new Exception(self::ArgumentBoundsException); }
 						$R = new PHPExcel_Shared_JAMA_Matrix($m, $n);
-						for($i = $i0; $i < $this->m; ++$i) {
-							for($j = $j0; $j < $this->n; ++$j) {
+						for ($i = $i0; $i < $this->m; ++$i) {
+							for ($j = $j0; $j < $this->n; ++$j) {
 								$R->set($i, $j, $this->A[$i][$j]);
 							}
 						}
@@ -192,9 +192,9 @@ 
 						list($i0, $iF, $j0, $jF) = $args;
 						if (($iF > $i0) && ($this->m >= $iF) && ($i0 >= 0)) { $m = $iF - $i0; } else { throw new Exception(self::ArgumentBoundsException); }
 						if (($jF > $j0) && ($this->n >= $jF) && ($j0 >= 0)) { $n = $jF - $j0; } else { throw new Exception(self::ArgumentBoundsException); }
-						$R = new PHPExcel_Shared_JAMA_Matrix($m+1, $n+1);
-						for($i = $i0; $i <= $iF; ++$i) {
-							for($j = $j0; $j <= $jF; ++$j) {
+						$R = new PHPExcel_Shared_JAMA_Matrix($m + 1, $n + 1);
+						for ($i = $i0; $i <= $iF; ++$i) {
+							for ($j = $j0; $j <= $jF; ++$j) {
 								$R->set($i - $i0, $j - $j0, $this->A[$i][$j]);
 							}
 						}
@@ -206,8 +206,8 @@ 
 						if (count($RL) > 0) { $m = count($RL); } else { throw new Exception(self::ArgumentBoundsException); }
 						if (count($CL) > 0) { $n = count($CL); } else { throw new Exception(self::ArgumentBoundsException); }
 						$R = new PHPExcel_Shared_JAMA_Matrix($m, $n);
-						for($i = 0; $i < $m; ++$i) {
-							for($j = 0; $j < $n; ++$j) {
+						for ($i = 0; $i < $m; ++$i) {
+							for ($j = 0; $j < $n; ++$j) {
 								$R->set($i - $i0, $j - $j0, $this->A[$RL[$i]][$CL[$j]]);
 							}
 						}
@@ -219,8 +219,8 @@ 
 						if (count($RL) > 0) { $m = count($RL); } else { throw new Exception(self::ArgumentBoundsException); }
 						if (count($CL) > 0) { $n = count($CL); } else { throw new Exception(self::ArgumentBoundsException); }
 						$R = new PHPExcel_Shared_JAMA_Matrix($m, $n);
-						for($i = 0; $i < $m; ++$i) {
-							for($j = 0; $j < $n; ++$j) {
+						for ($i = 0; $i < $m; ++$i) {
+							for ($j = 0; $j < $n; ++$j) {
 								$R->set($i, $j, $this->A[$RL[$i]][$CL[$j]]);
 							}
 						}
@@ -232,8 +232,8 @@ 
 						if (($iF > $i0) && ($this->m >= $iF) && ($i0 >= 0)) { $m = $iF - $i0; } else { throw new Exception(self::ArgumentBoundsException); }
 						if (count($CL) > 0) { $n = count($CL); } else { throw new Exception(self::ArgumentBoundsException); }
 						$R = new PHPExcel_Shared_JAMA_Matrix($m, $n);
-						for($i = $i0; $i < $iF; ++$i) {
-							for($j = 0; $j < $n; ++$j) {
+						for ($i = $i0; $i < $iF; ++$i) {
+							for ($j = 0; $j < $n; ++$j) {
 								$R->set($i - $i0, $j, $this->A[$RL[$i]][$j]);
 							}
 						}
@@ -244,9 +244,9 @@ 
 						list($RL, $j0, $jF) = $args;
 						if (count($RL) > 0) { $m = count($RL); } else { throw new Exception(self::ArgumentBoundsException); }
 						if (($jF >= $j0) && ($this->n >= $jF) && ($j0 >= 0)) { $n = $jF - $j0; } else { throw new Exception(self::ArgumentBoundsException); }
-						$R = new PHPExcel_Shared_JAMA_Matrix($m, $n+1);
-						for($i = 0; $i < $m; ++$i) {
-							for($j = $j0; $j <= $jF; ++$j) {
+						$R = new PHPExcel_Shared_JAMA_Matrix($m, $n + 1);
+						for ($i = 0; $i < $m; ++$i) {
+							for ($j = $j0; $j <= $jF; ++$j) {
 								$R->set($i, $j - $j0, $this->A[$RL[$i]][$j]);
 							}
 						}
@@ -322,7 +322,7 @@ 
 	 */
 	public function diagonal($m = null, $n = null, $c = 1) {
 		$R = new PHPExcel_Shared_JAMA_Matrix($m, $n);
-		for($i = 0; $i < $m; ++$i) {
+		for ($i = 0; $i < $m; ++$i) {
 			$R->set($i, $i, $c);
 		}
 		return $R;
@@ -379,8 +379,8 @@ 
 	 */
 	public function transpose() {
 		$R = new PHPExcel_Shared_JAMA_Matrix($this->n, $this->m);
-		for($i = 0; $i < $this->m; ++$i) {
-			for($j = 0; $j < $this->n; ++$j) {
+		for ($i = 0; $i < $this->m; ++$i) {
+			for ($j = 0; $j < $this->n; ++$j) {
 				$R->set($j, $i, $this->A[$i][$j]);
 			}
 		}
@@ -397,7 +397,7 @@ 
 	public function trace() {
 		$s = 0;
 		$n = min($this->m, $this->n);
-		for($i = 0; $i < $n; ++$i) {
+		for ($i = 0; $i < $n; ++$i) {
 			$s += $this->A[$i][$i];
 		}
 		return $s;
@@ -426,7 +426,7 @@ 
 			$args = func_get_args();
 			$match = implode(",", array_map('gettype', $args));
 
-			switch($match) {
+			switch ($match) {
 				case 'object':
 						if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new Exception(self::ArgumentTypeException); }
 						break;
@@ -438,8 +438,8 @@ 
 						break;
 			}
 			$this->checkMatrixDimensions($M);
-			for($i = 0; $i < $this->m; ++$i) {
-				for($j = 0; $j < $this->n; ++$j) {
+			for ($i = 0; $i < $this->m; ++$i) {
+				for ($j = 0; $j < $this->n; ++$j) {
 					$M->set($i, $j, $M->get($i, $j) + $this->A[$i][$j]);
 				}
 			}
@@ -462,7 +462,7 @@ 
 			$args = func_get_args();
 			$match = implode(",", array_map('gettype', $args));
 
-			switch($match) {
+			switch ($match) {
 				case 'object':
 						if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new Exception(self::ArgumentTypeException); }
 						break;
@@ -474,16 +474,16 @@ 
 						break;
 			}
 			$this->checkMatrixDimensions($M);
-			for($i = 0; $i < $this->m; ++$i) {
-				for($j = 0; $j < $this->n; ++$j) {
+			for ($i = 0; $i < $this->m; ++$i) {
+				for ($j = 0; $j < $this->n; ++$j) {
 					$validValues = True;
 					$value = $M->get($i, $j);
-					if ((is_string($this->A[$i][$j])) && (strlen($this->A[$i][$j]) > 0) && (!is_numeric($this->A[$i][$j]))) {
-						$this->A[$i][$j] = trim($this->A[$i][$j],'"');
+					if ((is_string($this->A[$i][$j])) && (strlen($this->A[$i][$j]) > 0) && ( ! is_numeric($this->A[$i][$j]))) {
+						$this->A[$i][$j] = trim($this->A[$i][$j], '"');
 						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($this->A[$i][$j]);
 					}
-					if ((is_string($value)) && (strlen($value) > 0) && (!is_numeric($value))) {
-						$value = trim($value,'"');
+					if ((is_string($value)) && (strlen($value) > 0) && ( ! is_numeric($value))) {
+						$value = trim($value, '"');
 						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($value);
 					}
 					if ($validValues) {
@@ -512,7 +512,7 @@ 
 			$args = func_get_args();
 			$match = implode(",", array_map('gettype', $args));
 
-			switch($match) {
+			switch ($match) {
 				case 'object':
 						if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new Exception(self::ArgumentTypeException); }
 						break;
@@ -524,8 +524,8 @@ 
 						break;
 			}
 			$this->checkMatrixDimensions($M);
-			for($i = 0; $i < $this->m; ++$i) {
-				for($j = 0; $j < $this->n; ++$j) {
+			for ($i = 0; $i < $this->m; ++$i) {
+				for ($j = 0; $j < $this->n; ++$j) {
 					$M->set($i, $j, $M->get($i, $j) - $this->A[$i][$j]);
 				}
 			}
@@ -548,7 +548,7 @@ 
 			$args = func_get_args();
 			$match = implode(",", array_map('gettype', $args));
 
-			switch($match) {
+			switch ($match) {
 				case 'object':
 						if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new Exception(self::ArgumentTypeException); }
 						break;
@@ -560,16 +560,16 @@ 
 						break;
 			}
 			$this->checkMatrixDimensions($M);
-			for($i = 0; $i < $this->m; ++$i) {
-				for($j = 0; $j < $this->n; ++$j) {
+			for ($i = 0; $i < $this->m; ++$i) {
+				for ($j = 0; $j < $this->n; ++$j) {
 					$validValues = True;
 					$value = $M->get($i, $j);
-					if ((is_string($this->A[$i][$j])) && (strlen($this->A[$i][$j]) > 0) && (!is_numeric($this->A[$i][$j]))) {
-						$this->A[$i][$j] = trim($this->A[$i][$j],'"');
+					if ((is_string($this->A[$i][$j])) && (strlen($this->A[$i][$j]) > 0) && ( ! is_numeric($this->A[$i][$j]))) {
+						$this->A[$i][$j] = trim($this->A[$i][$j], '"');
 						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($this->A[$i][$j]);
 					}
-					if ((is_string($value)) && (strlen($value) > 0) && (!is_numeric($value))) {
-						$value = trim($value,'"');
+					if ((is_string($value)) && (strlen($value) > 0) && ( ! is_numeric($value))) {
+						$value = trim($value, '"');
 						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($value);
 					}
 					if ($validValues) {
@@ -599,7 +599,7 @@ 
 			$args = func_get_args();
 			$match = implode(",", array_map('gettype', $args));
 
-			switch($match) {
+			switch ($match) {
 				case 'object':
 						if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new Exception(self::ArgumentTypeException); }
 						break;
@@ -611,8 +611,8 @@ 
 						break;
 			}
 			$this->checkMatrixDimensions($M);
-			for($i = 0; $i < $this->m; ++$i) {
-				for($j = 0; $j < $this->n; ++$j) {
+			for ($i = 0; $i < $this->m; ++$i) {
+				for ($j = 0; $j < $this->n; ++$j) {
 					$M->set($i, $j, $M->get($i, $j) * $this->A[$i][$j]);
 				}
 			}
@@ -636,7 +636,7 @@ 
 			$args = func_get_args();
 			$match = implode(",", array_map('gettype', $args));
 
-			switch($match) {
+			switch ($match) {
 				case 'object':
 						if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new Exception(self::ArgumentTypeException); }
 						break;
@@ -648,16 +648,16 @@ 
 						break;
 			}
 			$this->checkMatrixDimensions($M);
-			for($i = 0; $i < $this->m; ++$i) {
-				for($j = 0; $j < $this->n; ++$j) {
+			for ($i = 0; $i < $this->m; ++$i) {
+				for ($j = 0; $j < $this->n; ++$j) {
 					$validValues = True;
 					$value = $M->get($i, $j);
-					if ((is_string($this->A[$i][$j])) && (strlen($this->A[$i][$j]) > 0) && (!is_numeric($this->A[$i][$j]))) {
-						$this->A[$i][$j] = trim($this->A[$i][$j],'"');
+					if ((is_string($this->A[$i][$j])) && (strlen($this->A[$i][$j]) > 0) && ( ! is_numeric($this->A[$i][$j]))) {
+						$this->A[$i][$j] = trim($this->A[$i][$j], '"');
 						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($this->A[$i][$j]);
 					}
-					if ((is_string($value)) && (strlen($value) > 0) && (!is_numeric($value))) {
-						$value = trim($value,'"');
+					if ((is_string($value)) && (strlen($value) > 0) && ( ! is_numeric($value))) {
+						$value = trim($value, '"');
 						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($value);
 					}
 					if ($validValues) {
@@ -687,7 +687,7 @@ 
 			$args = func_get_args();
 			$match = implode(",", array_map('gettype', $args));
 
-			switch($match) {
+			switch ($match) {
 				case 'object':
 						if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new Exception(self::ArgumentTypeException); }
 						break;
@@ -699,16 +699,16 @@ 
 						break;
 			}
 			$this->checkMatrixDimensions($M);
-			for($i = 0; $i < $this->m; ++$i) {
-				for($j = 0; $j < $this->n; ++$j) {
+			for ($i = 0; $i < $this->m; ++$i) {
+				for ($j = 0; $j < $this->n; ++$j) {
 					$validValues = True;
 					$value = $M->get($i, $j);
-					if ((is_string($this->A[$i][$j])) && (strlen($this->A[$i][$j]) > 0) && (!is_numeric($this->A[$i][$j]))) {
-						$this->A[$i][$j] = trim($this->A[$i][$j],'"');
+					if ((is_string($this->A[$i][$j])) && (strlen($this->A[$i][$j]) > 0) && ( ! is_numeric($this->A[$i][$j]))) {
+						$this->A[$i][$j] = trim($this->A[$i][$j], '"');
 						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($this->A[$i][$j]);
 					}
-					if ((is_string($value)) && (strlen($value) > 0) && (!is_numeric($value))) {
-						$value = trim($value,'"');
+					if ((is_string($value)) && (strlen($value) > 0) && ( ! is_numeric($value))) {
+						$value = trim($value, '"');
 						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($value);
 					}
 					if ($validValues) {
@@ -743,7 +743,7 @@ 
 			$args = func_get_args();
 			$match = implode(",", array_map('gettype', $args));
 
-			switch($match) {
+			switch ($match) {
 				case 'object':
 						if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new Exception(self::ArgumentTypeException); }
 						break;
@@ -755,8 +755,8 @@ 
 						break;
 			}
 			$this->checkMatrixDimensions($M);
-			for($i = 0; $i < $this->m; ++$i) {
-				for($j = 0; $j < $this->n; ++$j) {
+			for ($i = 0; $i < $this->m; ++$i) {
+				for ($j = 0; $j < $this->n; ++$j) {
 					$this->A[$i][$j] = $this->A[$i][$j] / $M->get($i, $j);
 				}
 			}
@@ -780,7 +780,7 @@ 
 			$args = func_get_args();
 			$match = implode(",", array_map('gettype', $args));
 
-			switch($match) {
+			switch ($match) {
 				case 'object':
 						if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new Exception(self::ArgumentTypeException); }
 						break;
@@ -792,8 +792,8 @@ 
 						break;
 			}
 			$this->checkMatrixDimensions($M);
-			for($i = 0; $i < $this->m; ++$i) {
-				for($j = 0; $j < $this->n; ++$j) {
+			for ($i = 0; $i < $this->m; ++$i) {
+				for ($j = 0; $j < $this->n; ++$j) {
 					$M->set($i, $j, $M->get($i, $j) / $this->A[$i][$j]);
 				}
 			}
@@ -817,7 +817,7 @@ 
 			$args = func_get_args();
 			$match = implode(",", array_map('gettype', $args));
 
-			switch($match) {
+			switch ($match) {
 				case 'object':
 						if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new Exception(self::ArgumentTypeException); }
 						break;
@@ -829,8 +829,8 @@ 
 						break;
 			}
 			$this->checkMatrixDimensions($M);
-			for($i = 0; $i < $this->m; ++$i) {
-				for($j = 0; $j < $this->n; ++$j) {
+			for ($i = 0; $i < $this->m; ++$i) {
+				for ($j = 0; $j < $this->n; ++$j) {
 					$this->A[$i][$j] = $M->get($i, $j) / $this->A[$i][$j];
 				}
 			}
@@ -853,19 +853,19 @@ 
 			$args  = func_get_args();
 			$match = implode(",", array_map('gettype', $args));
 
-			switch($match) {
+			switch ($match) {
 				case 'object':
 						if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $B = $args[0]; } else { throw new Exception(self::ArgumentTypeException); }
 						if ($this->n == $B->m) {
 							$C = new PHPExcel_Shared_JAMA_Matrix($this->m, $B->n);
-							for($j = 0; $j < $B->n; ++$j) {
+							for ($j = 0; $j < $B->n; ++$j) {
 								for ($k = 0; $k < $this->n; ++$k) {
 									$Bcolj[$k] = $B->A[$k][$j];
 								}
-								for($i = 0; $i < $this->m; ++$i) {
+								for ($i = 0; $i < $this->m; ++$i) {
 									$Arowi = $this->A[$i];
 									$s = 0;
-									for($k = 0; $k < $this->n; ++$k) {
+									for ($k = 0; $k < $this->n; ++$k) {
 										$s += $Arowi[$k] * $Bcolj[$k];
 									}
 									$C->A[$i][$j] = $s;
@@ -880,10 +880,10 @@ 
 						$B = new PHPExcel_Shared_JAMA_Matrix($args[0]);
 						if ($this->n == $B->m) {
 							$C = new PHPExcel_Shared_JAMA_Matrix($this->m, $B->n);
-							for($i = 0; $i < $C->m; ++$i) {
-								for($j = 0; $j < $C->n; ++$j) {
+							for ($i = 0; $i < $C->m; ++$i) {
+								for ($j = 0; $j < $C->n; ++$j) {
 									$s = "0";
-									for($k = 0; $k < $C->n; ++$k) {
+									for ($k = 0; $k < $C->n; ++$k) {
 										$s += $this->A[$i][$k] * $B->A[$k][$j];
 									}
 									$C->A[$i][$j] = $s;
@@ -897,8 +897,8 @@ 
 						break;
 				case 'integer':
 						$C = new PHPExcel_Shared_JAMA_Matrix($this->A);
-						for($i = 0; $i < $C->m; ++$i) {
-							for($j = 0; $j < $C->n; ++$j) {
+						for ($i = 0; $i < $C->m; ++$i) {
+							for ($j = 0; $j < $C->n; ++$j) {
 								$C->A[$i][$j] *= $args[0];
 							}
 						}
@@ -906,8 +906,8 @@ 
 						break;
 				case 'double':
 						$C = new PHPExcel_Shared_JAMA_Matrix($this->m, $this->n);
-						for($i = 0; $i < $C->m; ++$i) {
-							for($j = 0; $j < $C->n; ++$j) {
+						for ($i = 0; $i < $C->m; ++$i) {
+							for ($j = 0; $j < $C->n; ++$j) {
 								$C->A[$i][$j] = $args[0] * $this->A[$i][$j];
 							}
 						}
@@ -915,8 +915,8 @@ 
 						break;
 				case 'float':
 						$C = new PHPExcel_Shared_JAMA_Matrix($this->A);
-						for($i = 0; $i < $C->m; ++$i) {
-							for($j = 0; $j < $C->n; ++$j) {
+						for ($i = 0; $i < $C->m; ++$i) {
+							for ($j = 0; $j < $C->n; ++$j) {
 								$C->A[$i][$j] *= $args[0];
 							}
 						}
@@ -944,7 +944,7 @@ 
 			$args = func_get_args();
 			$match = implode(",", array_map('gettype', $args));
 
-			switch($match) {
+			switch ($match) {
 				case 'object':
 						if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new Exception(self::ArgumentTypeException); }
 						break;
@@ -956,20 +956,20 @@ 
 						break;
 			}
 			$this->checkMatrixDimensions($M);
-			for($i = 0; $i < $this->m; ++$i) {
-				for($j = 0; $j < $this->n; ++$j) {
+			for ($i = 0; $i < $this->m; ++$i) {
+				for ($j = 0; $j < $this->n; ++$j) {
 					$validValues = True;
 					$value = $M->get($i, $j);
-					if ((is_string($this->A[$i][$j])) && (strlen($this->A[$i][$j]) > 0) && (!is_numeric($this->A[$i][$j]))) {
-						$this->A[$i][$j] = trim($this->A[$i][$j],'"');
+					if ((is_string($this->A[$i][$j])) && (strlen($this->A[$i][$j]) > 0) && ( ! is_numeric($this->A[$i][$j]))) {
+						$this->A[$i][$j] = trim($this->A[$i][$j], '"');
 						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($this->A[$i][$j]);
 					}
-					if ((is_string($value)) && (strlen($value) > 0) && (!is_numeric($value))) {
-						$value = trim($value,'"');
+					if ((is_string($value)) && (strlen($value) > 0) && ( ! is_numeric($value))) {
+						$value = trim($value, '"');
 						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($value);
 					}
 					if ($validValues) {
-						$this->A[$i][$j] = pow($this->A[$i][$j],$value);
+						$this->A[$i][$j] = pow($this->A[$i][$j], $value);
 					} else {
 						$this->A[$i][$j] = PHPExcel_Calculation_Functions::NaN();
 					}
@@ -994,7 +994,7 @@ 
 			$args = func_get_args();
 			$match = implode(",", array_map('gettype', $args));
 
-			switch($match) {
+			switch ($match) {
 				case 'object':
 						if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new Exception(self::ArgumentTypeException); }
 				case 'array':
@@ -1005,9 +1005,9 @@ 
 						break;
 			}
 			$this->checkMatrixDimensions($M);
-			for($i = 0; $i < $this->m; ++$i) {
-				for($j = 0; $j < $this->n; ++$j) {
-					$this->A[$i][$j] = trim($this->A[$i][$j],'"').trim($M->get($i, $j),'"');
+			for ($i = 0; $i < $this->m; ++$i) {
+				for ($j = 0; $j < $this->n; ++$j) {
+					$this->A[$i][$j] = trim($this->A[$i][$j], '"').trim($M->get($i, $j), '"');
 				}
 			}
 			return $this;

app/Vendor/PHPExcel/PHPExcel/Shared/JAMA/QRDecomposition.php

Doc Comments +4 added lines, -4 removed lines

@@ -111,7 +111,7 @@ 
 	/**
 	 *	Return the Householder vectors
 	 *
-	 *	@return Matrix Lower trapezoidal matrix whose columns define the reflections
+	 *	@return PHPExcel_Shared_JAMA_Matrix Lower trapezoidal matrix whose columns define the reflections
 	 */
 	public function getH() {
 		for ($i = 0; $i < $this->m; ++$i) {
@@ -130,7 +130,7 @@ 
 	/**
 	 *	Return the upper triangular factor
 	 *
-	 *	@return Matrix upper triangular factor
+	 *	@return PHPExcel_Shared_JAMA_Matrix upper triangular factor
 	 */
 	public function getR() {
 		for ($i = 0; $i < $this->n; ++$i) {
@@ -151,7 +151,7 @@ 
 	/**
 	 *	Generate and return the (economy-sized) orthogonal factor
 	 *
-	 *	@return Matrix orthogonal factor
+	 *	@return PHPExcel_Shared_JAMA_Matrix orthogonal factor
 	 */
 	public function getQ() {
 		for ($k = $this->n-1; $k >= 0; --$k) {
@@ -189,7 +189,7 @@ 
 	 *	Least squares solution of A*X = B
 	 *
 	 *	@param Matrix $B A Matrix with as many rows as A and any number of columns.
-	 *	@return Matrix Matrix that minimizes the two norm of Q*R*X-B.
+	 *	@return PHPExcel_Shared_JAMA_Matrix|null Matrix that minimizes the two norm of Q*R*X-B.
 	 */
 	public function solve($B) {
 		if ($B->getRowDimension() == $this->m) {

Indentation +3 added lines, -3 removed lines

@@ -33,9 +33,9 @@
 	private $m;
 
 	/**
-	*	Column dimension.
-	*	@var integer
-	*/
+	 *	Column dimension.
+	 *	@var integer
+	 */
 	private $n;
 
 	/**

Spacing +10 added lines, -10 removed lines

@@ -18,7 +18,7 @@ 
  */
 class PHPExcel_Shared_JAMA_QRDecomposition {
 
-	const MatrixRankException	= "Can only perform operation on full-rank matrix.";
+	const MatrixRankException = "Can only perform operation on full-rank matrix.";
 
 	/**
 	 *	Array for internal storage of decomposition.
@@ -52,7 +52,7 @@ 
 	 *	@return Structure to access R and the Householder vectors and compute Q.
 	 */
 	public function __construct($A) {
-		if($A instanceof PHPExcel_Shared_JAMA_Matrix) {
+		if ($A instanceof PHPExcel_Shared_JAMA_Matrix) {
 			// Initialize.
 			$this->QR = $A->getArrayCopy();
 			$this->m  = $A->getRowDimension();
@@ -74,12 +74,12 @@ 
 					}
 					$this->QR[$k][$k] += 1.0;
 					// Apply transformation to remaining columns.
-					for ($j = $k+1; $j < $this->n; ++$j) {
+					for ($j = $k + 1; $j < $this->n; ++$j) {
 						$s = 0.0;
 						for ($i = $k; $i < $this->m; ++$i) {
 							$s += $this->QR[$i][$k] * $this->QR[$i][$j];
 						}
-						$s = -$s/$this->QR[$k][$k];
+						$s = -$s / $this->QR[$k][$k];
 						for ($i = $k; $i < $this->m; ++$i) {
 							$this->QR[$i][$j] += $s * $this->QR[$i][$k];
 						}
@@ -154,7 +154,7 @@ 
 	 *	@return Matrix orthogonal factor
 	 */
 	public function getQ() {
-		for ($k = $this->n-1; $k >= 0; --$k) {
+		for ($k = $this->n - 1; $k >= 0; --$k) {
 			for ($i = 0; $i < $this->m; ++$i) {
 				$Q[$i][$k] = 0.0;
 			}
@@ -165,7 +165,7 @@ 
 					for ($i = $k; $i < $this->m; ++$i) {
 						$s += $this->QR[$i][$k] * $Q[$i][$j];
 					}
-					$s = -$s/$this->QR[$k][$k];
+					$s = -$s / $this->QR[$k][$k];
 					for ($i = $k; $i < $this->m; ++$i) {
 						$Q[$i][$j] += $s * $this->QR[$i][$k];
 					}
@@ -204,25 +204,25 @@ 
 						for ($i = $k; $i < $this->m; ++$i) {
 							$s += $this->QR[$i][$k] * $X[$i][$j];
 						}
-						$s = -$s/$this->QR[$k][$k];
+						$s = -$s / $this->QR[$k][$k];
 						for ($i = $k; $i < $this->m; ++$i) {
 							$X[$i][$j] += $s * $this->QR[$i][$k];
 						}
 					}
 				}
 				// Solve R*X = Y;
-				for ($k = $this->n-1; $k >= 0; --$k) {
+				for ($k = $this->n - 1; $k >= 0; --$k) {
 					for ($j = 0; $j < $nx; ++$j) {
 						$X[$k][$j] /= $this->Rdiag[$k];
 					}
 					for ($i = 0; $i < $k; ++$i) {
 						for ($j = 0; $j < $nx; ++$j) {
-							$X[$i][$j] -= $X[$k][$j]* $this->QR[$i][$k];
+							$X[$i][$j] -= $X[$k][$j] * $this->QR[$i][$k];
 						}
 					}
 				}
 				$X = new PHPExcel_Shared_JAMA_Matrix($X);
-				return ($X->getMatrix(0, $this->n-1, 0, $nx));
+				return ($X->getMatrix(0, $this->n - 1, 0, $nx));
 			} else {
 				throw new Exception(self::MatrixRankException);
 			}

app/Vendor/PHPExcel/PHPExcel/Shared/JAMA/SingularValueDecomposition.php

Doc Comments +1 added lines, -1 removed lines

@@ -509,7 +509,7 @@
 	 *	Effective numerical matrix rank
 	 *
 	 *	@access public
-	 *	@return Number of nonnegligible singular values.
+	 *	@return integer of nonnegligible singular values.
 	 */
 	public function rank() {
 		$eps = pow(2.0, -52.0);

Spacing +61 added lines, -61 removed lines

@@ -17,7 +17,7 @@ 
  *	@license PHP v3.0
  *	@version 1.1
  */
-class SingularValueDecomposition  {
+class SingularValueDecomposition {
 
 	/**
 	 *	Internal storage of U.
@@ -74,7 +74,7 @@ 
 
 		// Reduce A to bidiagonal form, storing the diagonal elements
 		// in s and the super-diagonal elements in e.
-		for ($k = 0; $k < max($nct,$nrt); ++$k) {
+		for ($k = 0; $k < max($nct, $nrt); ++$k) {
 
 			if ($k < $nct) {
 				// Compute the transformation for the k-th column and
@@ -130,27 +130,27 @@ 
 					$e[$k] = hypo($e[$k], $e[$i]);
 				}
 				if ($e[$k] != 0.0) {
-					if ($e[$k+1] < 0.0) {
+					if ($e[$k + 1] < 0.0) {
 						$e[$k] = -$e[$k];
 					}
 					for ($i = $k + 1; $i < $this->n; ++$i) {
 						$e[$i] /= $e[$k];
 					}
-					$e[$k+1] += 1.0;
+					$e[$k + 1] += 1.0;
 				}
 				$e[$k] = -$e[$k];
-				if (($k+1 < $this->m) AND ($e[$k] != 0.0)) {
+				if (($k + 1 < $this->m) AND ($e[$k] != 0.0)) {
 					// Apply the transformation.
-					for ($i = $k+1; $i < $this->m; ++$i) {
+					for ($i = $k + 1; $i < $this->m; ++$i) {
 						$work[$i] = 0.0;
 					}
-					for ($j = $k+1; $j < $this->n; ++$j) {
-						for ($i = $k+1; $i < $this->m; ++$i) {
+					for ($j = $k + 1; $j < $this->n; ++$j) {
+						for ($i = $k + 1; $i < $this->m; ++$i) {
 							$work[$i] += $e[$j] * $A[$i][$j];
 						}
 					}
 					for ($j = $k + 1; $j < $this->n; ++$j) {
-						$t = -$e[$j] / $e[$k+1];
+						$t = -$e[$j] / $e[$k + 1];
 						for ($i = $k + 1; $i < $this->m; ++$i) {
 							$A[$i][$j] += $t * $work[$i];
 						}
@@ -172,12 +172,12 @@ 
 			$this->s[$nct] = $A[$nct][$nct];
 		}
 		if ($this->m < $p) {
-			$this->s[$p-1] = 0.0;
+			$this->s[$p - 1] = 0.0;
 		}
 		if ($nrt + 1 < $p) {
-			$e[$nrt] = $A[$nrt][$p-1];
+			$e[$nrt] = $A[$nrt][$p - 1];
 		}
-		$e[$p-1] = 0.0;
+		$e[$p - 1] = 0.0;
 		// If required, generate U.
 		if ($wantu) {
 			for ($j = $nct; $j < $nu; ++$j) {
@@ -198,7 +198,7 @@ 
 							$this->U[$i][$j] += $t * $this->U[$i][$k];
 						}
 					}
-					for ($i = $k; $i < $this->m; ++$i ) {
+					for ($i = $k; $i < $this->m; ++$i) {
 						$this->U[$i][$k] = -$this->U[$i][$k];
 					}
 					$this->U[$k][$k] = 1.0 + $this->U[$k][$k];
@@ -221,9 +221,9 @@ 
 					for ($j = $k + 1; $j < $nu; ++$j) {
 						$t = 0;
 						for ($i = $k + 1; $i < $this->n; ++$i) {
-							$t += $this->V[$i][$k]* $this->V[$i][$j];
+							$t += $this->V[$i][$k] * $this->V[$i][$j];
 						}
-						$t = -$t / $this->V[$k+1][$k];
+						$t = -$t / $this->V[$k + 1][$k];
 						for ($i = $k + 1; $i < $this->n; ++$i) {
 							$this->V[$i][$j] += $t * $this->V[$i][$k];
 						}
@@ -255,7 +255,7 @@ 
 				if ($k == -1) {
 					break;
 				}
-				if (abs($e[$k]) <= $eps * (abs($this->s[$k]) + abs($this->s[$k+1]))) {
+				if (abs($e[$k]) <= $eps * (abs($this->s[$k]) + abs($this->s[$k + 1]))) {
 					$e[$k] = 0.0;
 					break;
 				}
@@ -267,15 +267,15 @@ 
 					if ($ks == $k) {
 						break;
 					}
-					$t = ($ks != $p ? abs($e[$ks]) : 0.) + ($ks != $k + 1 ? abs($e[$ks-1]) : 0.);
-					if (abs($this->s[$ks]) <= $eps * $t)  {
+					$t = ($ks != $p ? abs($e[$ks]) : 0.) + ($ks != $k + 1 ? abs($e[$ks - 1]) : 0.);
+					if (abs($this->s[$ks]) <= $eps * $t) {
 						$this->s[$ks] = 0.0;
 						break;
 					}
 				}
 				if ($ks == $k) {
 					$kase = 3;
-				} else if ($ks == $p-1) {
+				} else if ($ks == $p - 1) {
 					$kase = 1;
 				} else {
 					$kase = 2;
@@ -288,21 +288,21 @@ 
 			switch ($kase) {
 				// Deflate negligible s(p).
 				case 1:
-						$f = $e[$p-2];
-						$e[$p-2] = 0.0;
+						$f = $e[$p - 2];
+						$e[$p - 2] = 0.0;
 						for ($j = $p - 2; $j >= $k; --$j) {
-							$t  = hypo($this->s[$j],$f);
+							$t  = hypo($this->s[$j], $f);
 							$cs = $this->s[$j] / $t;
 							$sn = $f / $t;
 							$this->s[$j] = $t;
 							if ($j != $k) {
-								$f = -$sn * $e[$j-1];
-								$e[$j-1] = $cs * $e[$j-1];
+								$f = -$sn * $e[$j - 1];
+								$e[$j - 1] = $cs * $e[$j - 1];
 							}
 							if ($wantv) {
 								for ($i = 0; $i < $this->n; ++$i) {
-									$t = $cs * $this->V[$i][$j] + $sn * $this->V[$i][$p-1];
-									$this->V[$i][$p-1] = -$sn * $this->V[$i][$j] + $cs * $this->V[$i][$p-1];
+									$t = $cs * $this->V[$i][$j] + $sn * $this->V[$i][$p - 1];
+									$this->V[$i][$p - 1] = -$sn * $this->V[$i][$j] + $cs * $this->V[$i][$p - 1];
 									$this->V[$i][$j] = $t;
 								}
 							}
@@ -310,8 +310,8 @@ 
 						break;
 				// Split at negligible s(k).
 				case 2:
-						$f = $e[$k-1];
-						$e[$k-1] = 0.0;
+						$f = $e[$k - 1];
+						$e[$k - 1] = 0.0;
 						for ($j = $k; $j < $p; ++$j) {
 							$t = hypo($this->s[$j], $f);
 							$cs = $this->s[$j] / $t;
@@ -321,8 +321,8 @@ 
 							$e[$j] = $cs * $e[$j];
 							if ($wantu) {
 								for ($i = 0; $i < $this->m; ++$i) {
-									$t = $cs * $this->U[$i][$j] + $sn * $this->U[$i][$k-1];
-									$this->U[$i][$k-1] = -$sn * $this->U[$i][$j] + $cs * $this->U[$i][$k-1];
+									$t = $cs * $this->U[$i][$j] + $sn * $this->U[$i][$k - 1];
+									$this->U[$i][$k - 1] = -$sn * $this->U[$i][$j] + $cs * $this->U[$i][$k - 1];
 									$this->U[$i][$j] = $t;
 								}
 							}
@@ -332,11 +332,11 @@ 
 				case 3:
 						// Calculate the shift.
 						$scale = max(max(max(max(
-									abs($this->s[$p-1]),abs($this->s[$p-2])),abs($e[$p-2])),
+									abs($this->s[$p - 1]), abs($this->s[$p - 2])), abs($e[$p - 2])),
 									abs($this->s[$k])), abs($e[$k]));
-						$sp   = $this->s[$p-1] / $scale;
-						$spm1 = $this->s[$p-2] / $scale;
-						$epm1 = $e[$p-2] / $scale;
+						$sp   = $this->s[$p - 1] / $scale;
+						$spm1 = $this->s[$p - 2] / $scale;
+						$epm1 = $e[$p - 2] / $scale;
 						$sk   = $this->s[$k] / $scale;
 						$ek   = $e[$k] / $scale;
 						$b    = (($spm1 + $sp) * ($spm1 - $sp) + $epm1 * $epm1) / 2.0;
@@ -352,41 +352,41 @@ 
 						$f = ($sk + $sp) * ($sk - $sp) + $shift;
 						$g = $sk * $ek;
 						// Chase zeros.
-						for ($j = $k; $j < $p-1; ++$j) {
-							$t  = hypo($f,$g);
-							$cs = $f/$t;
-							$sn = $g/$t;
+						for ($j = $k; $j < $p - 1; ++$j) {
+							$t  = hypo($f, $g);
+							$cs = $f / $t;
+							$sn = $g / $t;
 							if ($j != $k) {
-								$e[$j-1] = $t;
+								$e[$j - 1] = $t;
 							}
 							$f = $cs * $this->s[$j] + $sn * $e[$j];
 							$e[$j] = $cs * $e[$j] - $sn * $this->s[$j];
-							$g = $sn * $this->s[$j+1];
-							$this->s[$j+1] = $cs * $this->s[$j+1];
+							$g = $sn * $this->s[$j + 1];
+							$this->s[$j + 1] = $cs * $this->s[$j + 1];
 							if ($wantv) {
 								for ($i = 0; $i < $this->n; ++$i) {
-									$t = $cs * $this->V[$i][$j] + $sn * $this->V[$i][$j+1];
-									$this->V[$i][$j+1] = -$sn * $this->V[$i][$j] + $cs * $this->V[$i][$j+1];
+									$t = $cs * $this->V[$i][$j] + $sn * $this->V[$i][$j + 1];
+									$this->V[$i][$j + 1] = -$sn * $this->V[$i][$j] + $cs * $this->V[$i][$j + 1];
 									$this->V[$i][$j] = $t;
 								}
 							}
-							$t = hypo($f,$g);
-							$cs = $f/$t;
-							$sn = $g/$t;
+							$t = hypo($f, $g);
+							$cs = $f / $t;
+							$sn = $g / $t;
 							$this->s[$j] = $t;
-							$f = $cs * $e[$j] + $sn * $this->s[$j+1];
-							$this->s[$j+1] = -$sn * $e[$j] + $cs * $this->s[$j+1];
-							$g = $sn * $e[$j+1];
-							$e[$j+1] = $cs * $e[$j+1];
+							$f = $cs * $e[$j] + $sn * $this->s[$j + 1];
+							$this->s[$j + 1] = -$sn * $e[$j] + $cs * $this->s[$j + 1];
+							$g = $sn * $e[$j + 1];
+							$e[$j + 1] = $cs * $e[$j + 1];
 							if ($wantu && ($j < $this->m - 1)) {
 								for ($i = 0; $i < $this->m; ++$i) {
-									$t = $cs * $this->U[$i][$j] + $sn * $this->U[$i][$j+1];
-									$this->U[$i][$j+1] = -$sn * $this->U[$i][$j] + $cs * $this->U[$i][$j+1];
+									$t = $cs * $this->U[$i][$j] + $sn * $this->U[$i][$j + 1];
+									$this->U[$i][$j + 1] = -$sn * $this->U[$i][$j] + $cs * $this->U[$i][$j + 1];
 									$this->U[$i][$j] = $t;
 								}
 							}
 						}
-						$e[$p-2] = $f;
+						$e[$p - 2] = $f;
 						$iter = $iter + 1;
 						break;
 				// Convergence.
@@ -402,23 +402,23 @@ 
 						}
 						// Order the singular values.
 						while ($k < $pp) {
-							if ($this->s[$k] >= $this->s[$k+1]) {
+							if ($this->s[$k] >= $this->s[$k + 1]) {
 								break;
 							}
 							$t = $this->s[$k];
-							$this->s[$k] = $this->s[$k+1];
-							$this->s[$k+1] = $t;
+							$this->s[$k] = $this->s[$k + 1];
+							$this->s[$k + 1] = $t;
 							if ($wantv AND ($k < $this->n - 1)) {
 								for ($i = 0; $i < $this->n; ++$i) {
-									$t = $this->V[$i][$k+1];
-									$this->V[$i][$k+1] = $this->V[$i][$k];
+									$t = $this->V[$i][$k + 1];
+									$this->V[$i][$k + 1] = $this->V[$i][$k];
 									$this->V[$i][$k] = $t;
 								}
 							}
-							if ($wantu AND ($k < $this->m-1)) {
+							if ($wantu AND ($k < $this->m - 1)) {
 								for ($i = 0; $i < $this->m; ++$i) {
-									$t = $this->U[$i][$k+1];
-									$this->U[$i][$k+1] = $this->U[$i][$k];
+									$t = $this->U[$i][$k + 1];
+									$this->U[$i][$k + 1] = $this->U[$i][$k];
 									$this->U[$i][$k] = $t;
 								}
 							}

app/Vendor/PHPExcel/PHPExcel/Shared/JAMA/tests/TestMatrix.php

Doc Comments -4 removed lines

@@ -364,8 +364,6 @@ 
 
   /**
   * Check norm of difference of "vectors".
-  * @param float $x[]
-  * @param float $y[]
   */
   function checkVectors($x, $y) {
     $nx = count($x);
@@ -379,8 +377,6 @@ 
 
   /**
   * Check norm of difference of "arrays".
-  * @param float $x[][]
-  * @param float $y[][]
   */
   function checkArrays($x, $y) {
     $A = new Matrix($x);

Indentation +338 added lines, -338 removed lines

@@ -6,115 +6,115 @@ 
 
   function TestMatrix() {
 
-    // define test variables
-
-    $errorCount   = 0;
-    $warningCount = 0;
-    $columnwise   = array(1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.);
-    $rowwise      = array(1.,4.,7.,10.,2.,5.,8.,11.,3.,6.,9.,12.);
-    $avals        = array(array(1.,4.,7.,10.),array(2.,5.,8.,11.),array(3.,6.,9.,12.));
-    $rankdef      = $avals;
-    $tvals        = array(array(1.,2.,3.),array(4.,5.,6.),array(7.,8.,9.),array(10.,11.,12.));
-    $subavals     = array(array(5.,8.,11.),array(6.,9.,12.));
-    $rvals        = array(array(1.,4.,7.),array(2.,5.,8.,11.),array(3.,6.,9.,12.));
-    $pvals        = array(array(1.,1.,1.),array(1.,2.,3.),array(1.,3.,6.));
-    $ivals        = array(array(1.,0.,0.,0.),array(0.,1.,0.,0.),array(0.,0.,1.,0.));
-    $evals        = array(array(0.,1.,0.,0.),array(1.,0.,2.e-7,0.),array(0.,-2.e-7,0.,1.),array(0.,0.,1.,0.));
-    $square       = array(array(166.,188.,210.),array(188.,214.,240.),array(210.,240.,270.));
-    $sqSolution   = array(array(13.),array(15.));
-    $condmat      = array(array(1.,3.),array(7.,9.));
-    $rows         = 3;
-    $cols         = 4;
-    $invalidID    = 5; /* should trigger bad shape for construction with val        */
-    $raggedr      = 0; /* (raggedr,raggedc) should be out of bounds in ragged array */
-    $raggedc      = 4;
-    $validID      = 3; /* leading dimension of intended test Matrices               */
-    $nonconformld = 4; /* leading dimension which is valid, but nonconforming       */
-    $ib           = 1; /* index ranges for sub Matrix                               */
-    $ie           = 2;
-    $jb           = 1;
-    $je           = 3;
-    $rowindexset       = array(1,2);
-    $badrowindexset    = array(1,3);
-    $columnindexset    = array(1,2,3);
-    $badcolumnindexset = array(1,2,4);
-    $columnsummax      = 33.;
-    $rowsummax         = 30.;
-    $sumofdiagonals    = 15;
-    $sumofsquares      = 650;
-
-    /**
-    * Test matrix methods
-    */
-
-    /**
-    * Constructors and constructor-like methods:
-    *
-    *   Matrix(double[], int)
-    *   Matrix(double[][])
-    *   Matrix(int, int)
-    *   Matrix(int, int, double)
-    *   Matrix(int, int, double[][])
-    *   constructWithCopy(double[][])
-    *   random(int,int)
-    *   identity(int)
-    */
-    echo "<p>Testing constructors and constructor-like methods...</p>";
-
-    $A = new Matrix($columnwise, 3);
-    if($A instanceof Matrix) {
-      $this->try_success("Column-packed constructor...");
-    } else
-      $errorCount = $this->try_failure($errorCount, "Column-packed constructor...", "Unable to construct Matrix");
-
-    $T = new Matrix($tvals);
-    if($T instanceof Matrix)
-      $this->try_success("2D array constructor...");
-    else
-      $errorCount = $this->try_failure($errorCount, "2D array constructor...", "Unable to construct Matrix");
-
-    $A = new Matrix($columnwise, $validID);
-    $B = new Matrix($avals);
-    $tmp = $B->get(0,0);
-    $avals[0][0] = 0.0;
-    $C = $B->minus($A);
-    $avals[0][0] = $tmp;
-    $B = Matrix::constructWithCopy($avals);
-    $tmp = $B->get(0,0);
-    $avals[0][0] = 0.0;
-    /** check that constructWithCopy behaves properly **/
-    if ( ( $tmp - $B->get(0,0) ) != 0.0 )
-      $errorCount = $this->try_failure($errorCount,"constructWithCopy... ","copy not effected... data visible outside");
-    else
-      $this->try_success("constructWithCopy... ","");
-
-    $I = new Matrix($ivals);
-    if ( $this->checkMatrices($I,Matrix::identity(3,4)) )
-      $this->try_success("identity... ","");
-    else
-      $errorCount = $this->try_failure($errorCount,"identity... ","identity Matrix not successfully created");
-
-    /**
-    * Access Methods:
-    *
-    *   getColumnDimension()
-    *   getRowDimension()
-    *   getArray()
-    *   getArrayCopy()
-    *   getColumnPackedCopy()
-    *   getRowPackedCopy()
-    *   get(int,int)
-    *   getMatrix(int,int,int,int)
-    *   getMatrix(int,int,int[])
-    *   getMatrix(int[],int,int)
-    *   getMatrix(int[],int[])
-    *   set(int,int,double)
-    *   setMatrix(int,int,int,int,Matrix)
-    *   setMatrix(int,int,int[],Matrix)
-    *   setMatrix(int[],int,int,Matrix)
-    *   setMatrix(int[],int[],Matrix)
-    */
-    print "<p>Testing access methods...</p>";
+	// define test variables
+
+	$errorCount   = 0;
+	$warningCount = 0;
+	$columnwise   = array(1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.);
+	$rowwise      = array(1.,4.,7.,10.,2.,5.,8.,11.,3.,6.,9.,12.);
+	$avals        = array(array(1.,4.,7.,10.),array(2.,5.,8.,11.),array(3.,6.,9.,12.));
+	$rankdef      = $avals;
+	$tvals        = array(array(1.,2.,3.),array(4.,5.,6.),array(7.,8.,9.),array(10.,11.,12.));
+	$subavals     = array(array(5.,8.,11.),array(6.,9.,12.));
+	$rvals        = array(array(1.,4.,7.),array(2.,5.,8.,11.),array(3.,6.,9.,12.));
+	$pvals        = array(array(1.,1.,1.),array(1.,2.,3.),array(1.,3.,6.));
+	$ivals        = array(array(1.,0.,0.,0.),array(0.,1.,0.,0.),array(0.,0.,1.,0.));
+	$evals        = array(array(0.,1.,0.,0.),array(1.,0.,2.e-7,0.),array(0.,-2.e-7,0.,1.),array(0.,0.,1.,0.));
+	$square       = array(array(166.,188.,210.),array(188.,214.,240.),array(210.,240.,270.));
+	$sqSolution   = array(array(13.),array(15.));
+	$condmat      = array(array(1.,3.),array(7.,9.));
+	$rows         = 3;
+	$cols         = 4;
+	$invalidID    = 5; /* should trigger bad shape for construction with val        */
+	$raggedr      = 0; /* (raggedr,raggedc) should be out of bounds in ragged array */
+	$raggedc      = 4;
+	$validID      = 3; /* leading dimension of intended test Matrices               */
+	$nonconformld = 4; /* leading dimension which is valid, but nonconforming       */
+	$ib           = 1; /* index ranges for sub Matrix                               */
+	$ie           = 2;
+	$jb           = 1;
+	$je           = 3;
+	$rowindexset       = array(1,2);
+	$badrowindexset    = array(1,3);
+	$columnindexset    = array(1,2,3);
+	$badcolumnindexset = array(1,2,4);
+	$columnsummax      = 33.;
+	$rowsummax         = 30.;
+	$sumofdiagonals    = 15;
+	$sumofsquares      = 650;
+
+	/**
+	 * Test matrix methods
+	 */
+
+	/**
+	 * Constructors and constructor-like methods:
+	 *
+	 *   Matrix(double[], int)
+	 *   Matrix(double[][])
+	 *   Matrix(int, int)
+	 *   Matrix(int, int, double)
+	 *   Matrix(int, int, double[][])
+	 *   constructWithCopy(double[][])
+	 *   random(int,int)
+	 *   identity(int)
+	 */
+	echo "<p>Testing constructors and constructor-like methods...</p>";
+
+	$A = new Matrix($columnwise, 3);
+	if($A instanceof Matrix) {
+	  $this->try_success("Column-packed constructor...");
+	} else
+	  $errorCount = $this->try_failure($errorCount, "Column-packed constructor...", "Unable to construct Matrix");
+
+	$T = new Matrix($tvals);
+	if($T instanceof Matrix)
+	  $this->try_success("2D array constructor...");
+	else
+	  $errorCount = $this->try_failure($errorCount, "2D array constructor...", "Unable to construct Matrix");
+
+	$A = new Matrix($columnwise, $validID);
+	$B = new Matrix($avals);
+	$tmp = $B->get(0,0);
+	$avals[0][0] = 0.0;
+	$C = $B->minus($A);
+	$avals[0][0] = $tmp;
+	$B = Matrix::constructWithCopy($avals);
+	$tmp = $B->get(0,0);
+	$avals[0][0] = 0.0;
+	/** check that constructWithCopy behaves properly **/
+	if ( ( $tmp - $B->get(0,0) ) != 0.0 )
+	  $errorCount = $this->try_failure($errorCount,"constructWithCopy... ","copy not effected... data visible outside");
+	else
+	  $this->try_success("constructWithCopy... ","");
+
+	$I = new Matrix($ivals);
+	if ( $this->checkMatrices($I,Matrix::identity(3,4)) )
+	  $this->try_success("identity... ","");
+	else
+	  $errorCount = $this->try_failure($errorCount,"identity... ","identity Matrix not successfully created");
+
+	/**
+	 * Access Methods:
+	 *
+	 *   getColumnDimension()
+	 *   getRowDimension()
+	 *   getArray()
+	 *   getArrayCopy()
+	 *   getColumnPackedCopy()
+	 *   getRowPackedCopy()
+	 *   get(int,int)
+	 *   getMatrix(int,int,int,int)
+	 *   getMatrix(int,int,int[])
+	 *   getMatrix(int[],int,int)
+	 *   getMatrix(int[],int[])
+	 *   set(int,int,double)
+	 *   setMatrix(int,int,int,int,Matrix)
+	 *   setMatrix(int,int,int[],Matrix)
+	 *   setMatrix(int[],int,int,Matrix)
+	 *   setMatrix(int[],int[],Matrix)
+	 */
+	print "<p>Testing access methods...</p>";
 
 	$B = new Matrix($avals);
 	if($B->getRowDimension() == $rows)
@@ -145,268 +145,268 @@ 
 	else
 	  $errorCount = $this->try_failure($errorCount, "getRowPackedCopy...");
 
-    /**
-    * Array-like methods:
-    *   minus
-    *   minusEquals
-    *   plus
-    *   plusEquals
-    *   arrayLeftDivide
-    *   arrayLeftDivideEquals
-    *   arrayRightDivide
-    *   arrayRightDivideEquals
-    *   arrayTimes
-    *   arrayTimesEquals
-    *   uminus
-    */
-    print "<p>Testing array-like methods...</p>";
-
-    /**
-    * I/O methods:
-    *   read
-    *   print
-    *   serializable:
-    *   writeObject
-    *   readObject
-    */
-    print "<p>Testing I/O methods...</p>";
-
-    /**
-    * Test linear algebra methods
-    */
-    echo "<p>Testing linear algebra methods...<p>";
-
-    $A = new Matrix($columnwise, 3);
-    if( $this->checkMatrices($A->transpose(), $T) )
-      $this->try_success("Transpose check...");
-    else
-      $errorCount = $this->try_failure($errorCount, "Transpose check...", "Matrices are not equal");
-
-    if($this->checkScalars($A->norm1(), $columnsummax))
-      $this->try_success("Maximum column sum...");
-    else
-      $errorCount = $this->try_failure($errorCount, "Maximum column sum...", "Incorrect: " . $A->norm1() . " != " . $columnsummax);
-
-    if($this->checkScalars($A->normInf(), $rowsummax))
-      $this->try_success("Maximum row sum...");
-    else
-      $errorCount = $this->try_failure($errorCount, "Maximum row sum...", "Incorrect: " . $A->normInf() . " != " . $rowsummax );
-
-    if($this->checkScalars($A->normF(), sqrt($sumofsquares)))
-      $this->try_success("Frobenius norm...");
-    else
-      $errorCount = $this->try_failure($errorCount, "Frobenius norm...", "Incorrect:" . $A->normF() . " != " . sqrt($sumofsquares));
-
-    if($this->checkScalars($A->trace(), $sumofdiagonals))
-      $this->try_success("Matrix trace...");
-    else
-      $errorCount = $this->try_failure($errorCount, "Matrix trace...", "Incorrect: " . $A->trace() . " != " . $sumofdiagonals);
-
-    $B = $A->getMatrix(0, $A->getRowDimension(), 0, $A->getRowDimension());
-    if( $B->det() == 0 )
-      $this->try_success("Matrix determinant...");
-    else
-      $errorCount = $this->try_failure($errorCount, "Matrix determinant...", "Incorrect: " . $B->det() . " != " . 0);
-
-    $A = new Matrix($columnwise,3);
-    $SQ = new Matrix($square);
-    if ($this->checkMatrices($SQ, $A->times($A->transpose())))
-      $this->try_success("times(Matrix)...");
-    else {
-      $errorCount = $this->try_failure($errorCount, "times(Matrix)...", "Unable to multiply matrices");
-      $SQ->toHTML();
-      $AT->toHTML();
-    }
-
-    $A = new Matrix($columnwise, 4);
-
-    $QR = $A->qr();
-    $R = $QR->getR();
-    $Q = $QR->getQ();
-    if($this->checkMatrices($A, $Q->times($R)))
-      $this->try_success("QRDecomposition...","");
-    else
-      $errorCount = $this->try_failure($errorCount,"QRDecomposition...","incorrect qr decomposition calculation");
-
-    $A = new Matrix($columnwise, 4);
-    $SVD = $A->svd();
-    $U = $SVD->getU();
-    $S = $SVD->getS();
-    $V = $SVD->getV();
-    if ($this->checkMatrices($A, $U->times($S->times($V->transpose()))))
-      $this->try_success("SingularValueDecomposition...","");
-    else
-      $errorCount = $this->try_failure($errorCount,"SingularValueDecomposition...","incorrect singular value decomposition calculation");
-
-    $n = $A->getColumnDimension();
-    $A = $A->getMatrix(0,$n-1,0,$n-1);
-    $A->set(0,0,0.);
-
-    $LU = $A->lu();
-    $L  = $LU->getL();
-    if ( $this->checkMatrices($A->getMatrix($LU->getPivot(),0,$n-1), $L->times($LU->getU())) )
-      $this->try_success("LUDecomposition...","");
-    else
-      $errorCount = $this->try_failure($errorCount,"LUDecomposition...","incorrect LU decomposition calculation");
-
-    $X = $A->inverse();
-    if ( $this->checkMatrices($A->times($X),Matrix::identity(3,3)) )
-       $this->try_success("inverse()...","");
-     else
-       $errorCount = $this->try_failure($errorCount, "inverse()...","incorrect inverse calculation");
-
-    $DEF = new Matrix($rankdef);
-    if($this->checkScalars($DEF->rank(), min($DEF->getRowDimension(), $DEF->getColumnDimension())-1))
-      $this->try_success("Rank...");
-    else
-      $this->try_failure("Rank...", "incorrect rank calculation");
-
-    $B = new Matrix($condmat);
-    $SVD = $B->svd();
-    $singularvalues = $SVD->getSingularValues();
-    if($this->checkScalars($B->cond(), $singularvalues[0]/$singularvalues[min($B->getRowDimension(), $B->getColumnDimension())-1]))
-      $this->try_success("Condition number...");
-    else
-      $this->try_failure("Condition number...", "incorrect condition number calculation");
-
-    $SUB = new Matrix($subavals);
-    $O   = new Matrix($SUB->getRowDimension(),1,1.0);
-    $SOL = new Matrix($sqSolution);
-    $SQ = $SUB->getMatrix(0,$SUB->getRowDimension()-1,0,$SUB->getRowDimension()-1);
-    if ( $this->checkMatrices($SQ->solve($SOL),$O) )
-      $this->try_success("solve()...","");
-    else
-     $errorCount = $this->try_failure($errorCount,"solve()...","incorrect lu solve calculation");
-
-    $A = new Matrix($pvals);
-    $Chol = $A->chol();
-    $L = $Chol->getL();
-    if ( $this->checkMatrices($A, $L->times($L->transpose())) )
-      $this->try_success("CholeskyDecomposition...","");
-    else
-      $errorCount = $this->try_failure($errorCount,"CholeskyDecomposition...","incorrect Cholesky decomposition calculation");
-
-    $X = $Chol->solve(Matrix::identity(3,3));
-    if ( $this->checkMatrices($A->times($X), Matrix::identity(3,3)) )
-      $this->try_success("CholeskyDecomposition solve()...","");
-    else
-      $errorCount = $this->try_failure($errorCount,"CholeskyDecomposition solve()...","incorrect Choleskydecomposition solve calculation");
-
-    $Eig = $A->eig();
-    $D = $Eig->getD();
-    $V = $Eig->getV();
-    if( $this->checkMatrices($A->times($V),$V->times($D)) )
-      $this->try_success("EigenvalueDecomposition (symmetric)...","");
-    else
-      $errorCount = $this->try_failure($errorCount,"EigenvalueDecomposition (symmetric)...","incorrect symmetric Eigenvalue decomposition calculation");
-
-    $A = new Matrix($evals);
-    $Eig = $A->eig();
-    $D = $Eig->getD();
-    $V = $Eig->getV();
-    if ( $this->checkMatrices($A->times($V),$V->times($D)) )
-      $this->try_success("EigenvalueDecomposition (nonsymmetric)...","");
-    else
-      $errorCount = $this->try_failure($errorCount,"EigenvalueDecomposition (nonsymmetric)...","incorrect nonsymmetric Eigenvalue decomposition calculation");
+	/**
+	 * Array-like methods:
+	 *   minus
+	 *   minusEquals
+	 *   plus
+	 *   plusEquals
+	 *   arrayLeftDivide
+	 *   arrayLeftDivideEquals
+	 *   arrayRightDivide
+	 *   arrayRightDivideEquals
+	 *   arrayTimes
+	 *   arrayTimesEquals
+	 *   uminus
+	 */
+	print "<p>Testing array-like methods...</p>";
+
+	/**
+	 * I/O methods:
+	 *   read
+	 *   print
+	 *   serializable:
+	 *   writeObject
+	 *   readObject
+	 */
+	print "<p>Testing I/O methods...</p>";
+
+	/**
+	 * Test linear algebra methods
+	 */
+	echo "<p>Testing linear algebra methods...<p>";
+
+	$A = new Matrix($columnwise, 3);
+	if( $this->checkMatrices($A->transpose(), $T) )
+	  $this->try_success("Transpose check...");
+	else
+	  $errorCount = $this->try_failure($errorCount, "Transpose check...", "Matrices are not equal");
+
+	if($this->checkScalars($A->norm1(), $columnsummax))
+	  $this->try_success("Maximum column sum...");
+	else
+	  $errorCount = $this->try_failure($errorCount, "Maximum column sum...", "Incorrect: " . $A->norm1() . " != " . $columnsummax);
+
+	if($this->checkScalars($A->normInf(), $rowsummax))
+	  $this->try_success("Maximum row sum...");
+	else
+	  $errorCount = $this->try_failure($errorCount, "Maximum row sum...", "Incorrect: " . $A->normInf() . " != " . $rowsummax );
+
+	if($this->checkScalars($A->normF(), sqrt($sumofsquares)))
+	  $this->try_success("Frobenius norm...");
+	else
+	  $errorCount = $this->try_failure($errorCount, "Frobenius norm...", "Incorrect:" . $A->normF() . " != " . sqrt($sumofsquares));
+
+	if($this->checkScalars($A->trace(), $sumofdiagonals))
+	  $this->try_success("Matrix trace...");
+	else
+	  $errorCount = $this->try_failure($errorCount, "Matrix trace...", "Incorrect: " . $A->trace() . " != " . $sumofdiagonals);
+
+	$B = $A->getMatrix(0, $A->getRowDimension(), 0, $A->getRowDimension());
+	if( $B->det() == 0 )
+	  $this->try_success("Matrix determinant...");
+	else
+	  $errorCount = $this->try_failure($errorCount, "Matrix determinant...", "Incorrect: " . $B->det() . " != " . 0);
+
+	$A = new Matrix($columnwise,3);
+	$SQ = new Matrix($square);
+	if ($this->checkMatrices($SQ, $A->times($A->transpose())))
+	  $this->try_success("times(Matrix)...");
+	else {
+	  $errorCount = $this->try_failure($errorCount, "times(Matrix)...", "Unable to multiply matrices");
+	  $SQ->toHTML();
+	  $AT->toHTML();
+	}
+
+	$A = new Matrix($columnwise, 4);
+
+	$QR = $A->qr();
+	$R = $QR->getR();
+	$Q = $QR->getQ();
+	if($this->checkMatrices($A, $Q->times($R)))
+	  $this->try_success("QRDecomposition...","");
+	else
+	  $errorCount = $this->try_failure($errorCount,"QRDecomposition...","incorrect qr decomposition calculation");
+
+	$A = new Matrix($columnwise, 4);
+	$SVD = $A->svd();
+	$U = $SVD->getU();
+	$S = $SVD->getS();
+	$V = $SVD->getV();
+	if ($this->checkMatrices($A, $U->times($S->times($V->transpose()))))
+	  $this->try_success("SingularValueDecomposition...","");
+	else
+	  $errorCount = $this->try_failure($errorCount,"SingularValueDecomposition...","incorrect singular value decomposition calculation");
+
+	$n = $A->getColumnDimension();
+	$A = $A->getMatrix(0,$n-1,0,$n-1);
+	$A->set(0,0,0.);
+
+	$LU = $A->lu();
+	$L  = $LU->getL();
+	if ( $this->checkMatrices($A->getMatrix($LU->getPivot(),0,$n-1), $L->times($LU->getU())) )
+	  $this->try_success("LUDecomposition...","");
+	else
+	  $errorCount = $this->try_failure($errorCount,"LUDecomposition...","incorrect LU decomposition calculation");
+
+	$X = $A->inverse();
+	if ( $this->checkMatrices($A->times($X),Matrix::identity(3,3)) )
+	   $this->try_success("inverse()...","");
+	 else
+	   $errorCount = $this->try_failure($errorCount, "inverse()...","incorrect inverse calculation");
+
+	$DEF = new Matrix($rankdef);
+	if($this->checkScalars($DEF->rank(), min($DEF->getRowDimension(), $DEF->getColumnDimension())-1))
+	  $this->try_success("Rank...");
+	else
+	  $this->try_failure("Rank...", "incorrect rank calculation");
+
+	$B = new Matrix($condmat);
+	$SVD = $B->svd();
+	$singularvalues = $SVD->getSingularValues();
+	if($this->checkScalars($B->cond(), $singularvalues[0]/$singularvalues[min($B->getRowDimension(), $B->getColumnDimension())-1]))
+	  $this->try_success("Condition number...");
+	else
+	  $this->try_failure("Condition number...", "incorrect condition number calculation");
+
+	$SUB = new Matrix($subavals);
+	$O   = new Matrix($SUB->getRowDimension(),1,1.0);
+	$SOL = new Matrix($sqSolution);
+	$SQ = $SUB->getMatrix(0,$SUB->getRowDimension()-1,0,$SUB->getRowDimension()-1);
+	if ( $this->checkMatrices($SQ->solve($SOL),$O) )
+	  $this->try_success("solve()...","");
+	else
+	 $errorCount = $this->try_failure($errorCount,"solve()...","incorrect lu solve calculation");
+
+	$A = new Matrix($pvals);
+	$Chol = $A->chol();
+	$L = $Chol->getL();
+	if ( $this->checkMatrices($A, $L->times($L->transpose())) )
+	  $this->try_success("CholeskyDecomposition...","");
+	else
+	  $errorCount = $this->try_failure($errorCount,"CholeskyDecomposition...","incorrect Cholesky decomposition calculation");
+
+	$X = $Chol->solve(Matrix::identity(3,3));
+	if ( $this->checkMatrices($A->times($X), Matrix::identity(3,3)) )
+	  $this->try_success("CholeskyDecomposition solve()...","");
+	else
+	  $errorCount = $this->try_failure($errorCount,"CholeskyDecomposition solve()...","incorrect Choleskydecomposition solve calculation");
+
+	$Eig = $A->eig();
+	$D = $Eig->getD();
+	$V = $Eig->getV();
+	if( $this->checkMatrices($A->times($V),$V->times($D)) )
+	  $this->try_success("EigenvalueDecomposition (symmetric)...","");
+	else
+	  $errorCount = $this->try_failure($errorCount,"EigenvalueDecomposition (symmetric)...","incorrect symmetric Eigenvalue decomposition calculation");
+
+	$A = new Matrix($evals);
+	$Eig = $A->eig();
+	$D = $Eig->getD();
+	$V = $Eig->getV();
+	if ( $this->checkMatrices($A->times($V),$V->times($D)) )
+	  $this->try_success("EigenvalueDecomposition (nonsymmetric)...","");
+	else
+	  $errorCount = $this->try_failure($errorCount,"EigenvalueDecomposition (nonsymmetric)...","incorrect nonsymmetric Eigenvalue decomposition calculation");
 
 	print("<b>{$errorCount} total errors</b>.");
   }
 
   /**
-  * Print appropriate messages for successful outcome try
-  * @param string $s
-  * @param string $e
-  */
+   * Print appropriate messages for successful outcome try
+   * @param string $s
+   * @param string $e
+   */
   function try_success($s, $e = "") {
-    print "> ". $s ."success<br />";
-    if ($e != "")
-      print "> Message: ". $e ."<br />";
+	print "> ". $s ."success<br />";
+	if ($e != "")
+	  print "> Message: ". $e ."<br />";
   }
 
   /**
-  * Print appropriate messages for unsuccessful outcome try
-  * @param int $count
-  * @param string $s
-  * @param string $e
-  * @return int incremented counter
-  */
+   * Print appropriate messages for unsuccessful outcome try
+   * @param int $count
+   * @param string $s
+   * @param string $e
+   * @return int incremented counter
+   */
   function try_failure($count, $s, $e="") {
-    print "> ". $s ."*** failure ***<br />> Message: ". $e ."<br />";
-    return ++$count;
+	print "> ". $s ."*** failure ***<br />> Message: ". $e ."<br />";
+	return ++$count;
   }
 
   /**
-  * Print appropriate messages for unsuccessful outcome try
-  * @param int $count
-  * @param string $s
-  * @param string $e
-  * @return int incremented counter
-  */
+   * Print appropriate messages for unsuccessful outcome try
+   * @param int $count
+   * @param string $s
+   * @param string $e
+   * @return int incremented counter
+   */
   function try_warning($count, $s, $e="") {
-    print "> ". $s ."*** warning ***<br />> Message: ". $e ."<br />";
-    return ++$count;
+	print "> ". $s ."*** warning ***<br />> Message: ". $e ."<br />";
+	return ++$count;
   }
 
   /**
-  * Check magnitude of difference of "scalars".
-  * @param float $x
-  * @param float $y
-  */
+   * Check magnitude of difference of "scalars".
+   * @param float $x
+   * @param float $y
+   */
   function checkScalars($x, $y) {
-    $eps = pow(2.0,-52.0);
-    if ($x == 0 & abs($y) < 10*$eps) return;
-    if ($y == 0 & abs($x) < 10*$eps) return;
-    if (abs($x-$y) > 10 * $eps * max(abs($x),abs($y)))
-      return false;
-    else
-      return true;
+	$eps = pow(2.0,-52.0);
+	if ($x == 0 & abs($y) < 10*$eps) return;
+	if ($y == 0 & abs($x) < 10*$eps) return;
+	if (abs($x-$y) > 10 * $eps * max(abs($x),abs($y)))
+	  return false;
+	else
+	  return true;
   }
 
   /**
-  * Check norm of difference of "vectors".
-  * @param float $x[]
-  * @param float $y[]
-  */
+   * Check norm of difference of "vectors".
+   * @param float $x[]
+   * @param float $y[]
+   */
   function checkVectors($x, $y) {
-    $nx = count($x);
-    $ny = count($y);
-    if ($nx == $ny)
-      for($i=0; $i < $nx; ++$i)
-        $this->checkScalars($x[$i],$y[$i]);
-    else
-      die("Attempt to compare vectors of different lengths");
+	$nx = count($x);
+	$ny = count($y);
+	if ($nx == $ny)
+	  for($i=0; $i < $nx; ++$i)
+		$this->checkScalars($x[$i],$y[$i]);
+	else
+	  die("Attempt to compare vectors of different lengths");
   }
 
   /**
-  * Check norm of difference of "arrays".
-  * @param float $x[][]
-  * @param float $y[][]
-  */
+   * Check norm of difference of "arrays".
+   * @param float $x[][]
+   * @param float $y[][]
+   */
   function checkArrays($x, $y) {
-    $A = new Matrix($x);
-    $B = new Matrix($y);
-    return $this->checkMatrices($A,$B);
+	$A = new Matrix($x);
+	$B = new Matrix($y);
+	return $this->checkMatrices($A,$B);
   }
 
   /**
-  * Check norm of difference of "matrices".
-  * @param matrix $X
-  * @param matrix $Y
-  */
+   * Check norm of difference of "matrices".
+   * @param matrix $X
+   * @param matrix $Y
+   */
   function checkMatrices($X = null, $Y = null) {
-    if( $X == null || $Y == null )
-      return false;
+	if( $X == null || $Y == null )
+	  return false;
 
-    $eps = pow(2.0,-52.0);
-    if ($X->norm1() == 0. & $Y->norm1() < 10*$eps) return true;
-    if ($Y->norm1() == 0. & $X->norm1() < 10*$eps) return true;
+	$eps = pow(2.0,-52.0);
+	if ($X->norm1() == 0. & $Y->norm1() < 10*$eps) return true;
+	if ($Y->norm1() == 0. & $X->norm1() < 10*$eps) return true;
 
-    $A = $X->minus($Y);
+	$A = $X->minus($Y);
 
-    if ($A->norm1() > 1000 * $eps * max($X->norm1(),$Y->norm1()))
-      die("The norm of (X-Y) is too large: ".$A->norm1());
-    else
-      return true;
+	if ($A->norm1() > 1000 * $eps * max($X->norm1(),$Y->norm1()))
+	  die("The norm of (X-Y) is too large: ".$A->norm1());
+	else
+	  return true;
   }
 
 }

Spacing +94 added lines, -94 removed lines

@@ -10,19 +10,19 @@ 
 
     $errorCount   = 0;
     $warningCount = 0;
-    $columnwise   = array(1.,2.,3.,4.,5.,6.,7.,8.,9.,10.,11.,12.);
-    $rowwise      = array(1.,4.,7.,10.,2.,5.,8.,11.,3.,6.,9.,12.);
-    $avals        = array(array(1.,4.,7.,10.),array(2.,5.,8.,11.),array(3.,6.,9.,12.));
+    $columnwise   = array(1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.);
+    $rowwise      = array(1., 4., 7., 10., 2., 5., 8., 11., 3., 6., 9., 12.);
+    $avals        = array(array(1., 4., 7., 10.), array(2., 5., 8., 11.), array(3., 6., 9., 12.));
     $rankdef      = $avals;
-    $tvals        = array(array(1.,2.,3.),array(4.,5.,6.),array(7.,8.,9.),array(10.,11.,12.));
-    $subavals     = array(array(5.,8.,11.),array(6.,9.,12.));
-    $rvals        = array(array(1.,4.,7.),array(2.,5.,8.,11.),array(3.,6.,9.,12.));
-    $pvals        = array(array(1.,1.,1.),array(1.,2.,3.),array(1.,3.,6.));
-    $ivals        = array(array(1.,0.,0.,0.),array(0.,1.,0.,0.),array(0.,0.,1.,0.));
-    $evals        = array(array(0.,1.,0.,0.),array(1.,0.,2.e-7,0.),array(0.,-2.e-7,0.,1.),array(0.,0.,1.,0.));
-    $square       = array(array(166.,188.,210.),array(188.,214.,240.),array(210.,240.,270.));
-    $sqSolution   = array(array(13.),array(15.));
-    $condmat      = array(array(1.,3.),array(7.,9.));
+    $tvals        = array(array(1., 2., 3.), array(4., 5., 6.), array(7., 8., 9.), array(10., 11., 12.));
+    $subavals     = array(array(5., 8., 11.), array(6., 9., 12.));
+    $rvals        = array(array(1., 4., 7.), array(2., 5., 8., 11.), array(3., 6., 9., 12.));
+    $pvals        = array(array(1., 1., 1.), array(1., 2., 3.), array(1., 3., 6.));
+    $ivals        = array(array(1., 0., 0., 0.), array(0., 1., 0., 0.), array(0., 0., 1., 0.));
+    $evals        = array(array(0., 1., 0., 0.), array(1., 0., 2.e-7, 0.), array(0., -2.e-7, 0., 1.), array(0., 0., 1., 0.));
+    $square       = array(array(166., 188., 210.), array(188., 214., 240.), array(210., 240., 270.));
+    $sqSolution   = array(array(13.), array(15.));
+    $condmat      = array(array(1., 3.), array(7., 9.));
     $rows         = 3;
     $cols         = 4;
     $invalidID    = 5; /* should trigger bad shape for construction with val        */
@@ -34,10 +34,10 @@ 
     $ie           = 2;
     $jb           = 1;
     $je           = 3;
-    $rowindexset       = array(1,2);
-    $badrowindexset    = array(1,3);
-    $columnindexset    = array(1,2,3);
-    $badcolumnindexset = array(1,2,4);
+    $rowindexset       = array(1, 2);
+    $badrowindexset    = array(1, 3);
+    $columnindexset    = array(1, 2, 3);
+    $badcolumnindexset = array(1, 2, 4);
     $columnsummax      = 33.;
     $rowsummax         = 30.;
     $sumofdiagonals    = 15;
@@ -62,37 +62,37 @@ 
     echo "<p>Testing constructors and constructor-like methods...</p>";
 
     $A = new Matrix($columnwise, 3);
-    if($A instanceof Matrix) {
+    if ($A instanceof Matrix) {
       $this->try_success("Column-packed constructor...");
     } else
       $errorCount = $this->try_failure($errorCount, "Column-packed constructor...", "Unable to construct Matrix");
 
     $T = new Matrix($tvals);
-    if($T instanceof Matrix)
+    if ($T instanceof Matrix)
       $this->try_success("2D array constructor...");
     else
       $errorCount = $this->try_failure($errorCount, "2D array constructor...", "Unable to construct Matrix");
 
     $A = new Matrix($columnwise, $validID);
     $B = new Matrix($avals);
-    $tmp = $B->get(0,0);
+    $tmp = $B->get(0, 0);
     $avals[0][0] = 0.0;
     $C = $B->minus($A);
     $avals[0][0] = $tmp;
     $B = Matrix::constructWithCopy($avals);
-    $tmp = $B->get(0,0);
+    $tmp = $B->get(0, 0);
     $avals[0][0] = 0.0;
     /** check that constructWithCopy behaves properly **/
-    if ( ( $tmp - $B->get(0,0) ) != 0.0 )
-      $errorCount = $this->try_failure($errorCount,"constructWithCopy... ","copy not effected... data visible outside");
+    if (($tmp - $B->get(0, 0)) != 0.0)
+      $errorCount = $this->try_failure($errorCount, "constructWithCopy... ", "copy not effected... data visible outside");
     else
-      $this->try_success("constructWithCopy... ","");
+      $this->try_success("constructWithCopy... ", "");
 
     $I = new Matrix($ivals);
-    if ( $this->checkMatrices($I,Matrix::identity(3,4)) )
-      $this->try_success("identity... ","");
+    if ($this->checkMatrices($I, Matrix::identity(3, 4)))
+      $this->try_success("identity... ", "");
     else
-      $errorCount = $this->try_failure($errorCount,"identity... ","identity Matrix not successfully created");
+      $errorCount = $this->try_failure($errorCount, "identity... ", "identity Matrix not successfully created");
 
     /**
     * Access Methods:
@@ -117,30 +117,30 @@ 
     print "<p>Testing access methods...</p>";
 
 	$B = new Matrix($avals);
-	if($B->getRowDimension() == $rows)
+	if ($B->getRowDimension() == $rows)
 	  $this->try_success("getRowDimension...");
 	else
 	  $errorCount = $this->try_failure($errorCount, "getRowDimension...");
 
-	if($B->getColumnDimension() == $cols)
+	if ($B->getColumnDimension() == $cols)
 	  $this->try_success("getColumnDimension...");
 	else
 	  $errorCount = $this->try_failure($errorCount, "getColumnDimension...");
 
 	$barray = $B->getArray();
-	if($this->checkArrays($barray, $avals))
+	if ($this->checkArrays($barray, $avals))
 	  $this->try_success("getArray...");
 	else
 	  $errorCount = $this->try_failure($errorCount, "getArray...");
 
 	$bpacked = $B->getColumnPackedCopy();
-	if($this->checkArrays($bpacked, $columnwise))
+	if ($this->checkArrays($bpacked, $columnwise))
 	  $this->try_success("getColumnPackedCopy...");
 	else
 	  $errorCount = $this->try_failure($errorCount, "getColumnPackedCopy...");
 
 	$bpacked = $B->getRowPackedCopy();
-	if($this->checkArrays($bpacked, $rowwise))
+	if ($this->checkArrays($bpacked, $rowwise))
 	  $this->try_success("getRowPackedCopy...");
 	else
 	  $errorCount = $this->try_failure($errorCount, "getRowPackedCopy...");
@@ -177,38 +177,38 @@ 
     echo "<p>Testing linear algebra methods...<p>";
 
     $A = new Matrix($columnwise, 3);
-    if( $this->checkMatrices($A->transpose(), $T) )
+    if ($this->checkMatrices($A->transpose(), $T))
       $this->try_success("Transpose check...");
     else
       $errorCount = $this->try_failure($errorCount, "Transpose check...", "Matrices are not equal");
 
-    if($this->checkScalars($A->norm1(), $columnsummax))
+    if ($this->checkScalars($A->norm1(), $columnsummax))
       $this->try_success("Maximum column sum...");
     else
-      $errorCount = $this->try_failure($errorCount, "Maximum column sum...", "Incorrect: " . $A->norm1() . " != " . $columnsummax);
+      $errorCount = $this->try_failure($errorCount, "Maximum column sum...", "Incorrect: ".$A->norm1()." != ".$columnsummax);
 
-    if($this->checkScalars($A->normInf(), $rowsummax))
+    if ($this->checkScalars($A->normInf(), $rowsummax))
       $this->try_success("Maximum row sum...");
     else
-      $errorCount = $this->try_failure($errorCount, "Maximum row sum...", "Incorrect: " . $A->normInf() . " != " . $rowsummax );
+      $errorCount = $this->try_failure($errorCount, "Maximum row sum...", "Incorrect: ".$A->normInf()." != ".$rowsummax);
 
-    if($this->checkScalars($A->normF(), sqrt($sumofsquares)))
+    if ($this->checkScalars($A->normF(), sqrt($sumofsquares)))
       $this->try_success("Frobenius norm...");
     else
-      $errorCount = $this->try_failure($errorCount, "Frobenius norm...", "Incorrect:" . $A->normF() . " != " . sqrt($sumofsquares));
+      $errorCount = $this->try_failure($errorCount, "Frobenius norm...", "Incorrect:".$A->normF()." != ".sqrt($sumofsquares));
 
-    if($this->checkScalars($A->trace(), $sumofdiagonals))
+    if ($this->checkScalars($A->trace(), $sumofdiagonals))
       $this->try_success("Matrix trace...");
     else
-      $errorCount = $this->try_failure($errorCount, "Matrix trace...", "Incorrect: " . $A->trace() . " != " . $sumofdiagonals);
+      $errorCount = $this->try_failure($errorCount, "Matrix trace...", "Incorrect: ".$A->trace()." != ".$sumofdiagonals);
 
     $B = $A->getMatrix(0, $A->getRowDimension(), 0, $A->getRowDimension());
-    if( $B->det() == 0 )
+    if ($B->det() == 0)
       $this->try_success("Matrix determinant...");
     else
-      $errorCount = $this->try_failure($errorCount, "Matrix determinant...", "Incorrect: " . $B->det() . " != " . 0);
+      $errorCount = $this->try_failure($errorCount, "Matrix determinant...", "Incorrect: ".$B->det()." != ".0);
 
-    $A = new Matrix($columnwise,3);
+    $A = new Matrix($columnwise, 3);
     $SQ = new Matrix($square);
     if ($this->checkMatrices($SQ, $A->times($A->transpose())))
       $this->try_success("times(Matrix)...");
@@ -223,10 +223,10 @@ 
     $QR = $A->qr();
     $R = $QR->getR();
     $Q = $QR->getQ();
-    if($this->checkMatrices($A, $Q->times($R)))
-      $this->try_success("QRDecomposition...","");
+    if ($this->checkMatrices($A, $Q->times($R)))
+      $this->try_success("QRDecomposition...", "");
     else
-      $errorCount = $this->try_failure($errorCount,"QRDecomposition...","incorrect qr decomposition calculation");
+      $errorCount = $this->try_failure($errorCount, "QRDecomposition...", "incorrect qr decomposition calculation");
 
     $A = new Matrix($columnwise, 4);
     $SVD = $A->svd();
@@ -234,29 +234,29 @@ 
     $S = $SVD->getS();
     $V = $SVD->getV();
     if ($this->checkMatrices($A, $U->times($S->times($V->transpose()))))
-      $this->try_success("SingularValueDecomposition...","");
+      $this->try_success("SingularValueDecomposition...", "");
     else
-      $errorCount = $this->try_failure($errorCount,"SingularValueDecomposition...","incorrect singular value decomposition calculation");
+      $errorCount = $this->try_failure($errorCount, "SingularValueDecomposition...", "incorrect singular value decomposition calculation");
 
     $n = $A->getColumnDimension();
-    $A = $A->getMatrix(0,$n-1,0,$n-1);
-    $A->set(0,0,0.);
+    $A = $A->getMatrix(0, $n - 1, 0, $n - 1);
+    $A->set(0, 0, 0.);
 
     $LU = $A->lu();
     $L  = $LU->getL();
-    if ( $this->checkMatrices($A->getMatrix($LU->getPivot(),0,$n-1), $L->times($LU->getU())) )
-      $this->try_success("LUDecomposition...","");
+    if ($this->checkMatrices($A->getMatrix($LU->getPivot(), 0, $n - 1), $L->times($LU->getU())))
+      $this->try_success("LUDecomposition...", "");
     else
-      $errorCount = $this->try_failure($errorCount,"LUDecomposition...","incorrect LU decomposition calculation");
+      $errorCount = $this->try_failure($errorCount, "LUDecomposition...", "incorrect LU decomposition calculation");
 
     $X = $A->inverse();
-    if ( $this->checkMatrices($A->times($X),Matrix::identity(3,3)) )
-       $this->try_success("inverse()...","");
+    if ($this->checkMatrices($A->times($X), Matrix::identity(3, 3)))
+       $this->try_success("inverse()...", "");
      else
-       $errorCount = $this->try_failure($errorCount, "inverse()...","incorrect inverse calculation");
+       $errorCount = $this->try_failure($errorCount, "inverse()...", "incorrect inverse calculation");
 
     $DEF = new Matrix($rankdef);
-    if($this->checkScalars($DEF->rank(), min($DEF->getRowDimension(), $DEF->getColumnDimension())-1))
+    if ($this->checkScalars($DEF->rank(), min($DEF->getRowDimension(), $DEF->getColumnDimension()) - 1))
       $this->try_success("Rank...");
     else
       $this->try_failure("Rank...", "incorrect rank calculation");
@@ -264,50 +264,50 @@ 
     $B = new Matrix($condmat);
     $SVD = $B->svd();
     $singularvalues = $SVD->getSingularValues();
-    if($this->checkScalars($B->cond(), $singularvalues[0]/$singularvalues[min($B->getRowDimension(), $B->getColumnDimension())-1]))
+    if ($this->checkScalars($B->cond(), $singularvalues[0] / $singularvalues[min($B->getRowDimension(), $B->getColumnDimension()) - 1]))
       $this->try_success("Condition number...");
     else
       $this->try_failure("Condition number...", "incorrect condition number calculation");
 
     $SUB = new Matrix($subavals);
-    $O   = new Matrix($SUB->getRowDimension(),1,1.0);
+    $O   = new Matrix($SUB->getRowDimension(), 1, 1.0);
     $SOL = new Matrix($sqSolution);
-    $SQ = $SUB->getMatrix(0,$SUB->getRowDimension()-1,0,$SUB->getRowDimension()-1);
-    if ( $this->checkMatrices($SQ->solve($SOL),$O) )
-      $this->try_success("solve()...","");
+    $SQ = $SUB->getMatrix(0, $SUB->getRowDimension() - 1, 0, $SUB->getRowDimension() - 1);
+    if ($this->checkMatrices($SQ->solve($SOL), $O))
+      $this->try_success("solve()...", "");
     else
-     $errorCount = $this->try_failure($errorCount,"solve()...","incorrect lu solve calculation");
+     $errorCount = $this->try_failure($errorCount, "solve()...", "incorrect lu solve calculation");
 
     $A = new Matrix($pvals);
     $Chol = $A->chol();
     $L = $Chol->getL();
-    if ( $this->checkMatrices($A, $L->times($L->transpose())) )
-      $this->try_success("CholeskyDecomposition...","");
+    if ($this->checkMatrices($A, $L->times($L->transpose())))
+      $this->try_success("CholeskyDecomposition...", "");
     else
-      $errorCount = $this->try_failure($errorCount,"CholeskyDecomposition...","incorrect Cholesky decomposition calculation");
+      $errorCount = $this->try_failure($errorCount, "CholeskyDecomposition...", "incorrect Cholesky decomposition calculation");
 
-    $X = $Chol->solve(Matrix::identity(3,3));
-    if ( $this->checkMatrices($A->times($X), Matrix::identity(3,3)) )
-      $this->try_success("CholeskyDecomposition solve()...","");
+    $X = $Chol->solve(Matrix::identity(3, 3));
+    if ($this->checkMatrices($A->times($X), Matrix::identity(3, 3)))
+      $this->try_success("CholeskyDecomposition solve()...", "");
     else
-      $errorCount = $this->try_failure($errorCount,"CholeskyDecomposition solve()...","incorrect Choleskydecomposition solve calculation");
+      $errorCount = $this->try_failure($errorCount, "CholeskyDecomposition solve()...", "incorrect Choleskydecomposition solve calculation");
 
     $Eig = $A->eig();
     $D = $Eig->getD();
     $V = $Eig->getV();
-    if( $this->checkMatrices($A->times($V),$V->times($D)) )
-      $this->try_success("EigenvalueDecomposition (symmetric)...","");
+    if ($this->checkMatrices($A->times($V), $V->times($D)))
+      $this->try_success("EigenvalueDecomposition (symmetric)...", "");
     else
-      $errorCount = $this->try_failure($errorCount,"EigenvalueDecomposition (symmetric)...","incorrect symmetric Eigenvalue decomposition calculation");
+      $errorCount = $this->try_failure($errorCount, "EigenvalueDecomposition (symmetric)...", "incorrect symmetric Eigenvalue decomposition calculation");
 
     $A = new Matrix($evals);
     $Eig = $A->eig();
     $D = $Eig->getD();
     $V = $Eig->getV();
-    if ( $this->checkMatrices($A->times($V),$V->times($D)) )
-      $this->try_success("EigenvalueDecomposition (nonsymmetric)...","");
+    if ($this->checkMatrices($A->times($V), $V->times($D)))
+      $this->try_success("EigenvalueDecomposition (nonsymmetric)...", "");
     else
-      $errorCount = $this->try_failure($errorCount,"EigenvalueDecomposition (nonsymmetric)...","incorrect nonsymmetric Eigenvalue decomposition calculation");
+      $errorCount = $this->try_failure($errorCount, "EigenvalueDecomposition (nonsymmetric)...", "incorrect nonsymmetric Eigenvalue decomposition calculation");
 
 	print("<b>{$errorCount} total errors</b>.");
   }
@@ -318,9 +318,9 @@ 
   * @param string $e
   */
   function try_success($s, $e = "") {
-    print "> ". $s ."success<br />";
+    print "> ".$s."success<br />";
     if ($e != "")
-      print "> Message: ". $e ."<br />";
+      print "> Message: ".$e."<br />";
   }
 
   /**
@@ -330,8 +330,8 @@ 
   * @param string $e
   * @return int incremented counter
   */
-  function try_failure($count, $s, $e="") {
-    print "> ". $s ."*** failure ***<br />> Message: ". $e ."<br />";
+  function try_failure($count, $s, $e = "") {
+    print "> ".$s."*** failure ***<br />> Message: ".$e."<br />";
     return ++$count;
   }
 
@@ -342,8 +342,8 @@ 
   * @param string $e
   * @return int incremented counter
   */
-  function try_warning($count, $s, $e="") {
-    print "> ". $s ."*** warning ***<br />> Message: ". $e ."<br />";
+  function try_warning($count, $s, $e = "") {
+    print "> ".$s."*** warning ***<br />> Message: ".$e."<br />";
     return ++$count;
   }
 
@@ -353,10 +353,10 @@ 
   * @param float $y
   */
   function checkScalars($x, $y) {
-    $eps = pow(2.0,-52.0);
-    if ($x == 0 & abs($y) < 10*$eps) return;
-    if ($y == 0 & abs($x) < 10*$eps) return;
-    if (abs($x-$y) > 10 * $eps * max(abs($x),abs($y)))
+    $eps = pow(2.0, -52.0);
+    if ($x == 0 & abs($y) < 10 * $eps) return;
+    if ($y == 0 & abs($x) < 10 * $eps) return;
+    if (abs($x - $y) > 10 * $eps * max(abs($x), abs($y)))
       return false;
     else
       return true;
@@ -371,8 +371,8 @@ 
     $nx = count($x);
     $ny = count($y);
     if ($nx == $ny)
-      for($i=0; $i < $nx; ++$i)
-        $this->checkScalars($x[$i],$y[$i]);
+      for ($i = 0; $i < $nx; ++$i)
+        $this->checkScalars($x[$i], $y[$i]);
     else
       die("Attempt to compare vectors of different lengths");
   }
@@ -385,7 +385,7 @@ 
   function checkArrays($x, $y) {
     $A = new Matrix($x);
     $B = new Matrix($y);
-    return $this->checkMatrices($A,$B);
+    return $this->checkMatrices($A, $B);
   }
 
   /**
@@ -394,16 +394,16 @@ 
   * @param matrix $Y
   */
   function checkMatrices($X = null, $Y = null) {
-    if( $X == null || $Y == null )
+    if ($X == null || $Y == null)
       return false;
 
-    $eps = pow(2.0,-52.0);
-    if ($X->norm1() == 0. & $Y->norm1() < 10*$eps) return true;
-    if ($Y->norm1() == 0. & $X->norm1() < 10*$eps) return true;
+    $eps = pow(2.0, -52.0);
+    if ($X->norm1() == 0. & $Y->norm1() < 10 * $eps) return true;
+    if ($Y->norm1() == 0. & $X->norm1() < 10 * $eps) return true;
 
     $A = $X->minus($Y);
 
-    if ($A->norm1() > 1000 * $eps * max($X->norm1(),$Y->norm1()))
+    if ($A->norm1() > 1000 * $eps * max($X->norm1(), $Y->norm1()))
       die("The norm of (X-Y) is too large: ".$A->norm1());
     else
       return true;

Braces +173 added lines, -131 removed lines

@@ -64,14 +64,16 @@ 
     $A = new Matrix($columnwise, 3);
     if($A instanceof Matrix) {
       $this->try_success("Column-packed constructor...");
-    } else
-      $errorCount = $this->try_failure($errorCount, "Column-packed constructor...", "Unable to construct Matrix");
+    } else {
+          $errorCount = $this->try_failure($errorCount, "Column-packed constructor...", "Unable to construct Matrix");
+    }
 
     $T = new Matrix($tvals);
-    if($T instanceof Matrix)
-      $this->try_success("2D array constructor...");
-    else
-      $errorCount = $this->try_failure($errorCount, "2D array constructor...", "Unable to construct Matrix");
+    if($T instanceof Matrix) {
+          $this->try_success("2D array constructor...");
+    } else {
+          $errorCount = $this->try_failure($errorCount, "2D array constructor...", "Unable to construct Matrix");
+    }
 
     $A = new Matrix($columnwise, $validID);
     $B = new Matrix($avals);
@@ -83,16 +85,18 @@ 
     $tmp = $B->get(0,0);
     $avals[0][0] = 0.0;
     /** check that constructWithCopy behaves properly **/
-    if ( ( $tmp - $B->get(0,0) ) != 0.0 )
-      $errorCount = $this->try_failure($errorCount,"constructWithCopy... ","copy not effected... data visible outside");
-    else
-      $this->try_success("constructWithCopy... ","");
+    if ( ( $tmp - $B->get(0,0) ) != 0.0 ) {
+          $errorCount = $this->try_failure($errorCount,"constructWithCopy... ","copy not effected... data visible outside");
+    } else {
+          $this->try_success("constructWithCopy... ","");
+    }
 
     $I = new Matrix($ivals);
-    if ( $this->checkMatrices($I,Matrix::identity(3,4)) )
-      $this->try_success("identity... ","");
-    else
-      $errorCount = $this->try_failure($errorCount,"identity... ","identity Matrix not successfully created");
+    if ( $this->checkMatrices($I,Matrix::identity(3,4)) ) {
+          $this->try_success("identity... ","");
+    } else {
+          $errorCount = $this->try_failure($errorCount,"identity... ","identity Matrix not successfully created");
+    }
 
     /**
     * Access Methods:
@@ -117,33 +121,38 @@ 
     print "<p>Testing access methods...</p>";
 
 	$B = new Matrix($avals);
-	if($B->getRowDimension() == $rows)
-	  $this->try_success("getRowDimension...");
-	else
-	  $errorCount = $this->try_failure($errorCount, "getRowDimension...");
-
-	if($B->getColumnDimension() == $cols)
-	  $this->try_success("getColumnDimension...");
-	else
-	  $errorCount = $this->try_failure($errorCount, "getColumnDimension...");
+	if($B->getRowDimension() == $rows) {
+		  $this->try_success("getRowDimension...");
+	} else {
+		  $errorCount = $this->try_failure($errorCount, "getRowDimension...");
+	}
+
+	if($B->getColumnDimension() == $cols) {
+		  $this->try_success("getColumnDimension...");
+	} else {
+		  $errorCount = $this->try_failure($errorCount, "getColumnDimension...");
+	}
 
 	$barray = $B->getArray();
-	if($this->checkArrays($barray, $avals))
-	  $this->try_success("getArray...");
-	else
-	  $errorCount = $this->try_failure($errorCount, "getArray...");
+	if($this->checkArrays($barray, $avals)) {
+		  $this->try_success("getArray...");
+	} else {
+		  $errorCount = $this->try_failure($errorCount, "getArray...");
+	}
 
 	$bpacked = $B->getColumnPackedCopy();
-	if($this->checkArrays($bpacked, $columnwise))
-	  $this->try_success("getColumnPackedCopy...");
-	else
-	  $errorCount = $this->try_failure($errorCount, "getColumnPackedCopy...");
+	if($this->checkArrays($bpacked, $columnwise)) {
+		  $this->try_success("getColumnPackedCopy...");
+	} else {
+		  $errorCount = $this->try_failure($errorCount, "getColumnPackedCopy...");
+	}
 
 	$bpacked = $B->getRowPackedCopy();
-	if($this->checkArrays($bpacked, $rowwise))
-	  $this->try_success("getRowPackedCopy...");
-	else
-	  $errorCount = $this->try_failure($errorCount, "getRowPackedCopy...");
+	if($this->checkArrays($bpacked, $rowwise)) {
+		  $this->try_success("getRowPackedCopy...");
+	} else {
+		  $errorCount = $this->try_failure($errorCount, "getRowPackedCopy...");
+	}
 
     /**
     * Array-like methods:
@@ -177,42 +186,48 @@ 
     echo "<p>Testing linear algebra methods...<p>";
 
     $A = new Matrix($columnwise, 3);
-    if( $this->checkMatrices($A->transpose(), $T) )
-      $this->try_success("Transpose check...");
-    else
-      $errorCount = $this->try_failure($errorCount, "Transpose check...", "Matrices are not equal");
-
-    if($this->checkScalars($A->norm1(), $columnsummax))
-      $this->try_success("Maximum column sum...");
-    else
-      $errorCount = $this->try_failure($errorCount, "Maximum column sum...", "Incorrect: " . $A->norm1() . " != " . $columnsummax);
-
-    if($this->checkScalars($A->normInf(), $rowsummax))
-      $this->try_success("Maximum row sum...");
-    else
-      $errorCount = $this->try_failure($errorCount, "Maximum row sum...", "Incorrect: " . $A->normInf() . " != " . $rowsummax );
-
-    if($this->checkScalars($A->normF(), sqrt($sumofsquares)))
-      $this->try_success("Frobenius norm...");
-    else
-      $errorCount = $this->try_failure($errorCount, "Frobenius norm...", "Incorrect:" . $A->normF() . " != " . sqrt($sumofsquares));
-
-    if($this->checkScalars($A->trace(), $sumofdiagonals))
-      $this->try_success("Matrix trace...");
-    else
-      $errorCount = $this->try_failure($errorCount, "Matrix trace...", "Incorrect: " . $A->trace() . " != " . $sumofdiagonals);
+    if( $this->checkMatrices($A->transpose(), $T) ) {
+          $this->try_success("Transpose check...");
+    } else {
+          $errorCount = $this->try_failure($errorCount, "Transpose check...", "Matrices are not equal");
+    }
+
+    if($this->checkScalars($A->norm1(), $columnsummax)) {
+          $this->try_success("Maximum column sum...");
+    } else {
+          $errorCount = $this->try_failure($errorCount, "Maximum column sum...", "Incorrect: " . $A->norm1() . " != " . $columnsummax);
+    }
+
+    if($this->checkScalars($A->normInf(), $rowsummax)) {
+          $this->try_success("Maximum row sum...");
+    } else {
+          $errorCount = $this->try_failure($errorCount, "Maximum row sum...", "Incorrect: " . $A->normInf() . " != " . $rowsummax );
+    }
+
+    if($this->checkScalars($A->normF(), sqrt($sumofsquares))) {
+          $this->try_success("Frobenius norm...");
+    } else {
+          $errorCount = $this->try_failure($errorCount, "Frobenius norm...", "Incorrect:" . $A->normF() . " != " . sqrt($sumofsquares));
+    }
+
+    if($this->checkScalars($A->trace(), $sumofdiagonals)) {
+          $this->try_success("Matrix trace...");
+    } else {
+          $errorCount = $this->try_failure($errorCount, "Matrix trace...", "Incorrect: " . $A->trace() . " != " . $sumofdiagonals);
+    }
 
     $B = $A->getMatrix(0, $A->getRowDimension(), 0, $A->getRowDimension());
-    if( $B->det() == 0 )
-      $this->try_success("Matrix determinant...");
-    else
-      $errorCount = $this->try_failure($errorCount, "Matrix determinant...", "Incorrect: " . $B->det() . " != " . 0);
+    if( $B->det() == 0 ) {
+          $this->try_success("Matrix determinant...");
+    } else {
+          $errorCount = $this->try_failure($errorCount, "Matrix determinant...", "Incorrect: " . $B->det() . " != " . 0);
+    }
 
     $A = new Matrix($columnwise,3);
     $SQ = new Matrix($square);
-    if ($this->checkMatrices($SQ, $A->times($A->transpose())))
-      $this->try_success("times(Matrix)...");
-    else {
+    if ($this->checkMatrices($SQ, $A->times($A->transpose()))) {
+          $this->try_success("times(Matrix)...");
+    } else {
       $errorCount = $this->try_failure($errorCount, "times(Matrix)...", "Unable to multiply matrices");
       $SQ->toHTML();
       $AT->toHTML();
@@ -223,20 +238,22 @@ 
     $QR = $A->qr();
     $R = $QR->getR();
     $Q = $QR->getQ();
-    if($this->checkMatrices($A, $Q->times($R)))
-      $this->try_success("QRDecomposition...","");
-    else
-      $errorCount = $this->try_failure($errorCount,"QRDecomposition...","incorrect qr decomposition calculation");
+    if($this->checkMatrices($A, $Q->times($R))) {
+          $this->try_success("QRDecomposition...","");
+    } else {
+          $errorCount = $this->try_failure($errorCount,"QRDecomposition...","incorrect qr decomposition calculation");
+    }
 
     $A = new Matrix($columnwise, 4);
     $SVD = $A->svd();
     $U = $SVD->getU();
     $S = $SVD->getS();
     $V = $SVD->getV();
-    if ($this->checkMatrices($A, $U->times($S->times($V->transpose()))))
-      $this->try_success("SingularValueDecomposition...","");
-    else
-      $errorCount = $this->try_failure($errorCount,"SingularValueDecomposition...","incorrect singular value decomposition calculation");
+    if ($this->checkMatrices($A, $U->times($S->times($V->transpose())))) {
+          $this->try_success("SingularValueDecomposition...","");
+    } else {
+          $errorCount = $this->try_failure($errorCount,"SingularValueDecomposition...","incorrect singular value decomposition calculation");
+    }
 
     $n = $A->getColumnDimension();
     $A = $A->getMatrix(0,$n-1,0,$n-1);
@@ -244,70 +261,79 @@ 
 
     $LU = $A->lu();
     $L  = $LU->getL();
-    if ( $this->checkMatrices($A->getMatrix($LU->getPivot(),0,$n-1), $L->times($LU->getU())) )
-      $this->try_success("LUDecomposition...","");
-    else
-      $errorCount = $this->try_failure($errorCount,"LUDecomposition...","incorrect LU decomposition calculation");
+    if ( $this->checkMatrices($A->getMatrix($LU->getPivot(),0,$n-1), $L->times($LU->getU())) ) {
+          $this->try_success("LUDecomposition...","");
+    } else {
+          $errorCount = $this->try_failure($errorCount,"LUDecomposition...","incorrect LU decomposition calculation");
+    }
 
     $X = $A->inverse();
-    if ( $this->checkMatrices($A->times($X),Matrix::identity(3,3)) )
-       $this->try_success("inverse()...","");
-     else
-       $errorCount = $this->try_failure($errorCount, "inverse()...","incorrect inverse calculation");
+    if ( $this->checkMatrices($A->times($X),Matrix::identity(3,3)) ) {
+           $this->try_success("inverse()...","");
+    } else {
+            $errorCount = $this->try_failure($errorCount, "inverse()...","incorrect inverse calculation");
+     }
 
     $DEF = new Matrix($rankdef);
-    if($this->checkScalars($DEF->rank(), min($DEF->getRowDimension(), $DEF->getColumnDimension())-1))
-      $this->try_success("Rank...");
-    else
-      $this->try_failure("Rank...", "incorrect rank calculation");
+    if($this->checkScalars($DEF->rank(), min($DEF->getRowDimension(), $DEF->getColumnDimension())-1)) {
+          $this->try_success("Rank...");
+    } else {
+          $this->try_failure("Rank...", "incorrect rank calculation");
+    }
 
     $B = new Matrix($condmat);
     $SVD = $B->svd();
     $singularvalues = $SVD->getSingularValues();
-    if($this->checkScalars($B->cond(), $singularvalues[0]/$singularvalues[min($B->getRowDimension(), $B->getColumnDimension())-1]))
-      $this->try_success("Condition number...");
-    else
-      $this->try_failure("Condition number...", "incorrect condition number calculation");
+    if($this->checkScalars($B->cond(), $singularvalues[0]/$singularvalues[min($B->getRowDimension(), $B->getColumnDimension())-1])) {
+          $this->try_success("Condition number...");
+    } else {
+          $this->try_failure("Condition number...", "incorrect condition number calculation");
+    }
 
     $SUB = new Matrix($subavals);
     $O   = new Matrix($SUB->getRowDimension(),1,1.0);
     $SOL = new Matrix($sqSolution);
     $SQ = $SUB->getMatrix(0,$SUB->getRowDimension()-1,0,$SUB->getRowDimension()-1);
-    if ( $this->checkMatrices($SQ->solve($SOL),$O) )
-      $this->try_success("solve()...","");
-    else
-     $errorCount = $this->try_failure($errorCount,"solve()...","incorrect lu solve calculation");
+    if ( $this->checkMatrices($SQ->solve($SOL),$O) ) {
+          $this->try_success("solve()...","");
+    } else {
+         $errorCount = $this->try_failure($errorCount,"solve()...","incorrect lu solve calculation");
+    }
 
     $A = new Matrix($pvals);
     $Chol = $A->chol();
     $L = $Chol->getL();
-    if ( $this->checkMatrices($A, $L->times($L->transpose())) )
-      $this->try_success("CholeskyDecomposition...","");
-    else
-      $errorCount = $this->try_failure($errorCount,"CholeskyDecomposition...","incorrect Cholesky decomposition calculation");
+    if ( $this->checkMatrices($A, $L->times($L->transpose())) ) {
+          $this->try_success("CholeskyDecomposition...","");
+    } else {
+          $errorCount = $this->try_failure($errorCount,"CholeskyDecomposition...","incorrect Cholesky decomposition calculation");
+    }
 
     $X = $Chol->solve(Matrix::identity(3,3));
-    if ( $this->checkMatrices($A->times($X), Matrix::identity(3,3)) )
-      $this->try_success("CholeskyDecomposition solve()...","");
-    else
-      $errorCount = $this->try_failure($errorCount,"CholeskyDecomposition solve()...","incorrect Choleskydecomposition solve calculation");
+    if ( $this->checkMatrices($A->times($X), Matrix::identity(3,3)) ) {
+          $this->try_success("CholeskyDecomposition solve()...","");
+    } else {
+          $errorCount = $this->try_failure($errorCount,"CholeskyDecomposition solve()...","incorrect Choleskydecomposition solve calculation");
+    }
 
     $Eig = $A->eig();
     $D = $Eig->getD();
     $V = $Eig->getV();
-    if( $this->checkMatrices($A->times($V),$V->times($D)) )
-      $this->try_success("EigenvalueDecomposition (symmetric)...","");
-    else
-      $errorCount = $this->try_failure($errorCount,"EigenvalueDecomposition (symmetric)...","incorrect symmetric Eigenvalue decomposition calculation");
+    if( $this->checkMatrices($A->times($V),$V->times($D)) ) {
+          $this->try_success("EigenvalueDecomposition (symmetric)...","");
+    } else {
+          $errorCount = $this->try_failure($errorCount,"EigenvalueDecomposition (symmetric)...","incorrect symmetric Eigenvalue decomposition calculation");
+    }
 
     $A = new Matrix($evals);
     $Eig = $A->eig();
     $D = $Eig->getD();
     $V = $Eig->getV();
-    if ( $this->checkMatrices($A->times($V),$V->times($D)) )
-      $this->try_success("EigenvalueDecomposition (nonsymmetric)...","");
-    else
-      $errorCount = $this->try_failure($errorCount,"EigenvalueDecomposition (nonsymmetric)...","incorrect nonsymmetric Eigenvalue decomposition calculation");
+    if ( $this->checkMatrices($A->times($V),$V->times($D)) ) {
+          $this->try_success("EigenvalueDecomposition (nonsymmetric)...","");
+    } else {
+          $errorCount = $this->try_failure($errorCount,"EigenvalueDecomposition (nonsymmetric)...","incorrect nonsymmetric Eigenvalue decomposition calculation");
+    }
 
 	print("<b>{$errorCount} total errors</b>.");
   }
@@ -319,8 +345,9 @@ 
   */
   function try_success($s, $e = "") {
     print "> ". $s ."success<br />";
-    if ($e != "")
-      print "> Message: ". $e ."<br />";
+    if ($e != "") {
+          print "> Message: ". $e ."<br />";
+    }
   }
 
   /**
@@ -354,12 +381,17 @@ 
   */
   function checkScalars($x, $y) {
     $eps = pow(2.0,-52.0);
-    if ($x == 0 & abs($y) < 10*$eps) return;
-    if ($y == 0 & abs($x) < 10*$eps) return;
-    if (abs($x-$y) > 10 * $eps * max(abs($x),abs($y)))
-      return false;
-    else
-      return true;
+    if ($x == 0 & abs($y) < 10*$eps) {
+    	return;
+    }
+    if ($y == 0 & abs($x) < 10*$eps) {
+    	return;
+    }
+    if (abs($x-$y) > 10 * $eps * max(abs($x),abs($y))) {
+          return false;
+    } else {
+          return true;
+    }
   }
 
   /**
@@ -370,11 +402,15 @@ 
   function checkVectors($x, $y) {
     $nx = count($x);
     $ny = count($y);
-    if ($nx == $ny)
-      for($i=0; $i < $nx; ++$i)
-        $this->checkScalars($x[$i],$y[$i]);
-    else
-      die("Attempt to compare vectors of different lengths");
+    if ($nx == $ny) {
+          for($i=0;
+    }
+    $i < $nx; ++$i) {
+              $this->checkScalars($x[$i],$y[$i]);
+      }
+    else {
+          die("Attempt to compare vectors of different lengths");
+    }
   }
 
   /**
@@ -394,19 +430,25 @@ 
   * @param matrix $Y
   */
   function checkMatrices($X = null, $Y = null) {
-    if( $X == null || $Y == null )
-      return false;
+    if( $X == null || $Y == null ) {
+          return false;
+    }
 
     $eps = pow(2.0,-52.0);
-    if ($X->norm1() == 0. & $Y->norm1() < 10*$eps) return true;
-    if ($Y->norm1() == 0. & $X->norm1() < 10*$eps) return true;
+    if ($X->norm1() == 0. & $Y->norm1() < 10*$eps) {
+    	return true;
+    }
+    if ($Y->norm1() == 0. & $X->norm1() < 10*$eps) {
+    	return true;
+    }
 
     $A = $X->minus($Y);
 
-    if ($A->norm1() > 1000 * $eps * max($X->norm1(),$Y->norm1()))
-      die("The norm of (X-Y) is too large: ".$A->norm1());
-    else
-      return true;
+    if ($A->norm1() > 1000 * $eps * max($X->norm1(),$Y->norm1())) {
+          die("The norm of (X-Y) is too large: ".$A->norm1());
+    } else {
+          return true;
+    }
   }
 
 }

app/Vendor/PHPExcel/PHPExcel/Shared/JAMA/utils/Error.php

Doc Comments +1 added lines, -1 removed lines

@@ -65,7 +65,7 @@
 
 /**
  *	Custom error handler
- *	@param int $num Error number
+ * @return string|null
  */
 function JAMAError($errorNumber = null) {
 	global $error;

app/Vendor/PHPExcel/PHPExcel/Shared/OLE.php

Doc Comments +6 added lines, -2 removed lines

@@ -91,7 +91,7 @@ 
 	 *
 	 * @acces public
 	 * @param string $file
-	 * @return mixed true on success, PEAR_Error on failure
+	 * @return boolean true on success, PEAR_Error on failure
 	*/
 	public function read($file)
 	{
@@ -222,6 +222,7 @@ 
 	/**
 	 * Reads a signed char.
 	 * @param   resource  file handle
+	 * @param resource $fh
 	 * @return  int
 	 * @access public
 	 */
@@ -234,6 +235,7 @@ 
 	/**
 	 * Reads an unsigned short (2 octets).
 	 * @param   resource  file handle
+	 * @param resource $fh
 	 * @return  int
 	 * @access public
 	 */
@@ -246,6 +248,7 @@ 
 	/**
 	 * Reads an unsigned long (4 octets).
 	 * @param   resource  file handle
+	 * @param resource $fh
 	 * @return  int
 	 * @access public
 	 */
@@ -261,7 +264,8 @@ 
 	*
 	* @access public
 	* @param  integer  the block id of the first block
-	* @return mixed true on success, PEAR_Error on failure
+	* @param integer $blockId
+	* @return boolean true on success, PEAR_Error on failure
 	*/
 	public function _readPpsWks($blockId)
 	{

Indentation +88 added lines, -88 removed lines

@@ -47,43 +47,43 @@ 
 	/**
 	 * The file handle for reading an OLE container
 	 * @var resource
-	*/
+	 */
 	public $_file_handle;
 
 	/**
-	* Array of PPS's found on the OLE container
-	* @var array
-	*/
+	 * Array of PPS's found on the OLE container
+	 * @var array
+	 */
 	public $_list = array();
 
 	/**
 	 * Root directory of OLE container
 	 * @var OLE_PPS_Root
-	*/
+	 */
 	public $root;
 
 	/**
 	 * Big Block Allocation Table
 	 * @var array  (blockId => nextBlockId)
-	*/
+	 */
 	public $bbat;
 
 	/**
 	 * Short Block Allocation Table
 	 * @var array  (blockId => nextBlockId)
-	*/
+	 */
 	public $sbat;
 
 	/**
 	 * Size of big blocks. This is usually 512.
 	 * @var  int  number of octets per block.
-	*/
+	 */
 	public $bigBlockSize;
 
 	/**
 	 * Size of small blocks. This is usually 64.
 	 * @var  int  number of octets per block
-	*/
+	 */
 	public $smallBlockSize;
 
 	/**
@@ -92,7 +92,7 @@ 
 	 * @acces public
 	 * @param string $file
 	 * @return mixed true on success, PEAR_Error on failure
-	*/
+	 */
 	public function read($file)
 	{
 		$fh = fopen($file, "r");
@@ -189,11 +189,11 @@ 
 	}
 
 	/**
-	* Returns a stream for use with fread() etc. External callers should
-	* use PHPExcel_Shared_OLE_PPS_File::getStream().
-	* @param   int|PPS   block id or PPS
-	* @return  resource  read-only stream
-	*/
+	 * Returns a stream for use with fread() etc. External callers should
+	 * use PHPExcel_Shared_OLE_PPS_File::getStream().
+	 * @param   int|PPS   block id or PPS
+	 * @return  resource  read-only stream
+	 */
 	public function getStream($blockIdOrPps)
 	{
 		static $isRegistered = false;
@@ -256,13 +256,13 @@ 
 	}
 
 	/**
-	* Gets information about all PPS's on the OLE container from the PPS WK's
-	* creates an OLE_PPS object for each one.
-	*
-	* @access public
-	* @param  integer  the block id of the first block
-	* @return mixed true on success, PEAR_Error on failure
-	*/
+	 * Gets information about all PPS's on the OLE container from the PPS WK's
+	 * creates an OLE_PPS object for each one.
+	 *
+	 * @access public
+	 * @param  integer  the block id of the first block
+	 * @return mixed true on success, PEAR_Error on failure
+	 */
 	public function _readPpsWks($blockId)
 	{
 		$fh = $this->getStream($blockId);
@@ -333,13 +333,13 @@ 
 	}
 
 	/**
-	* It checks whether the PPS tree is complete (all PPS's read)
-	* starting with the given PPS (not necessarily root)
-	*
-	* @access public
-	* @param integer $index The index of the PPS from which we are checking
-	* @return boolean Whether the PPS tree for the given PPS is complete
-	*/
+	 * It checks whether the PPS tree is complete (all PPS's read)
+	 * starting with the given PPS (not necessarily root)
+	 *
+	 * @access public
+	 * @param integer $index The index of the PPS from which we are checking
+	 * @return boolean Whether the PPS tree for the given PPS is complete
+	 */
 	public function _ppsTreeComplete($index)
 	{
 		return isset($this->_list[$index]) &&
@@ -353,13 +353,13 @@ 
 	}
 
 	/**
-	* Checks whether a PPS is a File PPS or not.
-	* If there is no PPS for the index given, it will return false.
-	*
-	* @access public
-	* @param integer $index The index for the PPS
-	* @return bool true if it's a File PPS, false otherwise
-	*/
+	 * Checks whether a PPS is a File PPS or not.
+	 * If there is no PPS for the index given, it will return false.
+	 *
+	 * @access public
+	 * @param integer $index The index for the PPS
+	 * @return bool true if it's a File PPS, false otherwise
+	 */
 	public function isFile($index)
 	{
 		if (isset($this->_list[$index])) {
@@ -369,13 +369,13 @@ 
 	}
 
 	/**
-	* Checks whether a PPS is a Root PPS or not.
-	* If there is no PPS for the index given, it will return false.
-	*
-	* @access public
-	* @param integer $index The index for the PPS.
-	* @return bool true if it's a Root PPS, false otherwise
-	*/
+	 * Checks whether a PPS is a Root PPS or not.
+	 * If there is no PPS for the index given, it will return false.
+	 *
+	 * @access public
+	 * @param integer $index The index for the PPS.
+	 * @return bool true if it's a Root PPS, false otherwise
+	 */
 	public function isRoot($index)
 	{
 		if (isset($this->_list[$index])) {
@@ -385,28 +385,28 @@ 
 	}
 
 	/**
-	* Gives the total number of PPS's found in the OLE container.
-	*
-	* @access public
-	* @return integer The total number of PPS's found in the OLE container
-	*/
+	 * Gives the total number of PPS's found in the OLE container.
+	 *
+	 * @access public
+	 * @return integer The total number of PPS's found in the OLE container
+	 */
 	public function ppsTotal()
 	{
 		return count($this->_list);
 	}
 
 	/**
-	* Gets data from a PPS
-	* If there is no PPS for the index given, it will return an empty string.
-	*
-	* @access public
-	* @param integer $index    The index for the PPS
-	* @param integer $position The position from which to start reading
-	*                          (relative to the PPS)
-	* @param integer $length   The amount of bytes to read (at most)
-	* @return string The binary string containing the data requested
-	* @see OLE_PPS_File::getStream()
-	*/
+	 * Gets data from a PPS
+	 * If there is no PPS for the index given, it will return an empty string.
+	 *
+	 * @access public
+	 * @param integer $index    The index for the PPS
+	 * @param integer $position The position from which to start reading
+	 *                          (relative to the PPS)
+	 * @param integer $length   The amount of bytes to read (at most)
+	 * @return string The binary string containing the data requested
+	 * @see OLE_PPS_File::getStream()
+	 */
 	public function getData($index, $position, $length)
 	{
 		// if position is not valid return empty string
@@ -420,13 +420,13 @@ 
 	}
 
 	/**
-	* Gets the data length from a PPS
-	* If there is no PPS for the index given, it will return 0.
-	*
-	* @access public
-	* @param integer $index    The index for the PPS
-	* @return integer The amount of bytes in data the PPS has
-	*/
+	 * Gets the data length from a PPS
+	 * If there is no PPS for the index given, it will return 0.
+	 *
+	 * @access public
+	 * @param integer $index    The index for the PPS
+	 * @return integer The amount of bytes in data the PPS has
+	 */
 	public function getDataLength($index)
 	{
 		if (isset($this->_list[$index])) {
@@ -436,13 +436,13 @@ 
 	}
 
 	/**
-	* Utility function to transform ASCII text to Unicode
-	*
-	* @access public
-	* @static
-	* @param string $ascii The ASCII string to transform
-	* @return string The string in Unicode
-	*/
+	 * Utility function to transform ASCII text to Unicode
+	 *
+	 * @access public
+	 * @static
+	 * @param string $ascii The ASCII string to transform
+	 * @return string The string in Unicode
+	 */
 	public static function Asc2Ucs($ascii)
 	{
 		$rawname = '';
@@ -453,14 +453,14 @@ 
 	}
 
 	/**
-	* Utility function
-	* Returns a string for the OLE container with the date given
-	*
-	* @access public
-	* @static
-	* @param integer $date A timestamp
-	* @return string The string for the OLE container
-	*/
+	 * Utility function
+	 * Returns a string for the OLE container with the date given
+	 *
+	 * @access public
+	 * @static
+	 * @param integer $date A timestamp
+	 * @return string The string for the OLE container
+	 */
 	public static function LocalDate2OLE($date = null)
 	{
 		if (!isset($date)) {
@@ -499,13 +499,13 @@ 
 	}
 
 	/**
-	* Returns a timestamp from an OLE container's date
-	*
-	* @access public
-	* @static
-	* @param integer $string A binary string with the encoded date
-	* @return string The timestamp corresponding to the string
-	*/
+	 * Returns a timestamp from an OLE container's date
+	 *
+	 * @access public
+	 * @static
+	 * @param integer $string A binary string with the encoded date
+	 * @return string The timestamp corresponding to the string
+	 */
 	public static function OLE2LocalDate($string)
 	{
 		if (strlen($string) != 8) {

Switch Indentation +13 added lines, -13 removed lines

@@ -275,19 +275,19 @@
 			$name = str_replace("\x00", "", $nameUtf16);
 			$type = self::_readInt1($fh);
 			switch ($type) {
-			case self::OLE_PPS_TYPE_ROOT:
-				$pps = new PHPExcel_Shared_OLE_PPS_Root(null, null, array());
-				$this->root = $pps;
-				break;
-			case self::OLE_PPS_TYPE_DIR:
-				$pps = new PHPExcel_Shared_OLE_PPS(null, null, null, null, null,
-								   null, null, null, null, array());
-				break;
-			case self::OLE_PPS_TYPE_FILE:
-				$pps = new PHPExcel_Shared_OLE_PPS_File($name);
-				break;
-			default:
-				continue;
+				case self::OLE_PPS_TYPE_ROOT:
+					$pps = new PHPExcel_Shared_OLE_PPS_Root(null, null, array());
+					$this->root = $pps;
+					break;
+				case self::OLE_PPS_TYPE_DIR:
+					$pps = new PHPExcel_Shared_OLE_PPS(null, null, null, null, null,
+								   	null, null, null, null, array());
+					break;
+				case self::OLE_PPS_TYPE_FILE:
+					$pps = new PHPExcel_Shared_OLE_PPS_File($name);
+					break;
+				default:
+					continue;
 			}
 			fseek($fh, 1, SEEK_CUR);
 			$pps->Type    = $type;

Spacing +19 added lines, -19 removed lines

@@ -37,12 +37,12 @@ 
 */
 class PHPExcel_Shared_OLE
 {
-	const OLE_PPS_TYPE_ROOT   =      5;
-	const OLE_PPS_TYPE_DIR    =      1;
-	const OLE_PPS_TYPE_FILE   =      2;
+	const OLE_PPS_TYPE_ROOT   = 5;
+	const OLE_PPS_TYPE_DIR    = 1;
+	const OLE_PPS_TYPE_FILE   = 2;
 	const OLE_DATA_SIZE_SMALL = 0x1000;
-	const OLE_LONG_INT_SIZE   =      4;
-	const OLE_PPS_SIZE        =   0x80;
+	const OLE_LONG_INT_SIZE   = 4;
+	const OLE_PPS_SIZE        = 0x80;
 
 	/**
 	 * The file handle for reading an OLE container
@@ -96,7 +96,7 @@ 
 	public function read($file)
 	{
 		$fh = fopen($file, "r");
-		if (!$fh) {
+		if ( ! $fh) {
 			throw new Exception("Can't open file $file");
 		}
 		$this->_file_handle = $fh;
@@ -112,7 +112,7 @@ 
 		}
 		// Size of blocks and short blocks in bytes
 		$this->bigBlockSize = pow(2, self::_readInt2($fh));
-		$this->smallBlockSize  = pow(2, self::_readInt2($fh));
+		$this->smallBlockSize = pow(2, self::_readInt2($fh));
 
 		// Skip UID, revision number and version number
 		fseek($fh, 44);
@@ -159,7 +159,7 @@ 
 		for ($i = 0; $i < $bbatBlockCount; ++$i) {
 			$pos = $this->_getBlockOffset($mbatBlocks[$i]);
 			fseek($fh, $pos);
-			for ($j = 0 ; $j < $this->bigBlockSize / 4; ++$j) {
+			for ($j = 0; $j < $this->bigBlockSize / 4; ++$j) {
 				$this->bbat[] = self::_readInt4($fh);
 			}
 		}
@@ -197,7 +197,7 @@ 
 	public function getStream($blockIdOrPps)
 	{
 		static $isRegistered = false;
-		if (!$isRegistered) {
+		if ( ! $isRegistered) {
 			stream_wrapper_register('ole-chainedblockstream',
 				'PHPExcel_Shared_OLE_ChainedBlockStream');
 			$isRegistered = true;
@@ -209,12 +209,12 @@ 
 		$GLOBALS['_OLE_INSTANCES'][] = $this;
 		$instanceId = end(array_keys($GLOBALS['_OLE_INSTANCES']));
 
-		$path = 'ole-chainedblockstream://oleInstanceId=' . $instanceId;
+		$path = 'ole-chainedblockstream://oleInstanceId='.$instanceId;
 		if ($blockIdOrPps instanceof PHPExcel_Shared_OLE_PPS) {
-			$path .= '&blockId=' . $blockIdOrPps->_StartBlock;
-			$path .= '&size=' . $blockIdOrPps->Size;
+			$path .= '&blockId='.$blockIdOrPps->_StartBlock;
+			$path .= '&size='.$blockIdOrPps->Size;
 		} else {
-			$path .= '&blockId=' . $blockIdOrPps;
+			$path .= '&blockId='.$blockIdOrPps;
 		}
 		return fopen($path, 'r');
 	}
@@ -410,7 +410,7 @@ 
 	public function getData($index, $position, $length)
 	{
 		// if position is not valid return empty string
-		if (!isset($this->_list[$index]) || ($position >= $this->_list[$index]->Size) || ($position < 0)) {
+		if ( ! isset($this->_list[$index]) || ($position >= $this->_list[$index]->Size) || ($position < 0)) {
 			return '';
 		}
 		$fh = $this->getStream($this->_list[$index]);
@@ -447,7 +447,7 @@ 
 	{
 		$rawname = '';
 		for ($i = 0; $i < strlen($ascii); ++$i) {
-			$rawname .= $ascii{$i} . "\x00";
+			$rawname .= $ascii{$i}."\x00";
 		}
 		return $rawname;
 	}
@@ -463,7 +463,7 @@ 
 	*/
 	public static function LocalDate2OLE($date = null)
 	{
-		if (!isset($date)) {
+		if ( ! isset($date)) {
 			return "\x00\x00\x00\x00\x00\x00\x00\x00";
 		}
 
@@ -473,8 +473,8 @@ 
 		// days from 1-1-1601 until the beggining of UNIX era
 		$days = 134774;
 		// calculate seconds
-		$big_date = $days*24*3600 + gmmktime(date("H",$date),date("i",$date),date("s",$date),
-											 date("m",$date),date("d",$date),date("Y",$date));
+		$big_date = $days * 24 * 3600 + gmmktime(date("H", $date), date("i", $date), date("s", $date),
+											 date("m", $date), date("d", $date), date("Y", $date));
 		// multiply just to make MS happy
 		$big_date *= 10000000;
 
@@ -513,7 +513,7 @@ 
 		}
 
 		// factor used for separating numbers into 4 bytes parts
-		$factor = pow(2,32);
+		$factor = pow(2, 32);
 		list(, $high_part) = unpack('V', substr($string, 4, 4));
 		list(, $low_part) = unpack('V', substr($string, 0, 4));
 

app/Vendor/PHPExcel/PHPExcel/Shared/OLE/PPS/Root.php

Doc Comments +4 added lines, -4 removed lines

@@ -64,9 +64,9 @@ 
 	* If a resource pointer to a stream created by fopen() is passed
 	* it will be used, but you have to close such stream by yourself.
 	*
-	* @param string|resource $filename The name of the file or stream where to save the OLE container.
+	* @param string|null $filename The name of the file or stream where to save the OLE container.
 	* @access public
-	* @return mixed true on success
+	* @return boolean true on success
 	*/
 	public function save($filename)
 	{
@@ -122,7 +122,7 @@ 
 	*
 	* @access public
 	* @param array $raList Reference to an array of PPS's
-	* @return array The array of numbers
+	* @return double[] The array of numbers
 	*/
 	public function _calcSize(&$raList)
 	{
@@ -161,7 +161,7 @@ 
 	* @access public
 	* @param integer $i2 The argument
 	* @see save()
-	* @return integer
+	* @return double
 	*/
 	private static function _adjust2($i2)
 	{

Indentation +54 added lines, -54 removed lines

@@ -58,16 +58,16 @@ 
 	}
 
 	/**
-	* Method for saving the whole OLE container (including files).
-	* In fact, if called with an empty argument (or '-'), it saves to a
-	* temporary file and then outputs it's contents to stdout.
-	* If a resource pointer to a stream created by fopen() is passed
-	* it will be used, but you have to close such stream by yourself.
-	*
-	* @param string|resource $filename The name of the file or stream where to save the OLE container.
-	* @access public
-	* @return mixed true on success
-	*/
+	 * Method for saving the whole OLE container (including files).
+	 * In fact, if called with an empty argument (or '-'), it saves to a
+	 * temporary file and then outputs it's contents to stdout.
+	 * If a resource pointer to a stream created by fopen() is passed
+	 * it will be used, but you have to close such stream by yourself.
+	 *
+	 * @param string|resource $filename The name of the file or stream where to save the OLE container.
+	 * @access public
+	 * @return mixed true on success
+	 */
 	public function save($filename)
 	{
 		// Initial Setting for saving
@@ -77,7 +77,7 @@ 
 					  ((isset($this->_SMALL_BLOCK_SIZE))?  self::_adjust2($this->_SMALL_BLOCK_SIZE): 6));
 
 		if (is_resource($filename)) {
-		    $this->_FILEH_ = $filename;
+			$this->_FILEH_ = $filename;
 		} else if ($filename == '-' || $filename == '') {
 			if ($this->_tmp_dir === NULL)
 				$this->_tmp_dir = PHPExcel_Shared_File::sys_get_temp_dir();
@@ -118,12 +118,12 @@ 
 	}
 
 	/**
-	* Calculate some numbers
-	*
-	* @access public
-	* @param array $raList Reference to an array of PPS's
-	* @return array The array of numbers
-	*/
+	 * Calculate some numbers
+	 *
+	 * @access public
+	 * @param array $raList Reference to an array of PPS's
+	 * @return array The array of numbers
+	 */
 	public function _calcSize(&$raList)
 	{
 		// Calculate Basic Setting
@@ -156,13 +156,13 @@ 
 	}
 
 	/**
-	* Helper function for caculating a magic value for block sizes
-	*
-	* @access public
-	* @param integer $i2 The argument
-	* @see save()
-	* @return integer
-	*/
+	 * Helper function for caculating a magic value for block sizes
+	 *
+	 * @access public
+	 * @param integer $i2 The argument
+	 * @see save()
+	 * @return integer
+	 */
 	private static function _adjust2($i2)
 	{
 		$iWk = log($i2)/log(2);
@@ -170,13 +170,13 @@ 
 	}
 
 	/**
-	* Save OLE header
-	*
-	* @access public
-	* @param integer $iSBDcnt
-	* @param integer $iBBcnt
-	* @param integer $iPPScnt
-	*/
+	 * Save OLE header
+	 *
+	 * @access public
+	 * @param integer $iSBDcnt
+	 * @param integer $iBBcnt
+	 * @param integer $iPPScnt
+	 */
 	public function _saveHeader($iSBDcnt, $iBBcnt, $iPPScnt)
 	{
 		$FILE = $this->_FILEH_;
@@ -249,12 +249,12 @@ 
 	}
 
 	/**
-	* Saving big data (PPS's with data bigger than PHPExcel_Shared_OLE::OLE_DATA_SIZE_SMALL)
-	*
-	* @access public
-	* @param integer $iStBlk
-	* @param array &$raList Reference to array of PPS's
-	*/
+	 * Saving big data (PPS's with data bigger than PHPExcel_Shared_OLE::OLE_DATA_SIZE_SMALL)
+	 *
+	 * @access public
+	 * @param integer $iStBlk
+	 * @param array &$raList Reference to array of PPS's
+	 */
 	public function _saveBigData($iStBlk, &$raList)
 	{
 		$FILE = $this->_FILEH_;
@@ -299,11 +299,11 @@ 
 	}
 
 	/**
-	* get small data (PPS's with data smaller than PHPExcel_Shared_OLE::OLE_DATA_SIZE_SMALL)
-	*
-	* @access public
-	* @param array &$raList Reference to array of PPS's
-	*/
+	 * get small data (PPS's with data smaller than PHPExcel_Shared_OLE::OLE_DATA_SIZE_SMALL)
+	 *
+	 * @access public
+	 * @param array &$raList Reference to array of PPS's
+	 */
 	public function _makeSmallData(&$raList)
 	{
 		$sRes = '';
@@ -356,11 +356,11 @@ 
 	}
 
 	/**
-	* Saves all the PPS's WKs
-	*
-	* @access public
-	* @param array $raList Reference to an array with all PPS's
-	*/
+	 * Saves all the PPS's WKs
+	 *
+	 * @access public
+	 * @param array $raList Reference to an array with all PPS's
+	 */
 	public function _savePps(&$raList)
 	{
 		// Save each PPS WK
@@ -377,13 +377,13 @@ 
 	}
 
 	/**
-	* Saving Big Block Depot
-	*
-	* @access public
-	* @param integer $iSbdSize
-	* @param integer $iBsize
-	* @param integer $iPpsCnt
-	*/
+	 * Saving Big Block Depot
+	 *
+	 * @access public
+	 * @param integer $iSbdSize
+	 * @param integer $iBsize
+	 * @param integer $iPpsCnt
+	 */
 	public function _saveBbd($iSbdSize, $iBsize, $iPpsCnt)
 	{
 		$FILE = $this->_FILEH_;

Spacing +43 added lines, -43 removed lines

@@ -34,7 +34,7 @@ 
 	 * Directory for temporary files
 	 * @var string
 	 */
-	protected $_tmp_dir		= NULL;
+	protected $_tmp_dir = NULL;
 
 	/**
 	 * @param integer $time_1st A timestamp
@@ -72,9 +72,9 @@ 
 	{
 		// Initial Setting for saving
 		$this->_BIG_BLOCK_SIZE  = pow(2,
-					  ((isset($this->_BIG_BLOCK_SIZE))? self::_adjust2($this->_BIG_BLOCK_SIZE)  : 9));
-		$this->_SMALL_BLOCK_SIZE= pow(2,
-					  ((isset($this->_SMALL_BLOCK_SIZE))?  self::_adjust2($this->_SMALL_BLOCK_SIZE): 6));
+					  ((isset($this->_BIG_BLOCK_SIZE)) ? self::_adjust2($this->_BIG_BLOCK_SIZE) : 9));
+		$this->_SMALL_BLOCK_SIZE = pow(2,
+					  ((isset($this->_SMALL_BLOCK_SIZE)) ? self::_adjust2($this->_SMALL_BLOCK_SIZE) : 6));
 
 		if (is_resource($filename)) {
 		    $this->_FILEH_ = $filename;
@@ -82,7 +82,7 @@ 
 			if ($this->_tmp_dir === NULL)
 				$this->_tmp_dir = PHPExcel_Shared_File::sys_get_temp_dir();
 			$this->_tmp_filename = tempnam($this->_tmp_dir, "OLE_PPS_Root");
-			$this->_FILEH_ = fopen($this->_tmp_filename,"w+b");
+			$this->_FILEH_ = fopen($this->_tmp_filename, "w+b");
 			if ($this->_FILEH_ == false) {
 				throw new Exception("Can't create temporary file.");
 			}
@@ -110,7 +110,7 @@ 
 		// Write Big Block Depot and BDList and Adding Header informations
 		$this->_saveBbd($iSBDcnt, $iBBcnt, $iPPScnt);
 
-		if (!is_resource($filename)) {
+		if ( ! is_resource($filename)) {
  			fclose($this->_FILEH_);
  		}
 
@@ -127,7 +127,7 @@ 
 	public function _calcSize(&$raList)
 	{
 		// Calculate Basic Setting
-		list($iSBDcnt, $iBBcnt, $iPPScnt) = array(0,0,0);
+		list($iSBDcnt, $iBBcnt, $iPPScnt) = array(0, 0, 0);
 		$iSmallLen = 0;
 		$iSBcnt = 0;
 		$iCount = count($raList);
@@ -136,21 +136,21 @@ 
 				$raList[$i]->Size = $raList[$i]->_DataLen();
 				if ($raList[$i]->Size < PHPExcel_Shared_OLE::OLE_DATA_SIZE_SMALL) {
 					$iSBcnt += floor($raList[$i]->Size / $this->_SMALL_BLOCK_SIZE)
-								  + (($raList[$i]->Size % $this->_SMALL_BLOCK_SIZE)? 1: 0);
+								  + (($raList[$i]->Size % $this->_SMALL_BLOCK_SIZE) ? 1 : 0);
 				} else {
 					$iBBcnt += (floor($raList[$i]->Size / $this->_BIG_BLOCK_SIZE) +
-						(($raList[$i]->Size % $this->_BIG_BLOCK_SIZE)? 1: 0));
+						(($raList[$i]->Size % $this->_BIG_BLOCK_SIZE) ? 1 : 0));
 				}
 			}
 		}
 		$iSmallLen = $iSBcnt * $this->_SMALL_BLOCK_SIZE;
 		$iSlCnt = floor($this->_BIG_BLOCK_SIZE / PHPExcel_Shared_OLE::OLE_LONG_INT_SIZE);
-		$iSBDcnt = floor($iSBcnt / $iSlCnt) + (($iSBcnt % $iSlCnt)? 1:0);
-		$iBBcnt +=  (floor($iSmallLen / $this->_BIG_BLOCK_SIZE) +
-					  (( $iSmallLen % $this->_BIG_BLOCK_SIZE)? 1: 0));
+		$iSBDcnt = floor($iSBcnt / $iSlCnt) + (($iSBcnt % $iSlCnt) ? 1 : 0);
+		$iBBcnt += (floor($iSmallLen / $this->_BIG_BLOCK_SIZE) +
+					  (($iSmallLen % $this->_BIG_BLOCK_SIZE) ? 1 : 0));
 		$iCnt = count($raList);
 		$iBdCnt = $this->_BIG_BLOCK_SIZE / PHPExcel_Shared_OLE::OLE_PPS_SIZE;
-		$iPPScnt = (floor($iCnt/$iBdCnt) + (($iCnt % $iBdCnt)? 1: 0));
+		$iPPScnt = (floor($iCnt / $iBdCnt) + (($iCnt % $iBdCnt) ? 1 : 0));
 
 		return array($iSBDcnt, $iBBcnt, $iPPScnt);
 	}
@@ -165,8 +165,8 @@ 
 	*/
 	private static function _adjust2($i2)
 	{
-		$iWk = log($i2)/log(2);
-		return ($iWk > floor($iWk))? floor($iWk)+1:$iWk;
+		$iWk = log($i2) / log(2);
+		return ($iWk > floor($iWk)) ? floor($iWk) + 1 : $iWk;
 	}
 
 	/**
@@ -188,17 +188,17 @@ 
 		$iBdExL = 0;
 		$iAll = $iBBcnt + $iPPScnt + $iSBDcnt;
 		$iAllW = $iAll;
-		$iBdCntW = floor($iAllW / $iBlCnt) + (($iAllW % $iBlCnt)? 1: 0);
-		$iBdCnt = floor(($iAll + $iBdCntW) / $iBlCnt) + ((($iAllW+$iBdCntW) % $iBlCnt)? 1: 0);
+		$iBdCntW = floor($iAllW / $iBlCnt) + (($iAllW % $iBlCnt) ? 1 : 0);
+		$iBdCnt = floor(($iAll + $iBdCntW) / $iBlCnt) + ((($iAllW + $iBdCntW) % $iBlCnt) ? 1 : 0);
 
 		// Calculate BD count
 		if ($iBdCnt > $i1stBdL) {
 			while (1) {
 				++$iBdExL;
 				++$iAllW;
-				$iBdCntW = floor($iAllW / $iBlCnt) + (($iAllW % $iBlCnt)? 1: 0);
-				$iBdCnt = floor(($iAllW + $iBdCntW) / $iBlCnt) + ((($iAllW+$iBdCntW) % $iBlCnt)? 1: 0);
-				if ($iBdCnt <= ($iBdExL*$iBlCnt+ $i1stBdL)) {
+				$iBdCntW = floor($iAllW / $iBlCnt) + (($iAllW % $iBlCnt) ? 1 : 0);
+				$iBdCnt = floor(($iAllW + $iBdCntW) / $iBlCnt) + ((($iAllW + $iBdCntW) % $iBlCnt) ? 1 : 0);
+				if ($iBdCnt <= ($iBdExL * $iBlCnt + $i1stBdL)) {
 					break;
 				}
 			}
@@ -220,7 +220,7 @@ 
 				. "\x00\x00\x00\x00"
 				. "\x00\x00\x00\x00"
 				. pack("V", $iBdCnt)
-				. pack("V", $iBBcnt+$iSBDcnt) //ROOT START
+				. pack("V", $iBBcnt + $iSBDcnt) //ROOT START
 				. pack("V", 0)
 				. pack("V", 0x1000)
 				. pack("V", $iSBDcnt ? 0 : -2)                  //Small Block Depot
@@ -233,12 +233,12 @@ 
 					. pack("V", 0)        // Extra BDList Count
 				  );
 		} else {
-			fwrite($FILE, pack("V", $iAll+$iBdCnt) . pack("V", $iBdExL));
+			fwrite($FILE, pack("V", $iAll + $iBdCnt).pack("V", $iBdExL));
 		}
 
 		// BDList
 		for ($i = 0; $i < $i1stBdL && $i < $iBdCnt; ++$i) {
-			fwrite($FILE, pack("V", $iAll+$i));
+			fwrite($FILE, pack("V", $iAll + $i));
 		}
 		if ($i < $i1stBdL) {
 			$jB = $i1stBdL - $i;
@@ -286,7 +286,7 @@ 
 					$raList[$i]->_StartBlock = $iStBlk;
 					$iStBlk +=
 							(floor($raList[$i]->Size / $this->_BIG_BLOCK_SIZE) +
-								(($raList[$i]->Size % $this->_BIG_BLOCK_SIZE)? 1: 0));
+								(($raList[$i]->Size % $this->_BIG_BLOCK_SIZE) ? 1 : 0));
 				}
 				// Close file for each PPS, and unlink it
 				//if (isset($raList[$i]->_PPS_FILE)) {
@@ -319,11 +319,11 @@ 
 				}
 				if ($raList[$i]->Size < PHPExcel_Shared_OLE::OLE_DATA_SIZE_SMALL) {
 					$iSmbCnt = floor($raList[$i]->Size / $this->_SMALL_BLOCK_SIZE)
-								  + (($raList[$i]->Size % $this->_SMALL_BLOCK_SIZE)? 1: 0);
+								  + (($raList[$i]->Size % $this->_SMALL_BLOCK_SIZE) ? 1 : 0);
 					// Add to SBD
 					$jB = $iSmbCnt - 1;
 					for ($j = 0; $j < $jB; ++$j) {
-						fwrite($FILE, pack("V", $j+$iSmBlk+1));
+						fwrite($FILE, pack("V", $j + $iSmBlk + 1));
 					}
 					fwrite($FILE, pack("V", -2));
 
@@ -337,7 +337,7 @@ 
 						$sRes .= $raList[$i]->_data;
 					//}
 					if ($raList[$i]->Size % $this->_SMALL_BLOCK_SIZE) {
-						$sRes .= str_repeat("\x00",$this->_SMALL_BLOCK_SIZE - ($raList[$i]->Size % $this->_SMALL_BLOCK_SIZE));
+						$sRes .= str_repeat("\x00", $this->_SMALL_BLOCK_SIZE - ($raList[$i]->Size % $this->_SMALL_BLOCK_SIZE));
 					}
 					// Set for PPS
 					$raList[$i]->_StartBlock = $iSmBlk;
@@ -372,7 +372,7 @@ 
 		$iCnt = count($raList);
 		$iBCnt = $this->_BIG_BLOCK_SIZE / PHPExcel_Shared_OLE::OLE_PPS_SIZE;
 		if ($iCnt % $iBCnt) {
-			fwrite($this->_FILEH_, str_repeat("\x00",($iBCnt - ($iCnt % $iBCnt)) * PHPExcel_Shared_OLE::OLE_PPS_SIZE));
+			fwrite($this->_FILEH_, str_repeat("\x00", ($iBCnt - ($iCnt % $iBCnt)) * PHPExcel_Shared_OLE::OLE_PPS_SIZE));
 		}
 	}
 
@@ -394,16 +394,16 @@ 
 		$iBdExL = 0;
 		$iAll = $iBsize + $iPpsCnt + $iSbdSize;
 		$iAllW = $iAll;
-		$iBdCntW = floor($iAllW / $iBbCnt) + (($iAllW % $iBbCnt)? 1: 0);
-		$iBdCnt = floor(($iAll + $iBdCntW) / $iBbCnt) + ((($iAllW+$iBdCntW) % $iBbCnt)? 1: 0);
+		$iBdCntW = floor($iAllW / $iBbCnt) + (($iAllW % $iBbCnt) ? 1 : 0);
+		$iBdCnt = floor(($iAll + $iBdCntW) / $iBbCnt) + ((($iAllW + $iBdCntW) % $iBbCnt) ? 1 : 0);
 		// Calculate BD count
-		if ($iBdCnt >$i1stBdL) {
+		if ($iBdCnt > $i1stBdL) {
 			while (1) {
 				++$iBdExL;
 				++$iAllW;
-				$iBdCntW = floor($iAllW / $iBbCnt) + (($iAllW % $iBbCnt)? 1: 0);
-				$iBdCnt = floor(($iAllW + $iBdCntW) / $iBbCnt) + ((($iAllW+$iBdCntW) % $iBbCnt)? 1: 0);
-				if ($iBdCnt <= ($iBdExL*$iBbCnt+ $i1stBdL)) {
+				$iBdCntW = floor($iAllW / $iBbCnt) + (($iAllW % $iBbCnt) ? 1 : 0);
+				$iBdCnt = floor(($iAllW + $iBdCntW) / $iBbCnt) + ((($iAllW + $iBdCntW) % $iBbCnt) ? 1 : 0);
+				if ($iBdCnt <= ($iBdExL * $iBbCnt + $i1stBdL)) {
 					break;
 				}
 			}
@@ -413,19 +413,19 @@ 
 		// Set for SBD
 		if ($iSbdSize > 0) {
 			for ($i = 0; $i < ($iSbdSize - 1); ++$i) {
-				fwrite($FILE, pack("V", $i+1));
+				fwrite($FILE, pack("V", $i + 1));
 			}
 			fwrite($FILE, pack("V", -2));
 		}
 		// Set for B
 		for ($i = 0; $i < ($iBsize - 1); ++$i) {
-			fwrite($FILE, pack("V", $i+$iSbdSize+1));
+			fwrite($FILE, pack("V", $i + $iSbdSize + 1));
 		}
 		fwrite($FILE, pack("V", -2));
 
 		// Set for PPS
 		for ($i = 0; $i < ($iPpsCnt - 1); ++$i) {
-			fwrite($FILE, pack("V", $i+$iSbdSize+$iBsize+1));
+			fwrite($FILE, pack("V", $i + $iSbdSize + $iBsize + 1));
 		}
 		fwrite($FILE, pack("V", -2));
 		// Set for BBD itself ( 0xFFFFFFFD : BBD)
@@ -445,17 +445,17 @@ 
 		}
 		// Extra BDList
 		if ($iBdCnt > $i1stBdL) {
-			$iN=0;
-			$iNb=0;
-			for ($i = $i1stBdL;$i < $iBdCnt; $i++, ++$iN) {
+			$iN = 0;
+			$iNb = 0;
+			for ($i = $i1stBdL; $i < $iBdCnt; $i++, ++$iN) {
 				if ($iN >= ($iBbCnt - 1)) {
 					$iN = 0;
 					++$iNb;
-					fwrite($FILE, pack("V", $iAll+$iBdCnt+$iNb));
+					fwrite($FILE, pack("V", $iAll + $iBdCnt + $iNb));
 				}
-				fwrite($FILE, pack("V", $iBsize+$iSbdSize+$iPpsCnt+$i));
+				fwrite($FILE, pack("V", $iBsize + $iSbdSize + $iPpsCnt + $i));
 			}
-			if (($iBdCnt-$i1stBdL) % ($iBbCnt-1)) {
+			if (($iBdCnt - $i1stBdL) % ($iBbCnt - 1)) {
 				$iB = ($iBbCnt - 1) - (($iBdCnt - $i1stBdL) % ($iBbCnt - 1));
 				for ($i = 0; $i < $iB; ++$i) {
 					fwrite($FILE, pack("V", -1));

Braces +3 added lines, -2 removed lines

@@ -79,8 +79,9 @@
 		if (is_resource($filename)) {
 		    $this->_FILEH_ = $filename;
 		} else if ($filename == '-' || $filename == '') {
-			if ($this->_tmp_dir === NULL)
-				$this->_tmp_dir = PHPExcel_Shared_File::sys_get_temp_dir();
+			if ($this->_tmp_dir === NULL) {
+							$this->_tmp_dir = PHPExcel_Shared_File::sys_get_temp_dir();
+			}
 			$this->_tmp_filename = tempnam($this->_tmp_dir, "OLE_PPS_Root");
 			$this->_FILEH_ = fopen($this->_tmp_filename,"w+b");
 			if ($this->_FILEH_ == false) {