JLMatrix R

jobject.spad line 1971 [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 convention of the C libraries, 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)

eigenvalues: % -> JLVector R if R has ComplexCategory NMRealField

eigenvalues(m) returns eigenvalues of m.

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

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 choosen 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 choosen 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 choosen 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 choosen 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 no 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

jlGetProperty: (%, JLSymbol) -> JLObject

from JLObjectType

jlId: % -> JLInt64

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: % -> String

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

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 Algebra NMFraction NMInteger and R has NMRing or R has IntegerNumberSystem and R has NMRing

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

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

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

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)