<?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();
    }    //    function det()
}    //    class PHPExcel_Shared_JAMA_Matrix