<?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 = [];

    /**
     *	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 (0 != $this->m) {
                            $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
     *	@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 self($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 self($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 self($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 self($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 self($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 self($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 bool
     */
    public function checkMatrixDimensions($B = null)
    {
        if ($B instanceof self) {
            if (($this->m == $B->getRowDimension()) && ($this->n == $B->getColumnDimension())) {
                return true;
            }
            throw new PHPExcel_Calculation_Exception(self::MatrixDimensionException);
        }
        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 self($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);
            }

            return $this->getMatrix($i0, 0, $i0 + 1, $this->n);
        }
        throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
    }

    //	function getMatrixByRow()

    /**
     *	getMatrixByCol
     *
     *	Get a submatrix by column index/range
     * @param null|mixed $j0
     * @param null|mixed $jF
     *	@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);
            }

            return $this->getMatrix(0, $j0, $this->m, $j0 + 1);
        }
        throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
    }

    //	function getMatrixByCol()

    /**
     *	transpose
     *
     *	Tranpose matrix
     *	@return Matrix Transposed matrix
     */
    public function transpose()
    {
        $R = new self($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
     *	@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 self) {
                            $M = $args[0];
                        } else {
                            throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
                        }
                        break;
                case 'array':
                        $M = new self($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;
        }
        throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
    }

    //	function plus()

    /**
     *	plusEquals
     *
     *	A = A + B
     *	@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 self) {
                            $M = $args[0];
                        } else {
                            throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
                        }
                        break;
                case 'array':
                        $M = new self($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])) && (mb_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)) && (mb_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;
        }
        throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
    }

    //	function plusEquals()

    /**
     *	minus
     *
     *	A - B
     *	@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 self) {
                            $M = $args[0];
                        } else {
                            throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
                        }
                        break;
                case 'array':
                        $M = new self($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;
        }
        throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
    }

    //	function minus()

    /**
     *	minusEquals
     *
     *	A = A - B
     *	@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 self) {
                            $M = $args[0];
                        } else {
                            throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
                        }
                        break;
                case 'array':
                        $M = new self($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])) && (mb_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)) && (mb_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;
        }
        throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
    }

    //	function minusEquals()

    /**
     *	arrayTimes
     *
     *	Element-by-element multiplication
     *	Cij = Aij * Bij
     *	@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 self) {
                            $M = $args[0];
                        } else {
                            throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
                        }
                        break;
                case 'array':
                        $M = new self($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;
        }
        throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
    }

    //	function arrayTimes()

    /**
     *	arrayTimesEquals
     *
     *	Element-by-element multiplication
     *	Aij = Aij * Bij
     *	@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 self) {
                            $M = $args[0];
                        } else {
                            throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
                        }
                        break;
                case 'array':
                        $M = new self($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])) && (mb_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)) && (mb_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;
        }
        throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
    }

    //	function arrayTimesEquals()

    /**
     *	arrayRightDivide
     *
     *	Element-by-element right division
     *	A / 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 self) {
                            $M = $args[0];
                        } else {
                            throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
                        }
                        break;
                case 'array':
                        $M = new self($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])) && (mb_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)) && (mb_strlen($value) > 0) && (!is_numeric($value))) {
                        $value = trim($value, '"');
                        $validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($value);
                    }
                    if ($validValues) {
                        if (0 == $value) {
                            //	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;
        }
        throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
    }

    //	function arrayRightDivide()

    /**
     *	arrayRightDivideEquals
     *
     *	Element-by-element right division
     *	Aij = Aij / Bij
     *	@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 self) {
                            $M = $args[0];
                        } else {
                            throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
                        }
                        break;
                case 'array':
                        $M = new self($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;
        }
        throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
    }

    //	function arrayRightDivideEquals()

    /**
     *	arrayLeftDivide
     *
     *	Element-by-element Left division
     *	A / 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 self) {
                            $M = $args[0];
                        } else {
                            throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
                        }
                        break;
                case 'array':
                        $M = new self($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;
        }
        throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
    }

    //	function arrayLeftDivide()

    /**
     *	arrayLeftDivideEquals
     *
     *	Element-by-element Left division
     *	Aij = Aij / Bij
     *	@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 self) {
                            $M = $args[0];
                        } else {
                            throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
                        }
                        break;
                case 'array':
                        $M = new self($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;
        }
        throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
    }

    //	function arrayLeftDivideEquals()

    /**
     *	times
     *
     *	Matrix multiplication
     *	@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 self) {
                            $B = $args[0];
                        } else {
                            throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
                        }
                        if ($this->n == $B->m) {
                            $C = new self($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;
                        }
                            throw new PHPExcel_Calculation_Exception(JAMAError(MatrixDimensionMismatch));
                        break;
                case 'array':
                        $B = new self($args[0]);
                        if ($this->n == $B->m) {
                            $C = new self($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;
                        }
                            throw new PHPExcel_Calculation_Exception(JAMAError(MatrixDimensionMismatch));

                        return $M;
                        break;
                case 'integer':
                        $C = new self($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 self($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 self($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
     *	@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 self) {
                            $M = $args[0];
                        } else {
                            throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
                        }
                        break;
                case 'array':
                        $M = new self($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])) && (mb_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)) && (mb_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;
        }
        throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
    }

    //	function power()

    /**
     *	concat
     *
     *	A = A & B
     *	@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 self) {
                            $M = $args[0];
                        } else {
                            throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
                        }
                        // no break
                case 'array':
                        $M = new self($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;
        }
        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);
        }
        $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();
    }

    //	function det()
}	//	class PHPExcel_Shared_JAMA_Matrix
