New file |
0,0 → 1,1059 |
<?php |
/** |
* @package JAMA |
*/ |
|
/** PHPExcel root directory */ |
if (!defined('PHPEXCEL_ROOT')) { |
/** |
* @ignore |
*/ |
define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../../'); |
require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php'); |
} |
|
|
/* |
* Matrix class |
* |
* @author Paul Meagher |
* @author Michael Bommarito |
* @author Lukasz Karapuda |
* @author Bartek Matosiuk |
* @version 1.8 |
* @license PHP v3.0 |
* @see http://math.nist.gov/javanumerics/jama/ |
*/ |
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."; |
|
/** |
* Matrix storage |
* |
* @var array |
* @access public |
*/ |
public $A = array(); |
|
/** |
* Matrix row dimension |
* |
* @var int |
* @access private |
*/ |
private $m; |
|
/** |
* Matrix column dimension |
* |
* @var int |
* @access private |
*/ |
private $n; |
|
|
/** |
* Polymorphic constructor |
* |
* As PHP has no support for polymorphic constructors, we hack our own sort of polymorphism using func_num_args, func_get_arg, and gettype. In essence, we're just implementing a simple RTTI filter and calling the appropriate constructor. |
*/ |
public function __construct() { |
if (func_num_args() > 0) { |
$args = func_get_args(); |
$match = implode(",", array_map('gettype', $args)); |
|
switch($match) { |
//Rectangular matrix - m x n initialized from 2D array |
case 'array': |
$this->m = count($args[0]); |
$this->n = count($args[0][0]); |
$this->A = $args[0]; |
break; |
//Square matrix - n x n |
case 'integer': |
$this->m = $args[0]; |
$this->n = $args[0]; |
$this->A = array_fill(0, $this->m, array_fill(0, $this->n, 0)); |
break; |
//Rectangular matrix - m x n |
case 'integer,integer': |
$this->m = $args[0]; |
$this->n = $args[1]; |
$this->A = array_fill(0, $this->m, array_fill(0, $this->n, 0)); |
break; |
//Rectangular matrix - m x n initialized from packed array |
case 'array,integer': |
$this->m = $args[1]; |
if ($this->m != 0) { |
$this->n = count($args[0]) / $this->m; |
} else { |
$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) { |
$this->A[$i][$j] = $args[0][$i + $j * $this->m]; |
} |
} |
} else { |
throw new PHPExcel_Calculation_Exception(self::ArrayLengthException); |
} |
break; |
default: |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
break; |
} |
} else { |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
} |
} // function __construct() |
|
|
/** |
* getArray |
* |
* @return array Matrix array |
*/ |
public function getArray() { |
return $this->A; |
} // function getArray() |
|
|
/** |
* getRowDimension |
* |
* @return int Row dimension |
*/ |
public function getRowDimension() { |
return $this->m; |
} // function getRowDimension() |
|
|
/** |
* getColumnDimension |
* |
* @return int Column dimension |
*/ |
public function getColumnDimension() { |
return $this->n; |
} // function getColumnDimension() |
|
|
/** |
* get |
* |
* Get the i,j-th element of the matrix. |
* @param int $i Row position |
* @param int $j Column position |
* @return mixed Element (int/float/double) |
*/ |
public function get($i = null, $j = null) { |
return $this->A[$i][$j]; |
} // function get() |
|
|
/** |
* 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 |
*/ |
public function getMatrix() { |
if (func_num_args() > 0) { |
$args = func_get_args(); |
$match = implode(",", array_map('gettype', $args)); |
|
switch($match) { |
//A($i0...; $j0...) |
case 'integer,integer': |
list($i0, $j0) = $args; |
if ($i0 >= 0) { $m = $this->m - $i0; } else { throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException); } |
if ($j0 >= 0) { $n = $this->n - $j0; } else { throw new PHPExcel_Calculation_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) { |
$R->set($i, $j, $this->A[$i][$j]); |
} |
} |
return $R; |
break; |
//A($i0...$iF; $j0...$jF) |
case 'integer,integer,integer,integer': |
list($i0, $iF, $j0, $jF) = $args; |
if (($iF > $i0) && ($this->m >= $iF) && ($i0 >= 0)) { $m = $iF - $i0; } else { throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException); } |
if (($jF > $j0) && ($this->n >= $jF) && ($j0 >= 0)) { $n = $jF - $j0; } else { throw new PHPExcel_Calculation_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->set($i - $i0, $j - $j0, $this->A[$i][$j]); |
} |
} |
return $R; |
break; |
//$R = array of row indices; $C = array of column indices |
case 'array,array': |
list($RL, $CL) = $args; |
if (count($RL) > 0) { $m = count($RL); } else { throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException); } |
if (count($CL) > 0) { $n = count($CL); } else { throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException); } |
$R = new PHPExcel_Shared_JAMA_Matrix($m, $n); |
for($i = 0; $i < $m; ++$i) { |
for($j = 0; $j < $n; ++$j) { |
$R->set($i - $i0, $j - $j0, $this->A[$RL[$i]][$CL[$j]]); |
} |
} |
return $R; |
break; |
//$RL = array of row indices; $CL = array of column indices |
case 'array,array': |
list($RL, $CL) = $args; |
if (count($RL) > 0) { $m = count($RL); } else { throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException); } |
if (count($CL) > 0) { $n = count($CL); } else { throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException); } |
$R = new PHPExcel_Shared_JAMA_Matrix($m, $n); |
for($i = 0; $i < $m; ++$i) { |
for($j = 0; $j < $n; ++$j) { |
$R->set($i, $j, $this->A[$RL[$i]][$CL[$j]]); |
} |
} |
return $R; |
break; |
//A($i0...$iF); $CL = array of column indices |
case 'integer,integer,array': |
list($i0, $iF, $CL) = $args; |
if (($iF > $i0) && ($this->m >= $iF) && ($i0 >= 0)) { $m = $iF - $i0; } else { throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException); } |
if (count($CL) > 0) { $n = count($CL); } else { throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException); } |
$R = new PHPExcel_Shared_JAMA_Matrix($m, $n); |
for($i = $i0; $i < $iF; ++$i) { |
for($j = 0; $j < $n; ++$j) { |
$R->set($i - $i0, $j, $this->A[$RL[$i]][$j]); |
} |
} |
return $R; |
break; |
//$RL = array of row indices |
case 'array,integer,integer': |
list($RL, $j0, $jF) = $args; |
if (count($RL) > 0) { $m = count($RL); } else { throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException); } |
if (($jF >= $j0) && ($this->n >= $jF) && ($j0 >= 0)) { $n = $jF - $j0; } else { throw new PHPExcel_Calculation_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->set($i, $j - $j0, $this->A[$RL[$i]][$j]); |
} |
} |
return $R; |
break; |
default: |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
break; |
} |
} else { |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
} |
} // function getMatrix() |
|
|
/** |
* checkMatrixDimensions |
* |
* Is matrix B the same size? |
* @param Matrix $B Matrix B |
* @return boolean |
*/ |
public function checkMatrixDimensions($B = null) { |
if ($B instanceof PHPExcel_Shared_JAMA_Matrix) { |
if (($this->m == $B->getRowDimension()) && ($this->n == $B->getColumnDimension())) { |
return true; |
} else { |
throw new PHPExcel_Calculation_Exception(self::MatrixDimensionException); |
} |
} else { |
throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException); |
} |
} // function checkMatrixDimensions() |
|
|
|
/** |
* set |
* |
* Set the i,j-th element of the matrix. |
* @param int $i Row position |
* @param int $j Column position |
* @param mixed $c Int/float/double value |
* @return mixed Element (int/float/double) |
*/ |
public function set($i = null, $j = null, $c = null) { |
// Optimized set version just has this |
$this->A[$i][$j] = $c; |
} // function set() |
|
|
/** |
* identity |
* |
* Generate an identity matrix. |
* @param int $m Row dimension |
* @param int $n Column dimension |
* @return Matrix Identity matrix |
*/ |
public function identity($m = null, $n = null) { |
return $this->diagonal($m, $n, 1); |
} // function identity() |
|
|
/** |
* diagonal |
* |
* Generate a diagonal matrix |
* @param int $m Row dimension |
* @param int $n Column dimension |
* @param mixed $c Diagonal value |
* @return Matrix Diagonal matrix |
*/ |
public function diagonal($m = null, $n = null, $c = 1) { |
$R = new PHPExcel_Shared_JAMA_Matrix($m, $n); |
for($i = 0; $i < $m; ++$i) { |
$R->set($i, $i, $c); |
} |
return $R; |
} // function diagonal() |
|
|
/** |
* getMatrixByRow |
* |
* Get a submatrix by row index/range |
* @param int $i0 Initial row index |
* @param int $iF Final row index |
* @return Matrix Submatrix |
*/ |
public function getMatrixByRow($i0 = null, $iF = null) { |
if (is_int($i0)) { |
if (is_int($iF)) { |
return $this->getMatrix($i0, 0, $iF + 1, $this->n); |
} else { |
return $this->getMatrix($i0, 0, $i0 + 1, $this->n); |
} |
} else { |
throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException); |
} |
} // function getMatrixByRow() |
|
|
/** |
* getMatrixByCol |
* |
* Get a submatrix by column index/range |
* @param int $i0 Initial column index |
* @param int $iF Final column index |
* @return Matrix Submatrix |
*/ |
public function getMatrixByCol($j0 = null, $jF = null) { |
if (is_int($j0)) { |
if (is_int($jF)) { |
return $this->getMatrix(0, $j0, $this->m, $jF + 1); |
} else { |
return $this->getMatrix(0, $j0, $this->m, $j0 + 1); |
} |
} else { |
throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException); |
} |
} // function getMatrixByCol() |
|
|
/** |
* transpose |
* |
* Tranpose matrix |
* @return Matrix Transposed matrix |
*/ |
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) { |
$R->set($j, $i, $this->A[$i][$j]); |
} |
} |
return $R; |
} // function transpose() |
|
|
/** |
* trace |
* |
* Sum of diagonal elements |
* @return float Sum of diagonal elements |
*/ |
public function trace() { |
$s = 0; |
$n = min($this->m, $this->n); |
for($i = 0; $i < $n; ++$i) { |
$s += $this->A[$i][$i]; |
} |
return $s; |
} // function trace() |
|
|
/** |
* uminus |
* |
* Unary minus matrix -A |
* @return Matrix Unary minus matrix |
*/ |
public function uminus() { |
} // function uminus() |
|
|
/** |
* plus |
* |
* A + B |
* @param mixed $B Matrix/Array |
* @return Matrix Sum |
*/ |
public function plus() { |
if (func_num_args() > 0) { |
$args = func_get_args(); |
$match = implode(",", array_map('gettype', $args)); |
|
switch($match) { |
case 'object': |
if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException); } |
break; |
case 'array': |
$M = new PHPExcel_Shared_JAMA_Matrix($args[0]); |
break; |
default: |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
break; |
} |
$this->checkMatrixDimensions($M); |
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]); |
} |
} |
return $M; |
} else { |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
} |
} // function plus() |
|
|
/** |
* plusEquals |
* |
* A = A + B |
* @param mixed $B Matrix/Array |
* @return Matrix Sum |
*/ |
public function plusEquals() { |
if (func_num_args() > 0) { |
$args = func_get_args(); |
$match = implode(",", array_map('gettype', $args)); |
|
switch($match) { |
case 'object': |
if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException); } |
break; |
case 'array': |
$M = new PHPExcel_Shared_JAMA_Matrix($args[0]); |
break; |
default: |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
break; |
} |
$this->checkMatrixDimensions($M); |
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],'"'); |
$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($this->A[$i][$j]); |
} |
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] += $value; |
} else { |
$this->A[$i][$j] = PHPExcel_Calculation_Functions::NaN(); |
} |
} |
} |
return $this; |
} else { |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
} |
} // function plusEquals() |
|
|
/** |
* minus |
* |
* A - B |
* @param mixed $B Matrix/Array |
* @return Matrix Sum |
*/ |
public function minus() { |
if (func_num_args() > 0) { |
$args = func_get_args(); |
$match = implode(",", array_map('gettype', $args)); |
|
switch($match) { |
case 'object': |
if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException); } |
break; |
case 'array': |
$M = new PHPExcel_Shared_JAMA_Matrix($args[0]); |
break; |
default: |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
break; |
} |
$this->checkMatrixDimensions($M); |
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]); |
} |
} |
return $M; |
} else { |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
} |
} // function minus() |
|
|
/** |
* minusEquals |
* |
* A = A - B |
* @param mixed $B Matrix/Array |
* @return Matrix Sum |
*/ |
public function minusEquals() { |
if (func_num_args() > 0) { |
$args = func_get_args(); |
$match = implode(",", array_map('gettype', $args)); |
|
switch($match) { |
case 'object': |
if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException); } |
break; |
case 'array': |
$M = new PHPExcel_Shared_JAMA_Matrix($args[0]); |
break; |
default: |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
break; |
} |
$this->checkMatrixDimensions($M); |
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],'"'); |
$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($this->A[$i][$j]); |
} |
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] -= $value; |
} else { |
$this->A[$i][$j] = PHPExcel_Calculation_Functions::NaN(); |
} |
} |
} |
return $this; |
} else { |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
} |
} // function minusEquals() |
|
|
/** |
* arrayTimes |
* |
* Element-by-element multiplication |
* Cij = Aij * Bij |
* @param mixed $B Matrix/Array |
* @return Matrix Matrix Cij |
*/ |
public function arrayTimes() { |
if (func_num_args() > 0) { |
$args = func_get_args(); |
$match = implode(",", array_map('gettype', $args)); |
|
switch($match) { |
case 'object': |
if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException); } |
break; |
case 'array': |
$M = new PHPExcel_Shared_JAMA_Matrix($args[0]); |
break; |
default: |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
break; |
} |
$this->checkMatrixDimensions($M); |
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]); |
} |
} |
return $M; |
} else { |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
} |
} // function arrayTimes() |
|
|
/** |
* arrayTimesEquals |
* |
* Element-by-element multiplication |
* Aij = Aij * Bij |
* @param mixed $B Matrix/Array |
* @return Matrix Matrix Aij |
*/ |
public function arrayTimesEquals() { |
if (func_num_args() > 0) { |
$args = func_get_args(); |
$match = implode(",", array_map('gettype', $args)); |
|
switch($match) { |
case 'object': |
if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException); } |
break; |
case 'array': |
$M = new PHPExcel_Shared_JAMA_Matrix($args[0]); |
break; |
default: |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
break; |
} |
$this->checkMatrixDimensions($M); |
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],'"'); |
$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($this->A[$i][$j]); |
} |
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] *= $value; |
} else { |
$this->A[$i][$j] = PHPExcel_Calculation_Functions::NaN(); |
} |
} |
} |
return $this; |
} else { |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
} |
} // function arrayTimesEquals() |
|
|
/** |
* arrayRightDivide |
* |
* Element-by-element right division |
* A / B |
* @param Matrix $B Matrix B |
* @return Matrix Division result |
*/ |
public function arrayRightDivide() { |
if (func_num_args() > 0) { |
$args = func_get_args(); |
$match = implode(",", array_map('gettype', $args)); |
|
switch($match) { |
case 'object': |
if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException); } |
break; |
case 'array': |
$M = new PHPExcel_Shared_JAMA_Matrix($args[0]); |
break; |
default: |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
break; |
} |
$this->checkMatrixDimensions($M); |
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],'"'); |
$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($this->A[$i][$j]); |
} |
if ((is_string($value)) && (strlen($value) > 0) && (!is_numeric($value))) { |
$value = trim($value,'"'); |
$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($value); |
} |
if ($validValues) { |
if ($value == 0) { |
// Trap for Divide by Zero error |
$M->set($i, $j, '#DIV/0!'); |
} else { |
$M->set($i, $j, $this->A[$i][$j] / $value); |
} |
} else { |
$M->set($i, $j, PHPExcel_Calculation_Functions::NaN()); |
} |
} |
} |
return $M; |
} else { |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
} |
} // function arrayRightDivide() |
|
|
/** |
* arrayRightDivideEquals |
* |
* Element-by-element right division |
* Aij = Aij / Bij |
* @param mixed $B Matrix/Array |
* @return Matrix Matrix Aij |
*/ |
public function arrayRightDivideEquals() { |
if (func_num_args() > 0) { |
$args = func_get_args(); |
$match = implode(",", array_map('gettype', $args)); |
|
switch($match) { |
case 'object': |
if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException); } |
break; |
case 'array': |
$M = new PHPExcel_Shared_JAMA_Matrix($args[0]); |
break; |
default: |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
break; |
} |
$this->checkMatrixDimensions($M); |
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); |
} |
} |
return $M; |
} else { |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
} |
} // function arrayRightDivideEquals() |
|
|
/** |
* arrayLeftDivide |
* |
* Element-by-element Left division |
* A / B |
* @param Matrix $B Matrix B |
* @return Matrix Division result |
*/ |
public function arrayLeftDivide() { |
if (func_num_args() > 0) { |
$args = func_get_args(); |
$match = implode(",", array_map('gettype', $args)); |
|
switch($match) { |
case 'object': |
if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException); } |
break; |
case 'array': |
$M = new PHPExcel_Shared_JAMA_Matrix($args[0]); |
break; |
default: |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
break; |
} |
$this->checkMatrixDimensions($M); |
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]); |
} |
} |
return $M; |
} else { |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
} |
} // function arrayLeftDivide() |
|
|
/** |
* arrayLeftDivideEquals |
* |
* Element-by-element Left division |
* Aij = Aij / Bij |
* @param mixed $B Matrix/Array |
* @return Matrix Matrix Aij |
*/ |
public function arrayLeftDivideEquals() { |
if (func_num_args() > 0) { |
$args = func_get_args(); |
$match = implode(",", array_map('gettype', $args)); |
|
switch($match) { |
case 'object': |
if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException); } |
break; |
case 'array': |
$M = new PHPExcel_Shared_JAMA_Matrix($args[0]); |
break; |
default: |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
break; |
} |
$this->checkMatrixDimensions($M); |
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]; |
} |
} |
return $M; |
} else { |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
} |
} // function arrayLeftDivideEquals() |
|
|
/** |
* times |
* |
* Matrix multiplication |
* @param mixed $n Matrix/Array/Scalar |
* @return Matrix Product |
*/ |
public function times() { |
if (func_num_args() > 0) { |
$args = func_get_args(); |
$match = implode(",", array_map('gettype', $args)); |
|
switch($match) { |
case 'object': |
if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $B = $args[0]; } else { throw new PHPExcel_Calculation_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 ($k = 0; $k < $this->n; ++$k) { |
$Bcolj[$k] = $B->A[$k][$j]; |
} |
for($i = 0; $i < $this->m; ++$i) { |
$Arowi = $this->A[$i]; |
$s = 0; |
for($k = 0; $k < $this->n; ++$k) { |
$s += $Arowi[$k] * $Bcolj[$k]; |
} |
$C->A[$i][$j] = $s; |
} |
} |
return $C; |
} else { |
throw new PHPExcel_Calculation_Exception(JAMAError(MatrixDimensionMismatch)); |
} |
break; |
case 'array': |
$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) { |
$s = "0"; |
for($k = 0; $k < $C->n; ++$k) { |
$s += $this->A[$i][$k] * $B->A[$k][$j]; |
} |
$C->A[$i][$j] = $s; |
} |
} |
return $C; |
} else { |
throw new PHPExcel_Calculation_Exception(JAMAError(MatrixDimensionMismatch)); |
} |
return $M; |
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) { |
$C->A[$i][$j] *= $args[0]; |
} |
} |
return $C; |
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) { |
$C->A[$i][$j] = $args[0] * $this->A[$i][$j]; |
} |
} |
return $C; |
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) { |
$C->A[$i][$j] *= $args[0]; |
} |
} |
return $C; |
break; |
default: |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
break; |
} |
} else { |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
} |
} // function times() |
|
|
/** |
* power |
* |
* A = A ^ B |
* @param mixed $B Matrix/Array |
* @return Matrix Sum |
*/ |
public function power() { |
if (func_num_args() > 0) { |
$args = func_get_args(); |
$match = implode(",", array_map('gettype', $args)); |
|
switch($match) { |
case 'object': |
if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException); } |
break; |
case 'array': |
$M = new PHPExcel_Shared_JAMA_Matrix($args[0]); |
break; |
default: |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
break; |
} |
$this->checkMatrixDimensions($M); |
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],'"'); |
$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($this->A[$i][$j]); |
} |
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); |
} else { |
$this->A[$i][$j] = PHPExcel_Calculation_Functions::NaN(); |
} |
} |
} |
return $this; |
} else { |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
} |
} // function power() |
|
|
/** |
* concat |
* |
* A = A & B |
* @param mixed $B Matrix/Array |
* @return Matrix Sum |
*/ |
public function concat() { |
if (func_num_args() > 0) { |
$args = func_get_args(); |
$match = implode(",", array_map('gettype', $args)); |
|
switch($match) { |
case 'object': |
if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix) { $M = $args[0]; } else { throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException); } |
case 'array': |
$M = new PHPExcel_Shared_JAMA_Matrix($args[0]); |
break; |
default: |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
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),'"'); |
} |
} |
return $this; |
} else { |
throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException); |
} |
} // function concat() |
|
|
/** |
* Solve A*X = B. |
* |
* @param Matrix $B Right hand side |
* @return Matrix ... Solution if A is square, least squares solution otherwise |
*/ |
public function solve($B) { |
if ($this->m == $this->n) { |
$LU = new PHPExcel_Shared_JAMA_LUDecomposition($this); |
return $LU->solve($B); |
} else { |
$QR = new QRDecomposition($this); |
return $QR->solve($B); |
} |
} // function solve() |
|
|
/** |
* Matrix inverse or pseudoinverse. |
* |
* @return Matrix ... Inverse(A) if A is square, pseudoinverse otherwise. |
*/ |
public function inverse() { |
return $this->solve($this->identity($this->m, $this->m)); |
} // function inverse() |
|
|
/** |
* det |
* |
* Calculate determinant |
* @return float Determinant |
*/ |
public function det() { |
$L = new PHPExcel_Shared_JAMA_LUDecomposition($this); |
return $L->det(); |
} // function det() |
|
|
} // class PHPExcel_Shared_JAMA_Matrix |