JLMatrix R

jobject.spad line 1655 [edit on github]

This domain provides a generic Julia matrix type stored in Julia with no bound checking on elt's. Minimum index is 1. Beware, for matrix with Nemo elements, contrary to Julia matrix, Nemo follows the C language convention, it wraps and uses row major representation.

#: % -> NonNegativeInteger

from Aggregate

*: (%, %) -> %

from MatrixOperationsCategory(R, JLVector R, JLVector R)

*: (%, JLVector R) -> JLVector R

from MatrixCategory(R, JLVector R, JLVector R)

*: (%, R) -> %

from MatrixOperationsCategory(R, JLVector R, JLVector R)

*: (Integer, %) -> %

from MatrixOperationsCategory(R, JLVector R, JLVector R)

*: (JLVector R, %) -> JLVector R

from MatrixCategory(R, JLVector R, JLVector R)

*: (R, %) -> %

from MatrixOperationsCategory(R, JLVector R, JLVector R)

+: (%, %) -> %

from MatrixOperationsCategory(R, JLVector R, JLVector R)

-: % -> %

from MatrixOperationsCategory(R, JLVector R, JLVector R)

-: (%, %) -> %

from MatrixOperationsCategory(R, JLVector R, JLVector R)

/: (%, R) -> % if R has Field

from MatrixOperationsCategory(R, JLVector R, JLVector R)

=: (%, %) -> Boolean

from BasicType

^: (%, Integer) -> % if R has Field

from MatrixCategory(R, JLVector R, JLVector R)

^: (%, NonNegativeInteger) -> %

from MatrixCategory(R, JLVector R, JLVector R)

~=: (%, %) -> Boolean

from BasicType

antisymmetric?: % -> Boolean

from MatrixOperationsCategory(R, JLVector R, JLVector R)

any?: (R -> Boolean, %) -> Boolean

from HomogeneousAggregate R

array2: List List R -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

blockConcat: List List % -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

blockSplit: (%, List NonNegativeInteger, List NonNegativeInteger) -> List List %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

blockSplit: (%, PositiveInteger, PositiveInteger) -> List List %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

coerce: % -> JLObject

from JLObjectType

coerce: % -> Matrix R

coerce(m) coerces a copy of m to a Matrix(R).

coerce: % -> OutputForm

from CoercibleTo OutputForm

coerce: JLComplexF32Matrix -> JLMatrix JLObjComplexF32

coerce(x): convenience function.

coerce: JLComplexF64Matrix -> JLMatrix JLObjComplexF64

coerce(x): convenience function.

coerce: JLFloat32Matrix -> JLMatrix JLObjFloat32

coerce(x): convenience function.

coerce: JLFloat64Matrix -> JLMatrix JLObjFloat64

coerce(x): convenience function.

coerce: JLVector R -> %

from MatrixCategory(R, JLVector R, JLVector R)

colSlice: % -> Segment Integer

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

column: (%, Integer) -> JLVector R

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

columnSpace: % -> List JLVector R if R has EuclideanDomain

from MatrixOperationsCategory(R, JLVector R, JLVector R)

convert: % -> String

from ConvertibleTo String

copy: % -> %

from Aggregate

count: (R -> Boolean, %) -> NonNegativeInteger

from HomogeneousAggregate R

count: (R, %) -> NonNegativeInteger

from HomogeneousAggregate R

determinant: % -> R if R has CommutativeRing

from MatrixCategory(R, JLVector R, JLVector R)

determinantDivisor: JLMatrix NMInteger -> NMInteger

determinantDivisor(mat) returns some divisor of the determinant of mat. 0 if the determinant is 0.

determinantGivenDivisor: (JLMatrix NMInteger, NMInteger) -> NMInteger

determinantGivenDivisor(mat, d) returns the determinant of mat from the divisor d.

diagonal?: % -> Boolean

from MatrixOperationsCategory(R, JLVector R, JLVector R)

diagonalMatrix: JLVector R -> %

diagonalMatrix(v) returns a diagonal matrix with elements of v.

diagonalMatrix: List % -> %

from MatrixCategory(R, JLVector R, JLVector R)

diagonalMatrix: List R -> %

from MatrixCategory(R, JLVector R, JLVector R)

eigenSpaces: (%, JLSymbol) -> JLObjDict if R has NMField

eigenSpace(mat, side) returns a Julia Dict containing the :left or :right side of the eigen space of mat associated to the eigenvalue key. example{a:=matrix([[111::NPF(127),91,50],[31,6,97],[117,63,6]])$JLMatrix(NPF(127))} example{eigenSpaces(a, “left”)}

eigenSpaces: (String, %, JLSymbol) -> JLObjDict if R has NMRing

eigenSpaces(JRing, mat, side) returns a Julia Dict containing the :left or :right side of the eigen space of mat associated to the eigenvalue key and the field JRing. example{a:=matrix([[111::NINT,91,50],[31,6,97],[117,63,6]])$JLMatrix(NINT)} example{eigenSpaces(jlNMRing()$NAN, a, “left”)}

eigenvalues: % -> JLVector R if R has NMField

eigenvalues(mat) returns a Julia vector containing the eigenvalues of mat. example{a:=matrix([[111::NPF(127),91,50],[31,6,97],[117,63,6]])$JLMatrix(NPF(127))} example{eigenvalues(a)}

eigenvalues: (String, %) -> JLVector JLObject if R has NMRing

eigenvalues(JRing, mat) returns a Julia vector containing the eigenvalues of mat in the field JRing. The Julia vector of JLObject is of internal type JLRing. example{a:=matrix([[111::NINT,91,50],[31,6,97],[117,63,6]])$JLMatrix(NINT)} example{eigenvalues(jlNMRing()$NCF, a)}

eigenvaluesWithMultiplicities: % -> JLVector JLObjTuple if R has NMField

eigenvaluesWithMultiplicities(mat) returns a Julia vector containing Julia tuples of the eigenvalues and their multiplicities. The tuples are of internal type (%, JLObjInt64). example{a:=matrix([[111::NPF(127),91,50],[31,6,97],[117,63,6]])$JLMatrix(NPF(127))} example{eigenvaluesWithMultiplicities(a)}

eigenvaluesWithMultiplicities: (String, %) -> JLVector JLObjTuple if R has NMRing

eigenvaluesWithMultiplicities(JRing, mat) returns a Julia vector containing Julia tuples of the eigenvalues and their multiplicities in the field JRing. The tuples are of internal type (JLRing, JLObjInt64). example{a:=matrix([[111::NINT,91,50],[31,6,97],[117,63,6]])$JLMatrix(NINT)} example{eigenvaluesWithMultiplicities(jlNMRing()$NCF, a)}

elt: (%, Integer) -> JLObject

from JLObjectAggregate

elt: (%, Integer, Integer) -> R

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

elt: (%, Integer, Integer, R) -> R

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

elt: (%, Integer, List Integer) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

elt: (%, Integer, List Segment Integer) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

elt: (%, JLSymbol) -> JLObject

from JLObjectAggregate

elt: (%, List Integer, Integer) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

elt: (%, List Integer, List Integer) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

elt: (%, List Integer, Segment Integer) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

elt: (%, List Segment Integer, Integer) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

elt: (%, List Segment Integer, List Segment Integer) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

elt: (%, List Segment Integer, Segment Integer) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

elt: (%, Segment Integer, List Integer) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

elt: (%, Segment Integer, List Segment Integer) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

elt: (%, Segment Integer, Segment Integer) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

empty?: % -> Boolean

from Aggregate

empty: () -> %

from Aggregate

eq?: (%, %) -> Boolean

from Aggregate

eval: (%, Equation R) -> % if R has Evalable R

from Evalable R

eval: (%, List Equation R) -> % if R has Evalable R

from Evalable R

eval: (%, List R, List R) -> % if R has Evalable R

from InnerEvalable(R, R)

eval: (%, R, R) -> % if R has Evalable R

from InnerEvalable(R, R)

every?: (R -> Boolean, %) -> Boolean

from HomogeneousAggregate R

exprand: (PositiveInteger, PositiveInteger) -> JLMatrix JLFloat if R has FloatingPointSystem and R hasn’t NMType and R has arbitraryPrecision

exprand(m,n) returns a JLMatrix of size (m,n) with exponentially distributed random numbers. example{mat := exprand(4,4)$JLMatrix(JLFloat)} example{svd := jlApply(“svd”, mat)}

exquo: (%, R) -> Union(%, failed) if R has IntegralDomain

from MatrixOperationsCategory(R, JLVector R, JLVector R)

factorize: JLMatrix JLObjComplexF32 -> JLObject

factorize(m) factorizes m using a suited matrix factorization for m. For a symmetric matrix the Bunch-Kaufman factorization will be chosen whereas for generic matrices, a LU or a QR factorization will be used.

factorize: JLMatrix JLObjComplexF64 -> JLObject

factorize(m) factorizes m using a suited matrix factorization for m. For a symmetric matrix the Bunch-Kaufman factorization will be chosen whereas for generic matrices, a LU or a QR factorization will be used.

factorize: JLMatrix JLObjFloat32 -> JLObject

factorize(m) factorizes m using a suited matrix factorization for m. For a symmetric matrix the Bunch-Kaufman factorization will be chosen whereas for generic matrices, a LU or a QR factorization will be used.

factorize: JLMatrix JLObjFloat64 -> JLObject

factorize(m) factorizes m using a suited matrix factorization for m. For a symmetric matrix the Bunch-Kaufman factorization will be chosen whereas for generic matrices, a LU or a QR factorization will be used.

fill!: (%, R) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

gram: % -> % if R has NMRing

gram(mat) returns the Gram matrix of mat.

gramSchmidtOrthogonalisation: JLMatrix NMFraction NMInteger -> JLMatrix NMFraction NMInteger

gramSchmidtOrthogonalisation(mat) returns the Gram-Schmidt orthogonalization of mat.

hash: % -> SingleInteger if R has Hashable

from Hashable

hashUpdate!: (HashState, %) -> HashState if R has Hashable

from Hashable

hermite: JLMatrix NMInteger -> JLMatrix NMInteger

hermite(mat) returns the Hermite normal form of mat.

hermiteModular: (JLMatrix NMInteger, NMInteger) -> JLMatrix NMInteger

hermiteModular(mat, n) returns the Hermite normal form of mat where n is a multiple of the determinant of the nonzero rows of mat.

hermiteModularElDiv: (JLMatrix NMInteger, NMInteger) -> JLMatrix NMInteger

hermiteModularElDiv(mat, n) returns the Hermite normal form of mat where n is a multiple of the largest elementary divisor of the full rank mat.

hessenberg: % -> % if R has NMRing

hessenberg(mat) returns the Hessenberg form of mat.

horizConcat: (%, %) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

horizConcat: List % -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

horizSplit: (%, List NonNegativeInteger) -> List %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

horizSplit: (%, PositiveInteger) -> List %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

howellForm: % -> % if R has NMRing and R has Finite

howellForm(mat) returns the Howell normal form of mat. Only supported for NMIntegerMod.

identity: NonNegativeInteger -> %

identity(n) returns a n by n identity matrix.

inverse: % -> %

inverse(m) returns inverse matrix. Throws a Julia error if m is not invertible.

inverse: % -> Union(%, failed) if R has Field

from MatrixCategory(R, JLVector R, JLVector R)

invertIfCan: % -> Union(%, failed) if R has IntegralDomain

invertIfCan(m) returns the inverse of the matrix m. If the matrix is not invertible, “failed” is returned. Error: if the matrix is not square.

jlAbout: % -> Void

from JLObjectType

jlApply: (String, %) -> JLObject

from JLObjectType

jlApply: (String, %, %) -> JLObject

from JLObjectType

jlApply: (String, %, %, %) -> JLObject

from JLObjectType

jlApply: (String, %, %, %, %) -> JLObject

from JLObjectType

jlApply: (String, %, %, %, %, %) -> JLObject

from JLObjectType

jlApprox?: (%, %) -> Boolean if R hasn’t NMType

jlApprox?(A,B) computes component-wise inexact equality with default parameters. Two numbers compare equal if their relative distance or their absolute distance is within tolerance bounds.

jlDisplay: % -> Void

from JLObjectType

jlDump: JLObject -> Void

from JLObjectType

jlFieldNames: % -> JLObject

from JLObjectType

jlGetField: (%, JLSymbol) -> JLObject

from JLObjectType

jlGetJuliaIndex: % -> String

from JLObjectType

jlGetProperty: (%, JLSymbol) -> JLObject

from JLObjectType

jlId: % -> JLInt64

from JLObjectType

jlimref: String -> %

from JLObjectType

jlObject: () -> String

from JLObjectType

jlPropertyNames: % -> JLObject

from JLObjectType

jlRef: % -> SExpression

from JLObjectType

jlref: String -> %

from JLObjectType

jlText: (%, String) -> List String

from JLObjectType

jlType: % -> Symbol

from JLObjectType

jmatrix: String -> %

jmatrix(str) evaluates the string str and returns the generated matrix. No checks are done at the FriCAS level.

kronecker_prod1: (%, Integer, List List NonNegativeInteger, List %, NonNegativeInteger, NonNegativeInteger, Union(R, one)) -> Void

from MatrixCategory(R, JLVector R, JLVector R)

kroneckerProduct: (%, %) -> %

from MatrixCategory(R, JLVector R, JLVector R)

kroneckerProduct: List % -> %

from MatrixCategory(R, JLVector R, JLVector R)

kroneckerSum: (%, %) -> %

from MatrixCategory(R, JLVector R, JLVector R)

kroneckerSum: List % -> %

from MatrixCategory(R, JLVector R, JLVector R)

latex: % -> String

from SetCategory

less?: (%, NonNegativeInteger) -> Boolean

from Aggregate

listOfLists: % -> List List R

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

lll: (JLMatrix NMInteger, JLObject) -> JLMatrix NMInteger

lll(mat, cont) returns the LLL-reduced lattice basis reduction of mat with context cont. See the Nemo documentation for more information on the context cont. lll! can also be used inplace, see jlApply.

lll: JLMatrix NMInteger -> JLMatrix NMInteger

lll(mat) returns the LLL-reduced lattice basis reduction of mat. lll! can also be used inplace, see jlApply.

lllGram: (JLMatrix NMInteger, JLObject) -> JLMatrix NMInteger

lllGram(mat, cont) returns the Gram LLL-reduced lattice basis reduction of the Gram matrix mat with context cont. See the Nemo documentation for more information about the context cont. lllGram! can also be used inplace, see jlApply.

lllGram: JLMatrix NMInteger -> JLMatrix NMInteger

lllGram(mat) returns the Gram LLL-reduced lattice basis reduction of the Gram matrix mat. lllGram! can also be used inplace, see jlApply.

map!: (R -> R, %) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

map: ((R, R) -> R, %, %) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

map: ((R, R) -> R, %, %, R) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

map: (R -> R, %) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

matrix: (NonNegativeInteger, NonNegativeInteger, (Integer, Integer) -> R) -> %

from MatrixCategory(R, JLVector R, JLVector R)

matrix: List List R -> %

from MatrixCategory(R, JLVector R, JLVector R)

max: % -> R if R has OrderedSet

from HomogeneousAggregate R

max: ((R, R) -> Boolean, %) -> R

from HomogeneousAggregate R

maxColIndex: % -> Integer

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

maxRowIndex: % -> Integer

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

member?: (R, %) -> Boolean

from HomogeneousAggregate R

members: % -> List R

from HomogeneousAggregate R

min: % -> R if R has OrderedSet

from HomogeneousAggregate R

minColIndex: % -> Integer

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

minordet: % -> R if R has CommutativeRing

from MatrixCategory(R, JLVector R, JLVector R)

minRowIndex: % -> Integer

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

missing?: % -> Boolean

from JLObjectType

more?: (%, NonNegativeInteger) -> Boolean

from Aggregate

mutable?: % -> Boolean

from JLObjectType

ncols: % -> NonNegativeInteger

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

new: (NonNegativeInteger, NonNegativeInteger, R) -> %

new(m, n, x) creates a matrix of size m by n with all elements x.

nothing?: % -> Boolean

from JLObjectType

nrand: (PositiveInteger, PositiveInteger) -> JLMatrix JLComplexFloat if R hasn’t NMType and R has ComplexCategory JLFloat

nrand(m,n) returns a JLMatrix of size (m,n) with normally distributed random numbers. example{mat := nrand(4,4)$JLMatrix(JLComplexFloat)} example{qr := jlApply(“qr”, mat)} example{qr.Q * qr.R}

nrand: (PositiveInteger, PositiveInteger) -> JLMatrix JLFloat if R has FloatingPointSystem and R hasn’t NMType and R has arbitraryPrecision

nrand(m,n) returns a JLMatrix of size (m,n) with normally distributed random numbers. For example: example{mat := nrand(4,4)$JLMatrix(JLFloat)} example{chol := jlApply(“cholesky”, mat * transpose(mat))} example{chol.L * chol.U}

nrows: % -> NonNegativeInteger

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

nullity: % -> NonNegativeInteger if R has IntegralDomain

from MatrixOperationsCategory(R, JLVector R, JLVector R)

nullSpace: % -> List JLVector R if R has IntegralDomain

from MatrixOperationsCategory(R, JLVector R, JLVector R)

nullspace: % -> Record(v: JLObjInt64, N: %) if R has NMRing

nullspace(mat) returns a record (v, N), v being the nullity ν of mat and N being a basis of the right nullspace of mat. i.e. M*N = 0.

nullspaceRightRational: JLMatrix NMInteger -> Record(r: JLObjInt64, U: JLMatrix NMInteger)

nullspaceRightRational(mat) returns the Q-basis of the right nullspace of mat. mat is considered as a matrix over rational. The record (r, U) returned is such that the first r columns of U form the Q-basis of the right nullspace of mat.

parts: % -> List R

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

Pfaffian: % -> R if R has CommutativeRing

from MatrixCategory(R, JLVector R, JLVector R)

positivePower: (%, Integer) -> %

from MatrixCategory(R, JLVector R, JLVector R)

qelt: (%, Integer) -> JLObject

from JLObjectAggregate

qelt: (%, Integer, Integer) -> R

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

qelt: (%, JLSymbol) -> JLObject

from JLObjectAggregate

qnew: (NonNegativeInteger, NonNegativeInteger) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

qsetelt!: (%, Integer, Integer, R) -> R

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

radicalEigenvalues: % -> JLVector NMAlgebraicNumber if R has NMRing and R has Algebra NMFraction NMInteger or R has NMRing and R has IntegerNumberSystem

radicalEigenvalues(mat) returns a Julia vector containing the eigenvalues of mat.

radicalEigenvaluesWithMultiplicities: % -> JLVector JLObjTuple if R has NMRing and R has Algebra NMFraction NMInteger or R has NMRing and R has IntegerNumberSystem

radicalEigenvaluesWithMultiplicities(mat) returns a Julia vector containing Julia tuples of the eigenvalues and their multiplicities. The tuples are of internal type (NMAlgebraicNumber, JLObjInt64).

rank: % -> NonNegativeInteger if R has IntegralDomain

from MatrixOperationsCategory(R, JLVector R, JLVector R)

row: (%, Integer) -> JLVector R

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

rowEchelon: % -> % if R has EuclideanDomain

from MatrixOperationsCategory(R, JLVector R, JLVector R)

rowSlice: % -> Segment Integer

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

sample: %

from Aggregate

scalarMatrix: (NonNegativeInteger, R) -> %

from MatrixCategory(R, JLVector R, JLVector R)

setColumn!: (%, Integer, JLVector R) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

setelt!: (%, Integer, Integer, R) -> R

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

setelt!: (%, Integer, List Integer, %) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

setelt!: (%, Integer, List Segment Integer, %) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

setelt!: (%, List Integer, Integer, %) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

setelt!: (%, List Integer, List Integer, %) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

setelt!: (%, List Integer, Segment Integer, %) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

setelt!: (%, List Segment Integer, Integer, %) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

setelt!: (%, List Segment Integer, List Segment Integer, %) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

setelt!: (%, List Segment Integer, Segment Integer, %) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

setelt!: (%, Segment Integer, List Integer, %) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

setelt!: (%, Segment Integer, List Segment Integer, %) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

setelt!: (%, Segment Integer, Segment Integer, %) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

setRow!: (%, Integer, JLVector R) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

setsubMatrix!: (%, Integer, Integer, %) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

size?: (%, NonNegativeInteger) -> Boolean

from Aggregate

smaller?: (%, %) -> Boolean if R has Comparable

from Comparable

smith: JLMatrix NMInteger -> JLMatrix NMInteger

smith(mat) returns the Smith normal form of mat.

smithDiagonal: JLMatrix NMInteger -> JLMatrix NMInteger

smithDiagonal(mat) returns the Smith normal form of the diagonal matrix mat.

square?: % -> Boolean

from MatrixOperationsCategory(R, JLVector R, JLVector R)

squareTop: % -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

string: % -> String

from JLType

strongEchelonForm: % -> % if R has NMRing and R has Finite

strongEchelonForm(mat) returns the strong echelon form of mat. Only supported for NMIntegerMod.

subMatrix: (%, Integer, Integer, Integer, Integer) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

swapColumns!: (%, Integer, Integer) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

swapRows!: (%, Integer, Integer) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

symmetric?: % -> Boolean

from MatrixOperationsCategory(R, JLVector R, JLVector R)

trace: % -> R

trace(m) returns the trace of square matrix m. Julia error if m is not square.

transpose: % -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

transpose: JLVector R -> %

from MatrixCategory(R, JLVector R, JLVector R)

urand01: (PositiveInteger, PositiveInteger) -> JLMatrix JLComplexFloat if R hasn’t NMType and R has ComplexCategory JLFloat

urand01(m,n) returns a JLMatrix of size (m,n) with uniformly distributed random number contained in the unit disk. example{mat := urand01(4,4)$JLMatrix(JLComplexFloat)} example{qr := jlApply(“qr”, mat)} example{qr.Q * qr.R}

urand01: (PositiveInteger, PositiveInteger) -> JLMatrix JLFloat if R has FloatingPointSystem and R hasn’t NMType and R has arbitraryPrecision

urand01(m,n) returns a JLMatrix of size (m,n) with uniformly distributed random number contained in [0,1]. example{mat := urand01(4,4)$JLMatrix(JLFloat)} example{qr := jlApply(“qr”, mat)} example{qr.Q * qr.R}

vertConcat: (%, %) -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

vertConcat: List % -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

vertSplit: (%, List NonNegativeInteger) -> List %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

vertSplit: (%, PositiveInteger) -> List %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

zero?: % -> Boolean

from MatrixOperationsCategory(R, JLVector R, JLVector R)

zero: (NonNegativeInteger, NonNegativeInteger) -> %

from MatrixCategory(R, JLVector R, JLVector R)

Aggregate

BasicType

CoercibleTo OutputForm

Comparable if R has Comparable

ConvertibleTo String

Evalable R if R has Evalable R

finiteAggregate

Hashable if R has Hashable

HomogeneousAggregate R

InnerEvalable(R, R) if R has Evalable R

JLMatrixCategory(R, JLVector R, JLVector R)

JLObjectAggregate

JLObjectType

JLType

MatrixCategory(R, JLVector R, JLVector R)

MatrixOperationsCategory(R, JLVector R, JLVector R)

SetCategory

shallowlyMutable

TwoDimensionalArrayCategory(R, JLVector R, JLVector R)