view release on metacpan or  search on metacpan

README  view on Meta::CPAN

    size()
        You can determine the dimensions of a matrix by calling:

            ($m, $n) = $a -> size;

    nelm()
        Returns the number of elements in the matrix.

            $n = $x -> nelm();

    nrow()
        Returns the number of rows.

            $m = $x -> nrow();

    ncol()
        Returns the number of columns.

            $n = $x -> ncol();

    npag()
        Returns the number of pages. A non-matrix has one page.

            $n = $x -> pag();

    ndim()
        Returns the number of dimensions. This is the number of dimensions
        along which the length is different from one.

            $n = $x -> ndim();

    bandwidth()
        Returns the bandwidth of a matrix. In scalar context, returns the
        number of the non-zero diagonal furthest away from the main
        diagonal. In list context, separate values are returned for the
        lower and upper bandwidth.

            $n = $x -> bandwidth();
            ($l, $u) = $x -> bandwidth();

        The bandwidth is a non-negative integer. If the bandwidth is 0, the
        matrix is diagonal or zero. If the bandwidth is 1, the matrix is
        tridiagonal. If the bandwidth is 2, the matrix is pentadiagonal etc.

        A matrix with the following pattern, where "x" denotes a non-zero
        value, would return 2 in scalar context, and (1,2) in list context.

            [ x x x 0 0 0 ]
            [ x x x x 0 0 ]
            [ 0 x x x x 0 ]
            [ 0 0 x x x x ]
            [ 0 0 0 x x x ]
            [ 0 0 0 0 x x ]

        See also "is_band()" and "is_aband()".

  Manipulate matrices
    These methods are for combining matrices, splitting matrices, extracing
    parts of a matrix, inserting new parts into a matrix, deleting parts of
    a matrix etc. There are also methods for shuffling elements around
    (relocating elements) inside a matrix.

    These methods are not concerned with the values of the elements.

    catrow()
        Concatenate rows, i.e., concatenate matrices vertically. Any number
        of arguments is allowed. All non-empty matrices must have the same
        number or columns. The result is a new matrix.

            $x = Math::Matrix -> new([1, 2], [4, 5]);   # 2-by-2 matrix
            $y = Math::Matrix -> new([3, 6]);           # 1-by-2 matrix
            $z = $x -> catrow($y);                      # 3-by-2 matrix

    catcol()
        Concatenate columns, i.e., matrices horizontally. Any number of
        arguments is allowed. All non-empty matrices must have the same
        number or rows. The result is a new matrix.

            $x = Math::Matrix -> new([1, 2], [4, 5]);   # 2-by-2 matrix
            $y = Math::Matrix -> new([3], [6]);         # 2-by-1 matrix
            $z = $x -> catcol($y);                      # 2-by-3 matrix

    getrow()
        Get the specified row(s). Returns a new matrix with the specified
        rows. The number of rows in the output is identical to the number of
        elements in the input.

            $y = $x -> getrow($i);                  # get one
            $y = $x -> getrow([$i0, $i1, $i2]);     # get multiple

    getcol()
        Get the specified column(s). Returns a new matrix with the specified
        columns. The number of columns in the output is identical to the
        number of elements in the input.

            $y = $x -> getcol($j);                  # get one
            $y = $x -> getcol([$j0, $j1, $j2]);     # get multiple

    delrow()
        Delete row(s). Returns a new matrix identical to the invocand but
        with the specified row(s) deleted.

            $y = $x -> delrow($i);                  # delete one
            $y = $x -> delrow([$i0, $i1, $i2]);     # delete multiple

    delcol()
        Delete column(s). Returns a new matrix identical to the invocand but
        with the specified column(s) deleted.

            $y = $x -> delcol($j);                  # delete one
            $y = $x -> delcol([$j0, $j1, $j2]);     # delete multiple

    concat()
        Concatenate two matrices horizontally. The matrices must have the
        same number of rows. The result is a new matrix or undef in case of
        error.

            $x = Math::Matrix -> new([1, 2], [4, 5]);   # 2-by-2 matrix
            $y = Math::Matrix -> new([3], [6]);         # 2-by-1 matrix
            $z = $x -> concat($y);                      # 2-by-3 matrix