Matrix.php in Loft Data Grids 7.2

File

vendor/phpoffice/phpexcel/Classes/PHPExcel/Shared/JAMA/Matrix.php

<?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 PHPExcel_Shared_JAMA_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();
  }

}

//	class PHPExcel_Shared_JAMA_Matrix

Classes

Name	Description
PHPExcel_Shared_JAMA_Matrix