JLMatrix R

jobject.spad line 1427 [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)

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 arbitraryPrecision and R hasn’t NMType and R has FloatingPointSystem

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)

hash: % -> SingleInteger if R has Hashable

from Hashable

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

from Hashable

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)

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)

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)

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 arbitraryPrecision and R hasn’t NMType and R has FloatingPointSystem

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)

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

square?: % -> Boolean

from MatrixOperationsCategory(R, JLVector R, JLVector R)

squareTop: % -> %

from TwoDimensionalArrayCategory(R, JLVector R, JLVector R)

string: % -> String

from JLType

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 arbitraryPrecision and R hasn’t NMType and R has FloatingPointSystem

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)