JuliaF64SquareMatrix nΒΆ

jarray64.spad line 546 [edit on github]

This domain provides a fast Julia Float64 square matrix type with no bound checking on elt's. Minimum index is 1.

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

#: % -> NonNegativeInteger

from Aggregate

*: (%, %) -> %

from Magma

*: (%, Integer) -> % if JuliaFloat64 has LinearlyExplicitOver Integer

from RightModule Integer

*: (%, JuliaFloat64) -> %

from RightModule JuliaFloat64

*: (%, JuliaFloat64Vector) -> JuliaFloat64Vector

from SquareMatrixCategory(n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

*: (Integer, %) -> %

from AbelianGroup

*: (JuliaFloat64, %) -> %

from LeftModule JuliaFloat64

*: (JuliaFloat64Vector, %) -> JuliaFloat64Vector

from SquareMatrixCategory(n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

*: (NonNegativeInteger, %) -> %

from AbelianMonoid

*: (PositiveInteger, %) -> %

from AbelianSemiGroup

+: (%, %) -> %

from AbelianSemiGroup

-: % -> %

from AbelianGroup

-: (%, %) -> %

from AbelianGroup

/: (%, JuliaFloat64) -> %

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

=: (%, %) -> Boolean

from BasicType

^: (%, Integer) -> %

from SquareMatrixCategory(n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

^: (%, NonNegativeInteger) -> %

from MagmaWithUnit

^: (%, PositiveInteger) -> %

from Magma

~=: (%, %) -> Boolean

from BasicType

annihilate?: (%, %) -> Boolean

from Rng

antiCommutator: (%, %) -> %

from NonAssociativeSemiRng

antisymmetric?: % -> Boolean

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

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

from HomogeneousAggregate JuliaFloat64

associator: (%, %, %) -> %

from NonAssociativeRng

characteristic: () -> NonNegativeInteger

from NonAssociativeRing

coerce: % -> JuliaFloat64Matrix

from CoercibleTo JuliaFloat64Matrix

coerce: % -> OutputForm

from CoercibleTo OutputForm

coerce: Fraction Integer -> %

from CoercibleFrom Fraction Integer

coerce: Integer -> %

from NonAssociativeRing

coerce: JuliaFloat64 -> %

from Algebra JuliaFloat64

column: (%, Integer) -> JuliaFloat64Vector

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

columnSpace: % -> List JuliaFloat64Vector

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

commutator: (%, %) -> %

from NonAssociativeRng

convert: % -> InputForm if JuliaFloat64 has Finite

from ConvertibleTo InputForm

convert: % -> String

from ConvertibleTo String

copy: % -> %

from Aggregate

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

from HomogeneousAggregate JuliaFloat64

count: (JuliaFloat64, %) -> NonNegativeInteger

from HomogeneousAggregate JuliaFloat64

D: % -> %

from DifferentialRing

D: (%, JuliaFloat64 -> JuliaFloat64) -> %

from DifferentialExtension JuliaFloat64

D: (%, JuliaFloat64 -> JuliaFloat64, NonNegativeInteger) -> %

from DifferentialExtension JuliaFloat64

D: (%, List Symbol) -> % if JuliaFloat64 has PartialDifferentialRing Symbol

from PartialDifferentialRing Symbol

D: (%, List Symbol, List NonNegativeInteger) -> % if JuliaFloat64 has PartialDifferentialRing Symbol

from PartialDifferentialRing Symbol

D: (%, NonNegativeInteger) -> %

from DifferentialRing

D: (%, Symbol) -> % if JuliaFloat64 has PartialDifferentialRing Symbol

from PartialDifferentialRing Symbol

D: (%, Symbol, NonNegativeInteger) -> % if JuliaFloat64 has PartialDifferentialRing Symbol

from PartialDifferentialRing Symbol

determinant: % -> JuliaFloat64

from SquareMatrixCategory(n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

diagonal?: % -> Boolean

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

diagonal: % -> JuliaFloat64Vector

from SquareMatrixCategory(n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

diagonalMatrix: List JuliaFloat64 -> %

from SquareMatrixCategory(n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

diagonalProduct: % -> JuliaFloat64

from SquareMatrixCategory(n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

differentiate: % -> %

from DifferentialRing

differentiate: (%, JuliaFloat64 -> JuliaFloat64) -> %

from DifferentialExtension JuliaFloat64

differentiate: (%, JuliaFloat64 -> JuliaFloat64, NonNegativeInteger) -> %

from DifferentialExtension JuliaFloat64

differentiate: (%, List Symbol) -> % if JuliaFloat64 has PartialDifferentialRing Symbol

from PartialDifferentialRing Symbol

differentiate: (%, List Symbol, List NonNegativeInteger) -> % if JuliaFloat64 has PartialDifferentialRing Symbol

from PartialDifferentialRing Symbol

differentiate: (%, NonNegativeInteger) -> %

from DifferentialRing

differentiate: (%, Symbol) -> % if JuliaFloat64 has PartialDifferentialRing Symbol

from PartialDifferentialRing Symbol

differentiate: (%, Symbol, NonNegativeInteger) -> % if JuliaFloat64 has PartialDifferentialRing Symbol

from PartialDifferentialRing Symbol

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

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

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

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

empty?: % -> Boolean

from Aggregate

empty: () -> %

from Aggregate

enumerate: () -> List % if JuliaFloat64 has Finite

from Finite

eq?: (%, %) -> Boolean

from Aggregate

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

from Evalable JuliaFloat64

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

from InnerEvalable(JuliaFloat64, JuliaFloat64)

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

from Evalable JuliaFloat64

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

from InnerEvalable(JuliaFloat64, JuliaFloat64)

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

from HomogeneousAggregate JuliaFloat64

exquo: (%, JuliaFloat64) -> Union(%, failed)

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

hash: % -> SingleInteger if JuliaFloat64 has Finite

from Hashable

hashUpdate!: (HashState, %) -> HashState if JuliaFloat64 has Finite

from Hashable

index: PositiveInteger -> % if JuliaFloat64 has Finite

from Finite

inverse: % -> Union(%, failed)

from SquareMatrixCategory(n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

latex: % -> String

from SetCategory

leftPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower: (%, PositiveInteger) -> %

from Magma

leftRecip: % -> Union(%, failed)

from MagmaWithUnit

less?: (%, NonNegativeInteger) -> Boolean

from Aggregate

listOfLists: % -> List List JuliaFloat64

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

lookup: % -> PositiveInteger if JuliaFloat64 has Finite

from Finite

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

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

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

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

matrix: List List JuliaFloat64 -> %

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

max: % -> JuliaFloat64

from HomogeneousAggregate JuliaFloat64

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

from HomogeneousAggregate JuliaFloat64

maxColIndex: % -> Integer

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

maxRowIndex: % -> Integer

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

member?: (JuliaFloat64, %) -> Boolean

from HomogeneousAggregate JuliaFloat64

members: % -> List JuliaFloat64

from HomogeneousAggregate JuliaFloat64

min: % -> JuliaFloat64

from HomogeneousAggregate JuliaFloat64

minColIndex: % -> Integer

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

minordet: % -> JuliaFloat64

from SquareMatrixCategory(n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

minRowIndex: % -> Integer

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

more?: (%, NonNegativeInteger) -> Boolean

from Aggregate

ncols: % -> NonNegativeInteger

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

nrows: % -> NonNegativeInteger

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

nullity: % -> NonNegativeInteger

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

nullSpace: % -> List JuliaFloat64Vector

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

one?: % -> Boolean

from MagmaWithUnit

opposite?: (%, %) -> Boolean

from AbelianMonoid

parts: % -> List JuliaFloat64

from HomogeneousAggregate JuliaFloat64

Pfaffian: % -> JuliaFloat64

from SquareMatrixCategory(n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

plenaryPower: (%, PositiveInteger) -> %

from NonAssociativeAlgebra JuliaFloat64

qcoerce: JuliaFloat64Matrix -> %

qcoerce(m) coerces m to JuliaF64SquareMatrix trusting that m is square.

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

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

random: () -> % if JuliaFloat64 has Finite

from Finite

rank: % -> NonNegativeInteger

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

recip: % -> Union(%, failed)

from MagmaWithUnit

reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer) if JuliaFloat64 has LinearlyExplicitOver Integer

from LinearlyExplicitOver Integer

reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix JuliaFloat64, vec: Vector JuliaFloat64)

from LinearlyExplicitOver JuliaFloat64

reducedSystem: Matrix % -> Matrix Integer if JuliaFloat64 has LinearlyExplicitOver Integer

from LinearlyExplicitOver Integer

reducedSystem: Matrix % -> Matrix JuliaFloat64

from LinearlyExplicitOver JuliaFloat64

retract: % -> Fraction Integer

from RetractableTo Fraction Integer

retract: % -> Integer

from RetractableTo Integer

retract: % -> JuliaFloat64

from RetractableTo JuliaFloat64

retractIfCan: % -> Union(Fraction Integer, failed)

from RetractableTo Fraction Integer

retractIfCan: % -> Union(Integer, failed)

from RetractableTo Integer

retractIfCan: % -> Union(JuliaFloat64, failed)

from RetractableTo JuliaFloat64

rightPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower: (%, PositiveInteger) -> %

from Magma

rightRecip: % -> Union(%, failed)

from MagmaWithUnit

row: (%, Integer) -> JuliaFloat64Vector

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

rowEchelon: % -> %

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

sample: %

from AbelianMonoid

scalarMatrix: JuliaFloat64 -> %

from SquareMatrixCategory(n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

size?: (%, NonNegativeInteger) -> Boolean

from Aggregate

size: () -> NonNegativeInteger if JuliaFloat64 has Finite

from Finite

smaller?: (%, %) -> Boolean if JuliaFloat64 has Finite

from Comparable

square?: % -> Boolean

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

squareMatrix: JuliaFloat64Matrix -> %

squareMatrix(m) returns a copy of m as a JuliaF64SquareMatrix.

subtractIfCan: (%, %) -> Union(%, failed)

from CancellationAbelianMonoid

symmetric?: % -> Boolean

from RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

trace: % -> JuliaFloat64

from SquareMatrixCategory(n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

zero?: % -> Boolean

from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Aggregate

Algebra JuliaFloat64

BasicType

BiModule(%, %)

BiModule(JuliaFloat64, JuliaFloat64)

CancellationAbelianMonoid

CoercibleFrom Fraction Integer

CoercibleFrom Integer

CoercibleFrom JuliaFloat64

CoercibleTo JuliaFloat64Matrix

CoercibleTo OutputForm

Comparable if JuliaFloat64 has Finite

ConvertibleTo InputForm if JuliaFloat64 has Finite

ConvertibleTo String

DifferentialExtension JuliaFloat64

DifferentialRing

Evalable JuliaFloat64 if JuliaFloat64 has Evalable JuliaFloat64

Finite if JuliaFloat64 has Finite

finiteAggregate

FullyLinearlyExplicitOver JuliaFloat64

FullyRetractableTo JuliaFloat64

Hashable if JuliaFloat64 has Finite

HomogeneousAggregate JuliaFloat64

InnerEvalable(JuliaFloat64, JuliaFloat64) if JuliaFloat64 has Evalable JuliaFloat64

JuliaType

LeftModule %

LeftModule JuliaFloat64

LinearlyExplicitOver Integer if JuliaFloat64 has LinearlyExplicitOver Integer

LinearlyExplicitOver JuliaFloat64

Magma

MagmaWithUnit

Module JuliaFloat64

Monoid

NonAssociativeAlgebra JuliaFloat64

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

PartialDifferentialRing Symbol if JuliaFloat64 has PartialDifferentialRing Symbol

RectangularMatrixCategory(n, n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

RetractableTo Fraction Integer

RetractableTo Integer

RetractableTo JuliaFloat64

RightModule %

RightModule Integer if JuliaFloat64 has LinearlyExplicitOver Integer

RightModule JuliaFloat64

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

SquareMatrixCategory(n, JuliaFloat64, JuliaFloat64Vector, JuliaFloat64Vector)

TwoSidedRecip

unitsKnown