ONE PIECE HACKING

Ngiler SH3LL 360
: / home / tbf / cursbackend / vendor / markbaker / matrix / classes / src /

Information Server
MySQL : OFF Perl : OFF CURL : ON WGET : OFF PKEXEC : OFF

Directive	Local Value
IP Address	89.40.16.97
System	Linux server.atelieruldeit.ro 3.10.0-1160.el7.x86_64 #1 SMP Mon Oct 19 16:18:59 UTC 2020 x86_64
User	tbf
PHP Version	7.3.33
Software	Apache
Doc root	Writable

Edit File : Functions.php \| Size : 10.64 KB
<?php namespace Matrix; class Functions { /** * Validates an array of matrix, converting an array to a matrix if required. * * @param Matrix\|array $matrix Matrix or an array to treat as a matrix. * @return Matrix The new matrix * @throws Exception If argument isn't a valid matrix or array. / private static function validateMatrix($matrix) { if (is_array($matrix)) { $matrix = new Matrix($matrix); } if (!$matrix instanceof Matrix) { throw new Exception('Must be Matrix or array'); } return $matrix; } /* * Calculate the adjoint of the matrix * * @param Matrix $matrix The matrix whose adjoint we wish to calculate * @return Matrix * * @throws Exception / private static function getAdjoint(Matrix $matrix) { return self::transpose( self::getCofactors($matrix) ); } /* * Return the adjoint of this matrix * The adjugate, classical adjoint, or adjunct of a square matrix is the transpose of its cofactor matrix. * The adjugate has sometimes been called the "adjoint", but today the "adjoint" of a matrix normally refers * to its corresponding adjoint operator, which is its conjugate transpose. * * @param Matrix\|array $matrix The matrix whose adjoint we wish to calculate * @return Matrix * @throws Exception / public static function adjoint($matrix) { $matrix = self::validateMatrix($matrix); if (!$matrix->isSquare()) { throw new Exception('Adjoint can only be calculated for a square matrix'); } return self::getAdjoint($matrix); } / * Calculate the cofactors of the matrix * * @param Matrix $matrix The matrix whose cofactors we wish to calculate * @return Matrix * * @throws Exception / private static function getCofactors(Matrix $matrix) { $cofactors = self::getMinors($matrix); $dimensions = $matrix->rows; $cof = 1; for ($i = 0; $i < $dimensions; ++$i) { $cofs = $cof; for ($j = 0; $j < $dimensions; ++$j) { $cofactors[$i][$j] = $cofs; $cofs = -$cofs; } $cof = -$cof; } return new Matrix($cofactors); } /** * Return the cofactors of this matrix * * @param Matrix\|array $matrix The matrix whose cofactors we wish to calculate * @return Matrix * * @throws Exception / public static function cofactors($matrix) { $matrix = self::validateMatrix($matrix); if (!$matrix->isSquare()) { throw new Exception('Cofactors can only be calculated for a square matrix'); } return self::getCofactors($matrix); } /* * @param Matrix $matrix * @param int $row * @param int $column * @return float * @throws Exception / private static function getDeterminantSegment(Matrix $matrix, $row, $column) { $tmpMatrix = $matrix->toArray(); unset($tmpMatrix[$row]); array_walk( $tmpMatrix, function (&$row) use ($column) { unset($row[$column]); } ); return self::getDeterminant(new Matrix($tmpMatrix)); } /* * Calculate the determinant of the matrix * * @param Matrix $matrix The matrix whose determinant we wish to calculate * @return float * * @throws Exception / private static function getDeterminant(Matrix $matrix) { $dimensions = $matrix->rows; $determinant = 0; switch ($dimensions) { case 1: $determinant = $matrix->getValue(1, 1); break; case 2: $determinant = $matrix->getValue(1, 1) $matrix->getValue(2, 2) - $matrix->getValue(1, 2) * $matrix->getValue(2, 1); break; default: for ($i = 1; $i <= $dimensions; ++$i) { $det = $matrix->getValue(1, $i) * self::getDeterminantSegment($matrix, 0, $i - 1); if (($i % 2) == 0) { $determinant -= $det; } else { $determinant += $det; } } break; } return $determinant; } /** * Return the determinant of this matrix * * @param Matrix\|array $matrix The matrix whose determinant we wish to calculate * @return float * @throws Exception / public static function determinant($matrix) { $matrix = self::validateMatrix($matrix); if (!$matrix->isSquare()) { throw new Exception('Determinant can only be calculated for a square matrix'); } return self::getDeterminant($matrix); } / * Return the diagonal of this matrix * * @param Matrix\|array $matrix The matrix whose diagonal we wish to calculate * @return Matrix * @throws Exception / public static function diagonal($matrix) { $matrix = self::validateMatrix($matrix); if (!$matrix->isSquare()) { throw new Exception('Diagonal can only be extracted from a square matrix'); } $dimensions = $matrix->rows; $grid = Builder::createFilledMatrix(0, $dimensions, $dimensions) ->toArray(); for ($i = 0; $i < $dimensions; ++$i) { $grid[$i][$i] = $matrix->getValue($i + 1, $i + 1); } return new Matrix($grid); } / * Return the antidiagonal of this matrix * * @param Matrix\|array $matrix The matrix whose antidiagonal we wish to calculate * @return Matrix * @throws Exception / public static function antidiagonal($matrix) { $matrix = self::validateMatrix($matrix); if (!$matrix->isSquare()) { throw new Exception('Anti-Diagonal can only be extracted from a square matrix'); } $dimensions = $matrix->rows; $grid = Builder::createFilledMatrix(0, $dimensions, $dimensions) ->toArray(); for ($i = 0; $i < $dimensions; ++$i) { $grid[$i][$dimensions - $i - 1] = $matrix->getValue($i + 1, $dimensions - $i); } return new Matrix($grid); } / * Return the identity matrix * The identity matrix, or sometimes ambiguously called a unit matrix, of size n is the n × n square matrix * with ones on the main diagonal and zeros elsewhere * * @param Matrix\|array $matrix The matrix whose identity we wish to calculate * @return Matrix * @throws Exception / public static function identity($matrix) { $matrix = self::validateMatrix($matrix); if (!$matrix->isSquare()) { throw new Exception('Identity can only be created for a square matrix'); } $dimensions = $matrix->rows; return Builder::createIdentityMatrix($dimensions); } / * Return the inverse of this matrix * * @param Matrix\|array $matrix The matrix whose inverse we wish to calculate * @return Matrix * @throws Exception / public static function inverse($matrix, string $type = 'inverse') { $matrix = self::validateMatrix($matrix); if (!$matrix->isSquare()) { throw new Exception(ucfirst($type) . ' can only be calculated for a square matrix'); } $determinant = self::getDeterminant($matrix); if ($determinant == 0.0) { throw new Div0Exception(ucfirst($type) . ' can only be calculated for a matrix with a non-zero determinant'); } if ($matrix->rows == 1) { return new Matrix([[1 / $matrix->getValue(1, 1)]]); } return self::getAdjoint($matrix) ->multiply(1 / $determinant); } / * Calculate the minors of the matrix * * @param Matrix $matrix The matrix whose minors we wish to calculate * @return array[] * * @throws Exception / protected static function getMinors(Matrix $matrix) { $minors = $matrix->toArray(); $dimensions = $matrix->rows; if ($dimensions == 1) { return $minors; } for ($i = 0; $i < $dimensions; ++$i) { for ($j = 0; $j < $dimensions; ++$j) { $minors[$i][$j] = self::getDeterminantSegment($matrix, $i, $j); } } return $minors; } /* * Return the minors of the matrix * The minor of a matrix A is the determinant of some smaller square matrix, cut down from A by removing one or * more of its rows or columns. * Minors obtained by removing just one row and one column from square matrices (first minors) are required for * calculating matrix cofactors, which in turn are useful for computing both the determinant and inverse of * square matrices. * * @param Matrix\|array $matrix The matrix whose minors we wish to calculate * @return Matrix * @throws Exception / public static function minors($matrix) { $matrix = self::validateMatrix($matrix); if (!$matrix->isSquare()) { throw new Exception('Minors can only be calculated for a square matrix'); } return new Matrix(self::getMinors($matrix)); } / * Return the trace of this matrix * The trace is defined as the sum of the elements on the main diagonal (the diagonal from the upper left to the lower right) * of the matrix * * @param Matrix\|array $matrix The matrix whose trace we wish to calculate * @return float * @throws Exception / public static function trace($matrix) { $matrix = self::validateMatrix($matrix); if (!$matrix->isSquare()) { throw new Exception('Trace can only be extracted from a square matrix'); } $dimensions = $matrix->rows; $result = 0; for ($i = 1; $i <= $dimensions; ++$i) { $result += $matrix->getValue($i, $i); } return $result; } / * Return the transpose of this matrix * * @param Matrix\|\a $matrix The matrix whose transpose we wish to calculate * @return Matrix **/ public static function transpose($matrix) { $matrix = self::validateMatrix($matrix); $array = array_values(array_merge([null], $matrix->toArray())); $grid = call_user_func_array( 'array_map', $array ); return new Matrix($grid); } } Back

Edit File : Functions.php | Size : 10.64 KB

<?php

namespace Matrix;

class Functions
{
    /**
     * Validates an array of matrix, converting an array to a matrix if required.
     *
     * @param Matrix|array $matrix Matrix or an array to treat as a matrix.
     * @return Matrix The new matrix
     * @throws Exception If argument isn't a valid matrix or array.
     */
    private static function validateMatrix($matrix)
    {
        if (is_array($matrix)) {
            $matrix = new Matrix($matrix);
        }
        if (!$matrix instanceof Matrix) {
            throw new Exception('Must be Matrix or array');
        }

return $matrix;
    }

/**
     * Calculate the adjoint of the matrix
     *
     * @param Matrix $matrix The matrix whose adjoint we wish to calculate
     * @return Matrix
     *
     * @throws Exception
     */
    private static function getAdjoint(Matrix $matrix)
    {
        return self::transpose(
            self::getCofactors($matrix)
        );
    }

/**
     * Return the adjoint of this matrix
     * The adjugate, classical adjoint, or adjunct of a square matrix is the transpose of its cofactor matrix.
     * The adjugate has sometimes been called the "adjoint", but today the "adjoint" of a matrix normally refers
     *     to its corresponding adjoint operator, which is its conjugate transpose.
     *
     * @param Matrix|array $matrix The matrix whose adjoint we wish to calculate
     * @return Matrix
     * @throws Exception
     **/
    public static function adjoint($matrix)
    {
        $matrix = self::validateMatrix($matrix);

if (!$matrix->isSquare()) {
            throw new Exception('Adjoint can only be calculated for a square matrix');
        }

return self::getAdjoint($matrix);
    }

/**
     * Calculate the cofactors of the matrix
     *
     * @param Matrix $matrix The matrix whose cofactors we wish to calculate
     * @return Matrix
     *
     * @throws Exception
     */
    private static function getCofactors(Matrix $matrix)
    {
        $cofactors = self::getMinors($matrix);
        $dimensions = $matrix->rows;

$cof = 1;
        for ($i = 0; $i < $dimensions; ++$i) {
            $cofs = $cof;
            for ($j = 0; $j < $dimensions; ++$j) {
                $cofactors[$i][$j] *= $cofs;
                $cofs = -$cofs;
            }
            $cof = -$cof;
        }

return new Matrix($cofactors);
    }

/**
     * Return the cofactors of this matrix
     *
     * @param Matrix|array $matrix The matrix whose cofactors we wish to calculate
     * @return Matrix
     *
     * @throws Exception
     */
    public static function cofactors($matrix)
    {
        $matrix = self::validateMatrix($matrix);

if (!$matrix->isSquare()) {
            throw new Exception('Cofactors can only be calculated for a square matrix');
        }

return self::getCofactors($matrix);
    }

/**
     * @param Matrix $matrix
     * @param int $row
     * @param int $column
     * @return float
     * @throws Exception
     */
    private static function getDeterminantSegment(Matrix $matrix, $row, $column)
    {
        $tmpMatrix = $matrix->toArray();
        unset($tmpMatrix[$row]);
        array_walk(
            $tmpMatrix,
            function (&$row) use ($column) {
                unset($row[$column]);
            }
        );

return self::getDeterminant(new Matrix($tmpMatrix));
    }

/**
     * Calculate the determinant of the matrix
     *
     * @param Matrix $matrix The matrix whose determinant we wish to calculate
     * @return float
     *
     * @throws Exception
     */
    private static function getDeterminant(Matrix $matrix)
    {
        $dimensions = $matrix->rows;
        $determinant = 0;

switch ($dimensions) {
            case 1:
                $determinant = $matrix->getValue(1, 1);
                break;
            case 2:
                $determinant = $matrix->getValue(1, 1) * $matrix->getValue(2, 2) -
                    $matrix->getValue(1, 2) * $matrix->getValue(2, 1);
                break;
            default:
                for ($i = 1; $i <= $dimensions; ++$i) {
                    $det = $matrix->getValue(1, $i) * self::getDeterminantSegment($matrix, 0, $i - 1);
                    if (($i % 2) == 0) {
                        $determinant -= $det;
                    } else {
                        $determinant += $det;
                    }
                }
                break;
        }

return $determinant;
    }

/**
     * Return the determinant of this matrix
     *
     * @param Matrix|array $matrix The matrix whose determinant we wish to calculate
     * @return float
     * @throws Exception
     **/
    public static function determinant($matrix)
    {
        $matrix = self::validateMatrix($matrix);

if (!$matrix->isSquare()) {
            throw new Exception('Determinant can only be calculated for a square matrix');
        }

return self::getDeterminant($matrix);
    }

/**
     * Return the diagonal of this matrix
     *
     * @param Matrix|array $matrix The matrix whose diagonal we wish to calculate
     * @return Matrix
     * @throws Exception
     **/
    public static function diagonal($matrix)
    {
        $matrix = self::validateMatrix($matrix);

if (!$matrix->isSquare()) {
            throw new Exception('Diagonal can only be extracted from a square matrix');
        }

$dimensions = $matrix->rows;
        $grid = Builder::createFilledMatrix(0, $dimensions, $dimensions)
            ->toArray();

for ($i = 0; $i < $dimensions; ++$i) {
            $grid[$i][$i] = $matrix->getValue($i + 1, $i + 1);
        }

return new Matrix($grid);
    }

/**
     * Return the antidiagonal of this matrix
     *
     * @param Matrix|array $matrix The matrix whose antidiagonal we wish to calculate
     * @return Matrix
     * @throws Exception
     **/
    public static function antidiagonal($matrix)
    {
        $matrix = self::validateMatrix($matrix);

if (!$matrix->isSquare()) {
            throw new Exception('Anti-Diagonal can only be extracted from a square matrix');
        }

$dimensions = $matrix->rows;
        $grid = Builder::createFilledMatrix(0, $dimensions, $dimensions)
            ->toArray();

for ($i = 0; $i < $dimensions; ++$i) {
            $grid[$i][$dimensions - $i - 1] = $matrix->getValue($i + 1, $dimensions - $i);
        }

return new Matrix($grid);
    }

/**
     * Return the identity matrix
     * The identity matrix, or sometimes ambiguously called a unit matrix, of size n is the n × n square matrix
     *   with ones on the main diagonal and zeros elsewhere
     *
     * @param Matrix|array $matrix The matrix whose identity we wish to calculate
     * @return Matrix
     * @throws Exception
     **/
    public static function identity($matrix)
    {
        $matrix = self::validateMatrix($matrix);

if (!$matrix->isSquare()) {
            throw new Exception('Identity can only be created for a square matrix');
        }

$dimensions = $matrix->rows;

return Builder::createIdentityMatrix($dimensions);
    }

/**
     * Return the inverse of this matrix
     *
     * @param Matrix|array $matrix The matrix whose inverse we wish to calculate
     * @return Matrix
     * @throws Exception
     **/
    public static function inverse($matrix, string $type = 'inverse')
    {
        $matrix = self::validateMatrix($matrix);

if (!$matrix->isSquare()) {
            throw new Exception(ucfirst($type) . ' can only be calculated for a square matrix');
        }

$determinant = self::getDeterminant($matrix);
        if ($determinant == 0.0) {
            throw new Div0Exception(ucfirst($type) . ' can only be calculated for a matrix with a non-zero determinant');
        }

if ($matrix->rows == 1) {
            return new Matrix([[1 / $matrix->getValue(1, 1)]]);
        }

return self::getAdjoint($matrix)
            ->multiply(1 / $determinant);
    }

/**
     * Calculate the minors of the matrix
     *
     * @param Matrix $matrix The matrix whose minors we wish to calculate
     * @return array[]
     *
     * @throws Exception
     */
    protected static function getMinors(Matrix $matrix)
    {
        $minors = $matrix->toArray();
        $dimensions = $matrix->rows;
        if ($dimensions == 1) {
            return $minors;
        }

for ($i = 0; $i < $dimensions; ++$i) {
            for ($j = 0; $j < $dimensions; ++$j) {
                $minors[$i][$j] = self::getDeterminantSegment($matrix, $i, $j);
            }
        }

return $minors;
    }

/**
     * Return the minors of the matrix
     * The minor of a matrix A is the determinant of some smaller square matrix, cut down from A by removing one or
     *     more of its rows or columns.
     * Minors obtained by removing just one row and one column from square matrices (first minors) are required for
     *     calculating matrix cofactors, which in turn are useful for computing both the determinant and inverse of
     *     square matrices.
     *
     * @param Matrix|array $matrix The matrix whose minors we wish to calculate
     * @return Matrix
     * @throws Exception
     **/
    public static function minors($matrix)
    {
        $matrix = self::validateMatrix($matrix);

if (!$matrix->isSquare()) {
            throw new Exception('Minors can only be calculated for a square matrix');
        }

return new Matrix(self::getMinors($matrix));
    }

/**
     * Return the trace of this matrix
     * The trace is defined as the sum of the elements on the main diagonal (the diagonal from the upper left to the lower right)
     *     of the matrix
     *
     * @param Matrix|array $matrix The matrix whose trace we wish to calculate
     * @return float
     * @throws Exception
     **/
    public static function trace($matrix)
    {
        $matrix = self::validateMatrix($matrix);

if (!$matrix->isSquare()) {
            throw new Exception('Trace can only be extracted from a square matrix');
        }

$dimensions = $matrix->rows;
        $result = 0;
        for ($i = 1; $i <= $dimensions; ++$i) {
            $result += $matrix->getValue($i, $i);
        }

return $result;
    }

/**
     * Return the transpose of this matrix
     *
     * @param Matrix|\a $matrix The matrix whose transpose we wish to calculate
     * @return Matrix
     **/
    public static function transpose($matrix)
    {
        $matrix = self::validateMatrix($matrix);

$array = array_values(array_merge([null], $matrix->toArray()));
        $grid = call_user_func_array(
            'array_map',
            $array
        );

return new Matrix($grid);
    }
}

Back