JuliaF32SquareMatrix n

jarray32.spad line 471 [edit on github]

• n: NonNegativeInteger

This domain provides a fast Julia Float32 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 JuliaFloat32 has LinearlyExplicitOver Integer

from RightModule Integer

*: (%, JuliaFloat32) -> %

from RightModule JuliaFloat32

*: (%, JuliaFloat32Vector) -> JuliaFloat32Vector

from SquareMatrixCategory(n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

*: (Integer, %) -> %

from AbelianGroup

*: (JuliaFloat32, %) -> %

from LeftModule JuliaFloat32

*: (JuliaFloat32Vector, %) -> JuliaFloat32Vector

from SquareMatrixCategory(n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

*: (NonNegativeInteger, %) -> %

from AbelianMonoid

*: (PositiveInteger, %) -> %

from AbelianSemiGroup

+: (%, %) -> %

from AbelianSemiGroup

-: % -> %

from AbelianGroup

-: (%, %) -> %

from AbelianGroup

/: (%, JuliaFloat32) -> %

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

=: (%, %) -> Boolean

from BasicType

^: (%, Integer) -> %

from SquareMatrixCategory(n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

^: (%, NonNegativeInteger) -> %

from MagmaWithUnit

^: (%, PositiveInteger) -> %

from Magma

~=: (%, %) -> Boolean

from BasicType

annihilate?: (%, %) -> Boolean

from Rng

antiCommutator: (%, %) -> %

from NonAssociativeSemiRng

antisymmetric?: % -> Boolean

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

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

from HomogeneousAggregate JuliaFloat32

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

from NonAssociativeRng

characteristic: () -> NonNegativeInteger

from NonAssociativeRing

coerce: % -> JuliaFloat32Matrix

from CoercibleTo JuliaFloat32Matrix

coerce: % -> OutputForm

from CoercibleTo OutputForm

coerce: Fraction Integer -> %

from CoercibleFrom Fraction Integer

coerce: Integer -> %

from CoercibleFrom Integer

coerce: JuliaFloat32 -> %

from CoercibleFrom JuliaFloat32

column: (%, Integer) -> JuliaFloat32Vector

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

columnSpace: % -> List JuliaFloat32Vector

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

commutator: (%, %) -> %

from NonAssociativeRng

convert: % -> InputForm if JuliaFloat32 has Finite

from ConvertibleTo InputForm

convert: % -> String

from ConvertibleTo String

copy: % -> %

from Aggregate

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

from HomogeneousAggregate JuliaFloat32

count: (JuliaFloat32, %) -> NonNegativeInteger

from HomogeneousAggregate JuliaFloat32

D: % -> %

from DifferentialRing

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

from DifferentialExtension JuliaFloat32

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

from DifferentialExtension JuliaFloat32

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

from PartialDifferentialRing Symbol

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

from PartialDifferentialRing Symbol

D: (%, NonNegativeInteger) -> %

from DifferentialRing

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

from PartialDifferentialRing Symbol

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

from PartialDifferentialRing Symbol

determinant: % -> JuliaFloat32

from SquareMatrixCategory(n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

diagonal?: % -> Boolean

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

diagonal: % -> JuliaFloat32Vector

from SquareMatrixCategory(n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

diagonalMatrix: List JuliaFloat32 -> %

from SquareMatrixCategory(n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

diagonalProduct: % -> JuliaFloat32

from SquareMatrixCategory(n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

differentiate: % -> %

from DifferentialRing

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

from DifferentialExtension JuliaFloat32

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

from DifferentialExtension JuliaFloat32

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

from PartialDifferentialRing Symbol

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

from PartialDifferentialRing Symbol

differentiate: (%, NonNegativeInteger) -> %

from DifferentialRing

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

from PartialDifferentialRing Symbol

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

from PartialDifferentialRing Symbol

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

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

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

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

empty?: % -> Boolean

from Aggregate

empty: () -> %

from Aggregate

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

from Finite

eq?: (%, %) -> Boolean

from Aggregate

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

from Evalable JuliaFloat32

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

from InnerEvalable(JuliaFloat32, JuliaFloat32)

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

from Evalable JuliaFloat32

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

from InnerEvalable(JuliaFloat32, JuliaFloat32)

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

from HomogeneousAggregate JuliaFloat32

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

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

hash: % -> SingleInteger if JuliaFloat32 has Finite

from Hashable

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

from Hashable

index: PositiveInteger -> % if JuliaFloat32 has Finite

from Finite

inverse: % -> Union(%, failed)

from SquareMatrixCategory(n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

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 JuliaFloat32

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

lookup: % -> PositiveInteger if JuliaFloat32 has Finite

from Finite

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

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

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

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

matrix: List List JuliaFloat32 -> %

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

max: % -> JuliaFloat32

from HomogeneousAggregate JuliaFloat32

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

from HomogeneousAggregate JuliaFloat32

maxColIndex: % -> Integer

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

maxRowIndex: % -> Integer

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

member?: (JuliaFloat32, %) -> Boolean

from HomogeneousAggregate JuliaFloat32

members: % -> List JuliaFloat32

from HomogeneousAggregate JuliaFloat32

min: % -> JuliaFloat32

from HomogeneousAggregate JuliaFloat32

minColIndex: % -> Integer

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

minordet: % -> JuliaFloat32

from SquareMatrixCategory(n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

minRowIndex: % -> Integer

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

more?: (%, NonNegativeInteger) -> Boolean

from Aggregate

ncols: % -> NonNegativeInteger

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

nrows: % -> NonNegativeInteger

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

nullity: % -> NonNegativeInteger

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

nullSpace: % -> List JuliaFloat32Vector

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

one?: % -> Boolean

from MagmaWithUnit

opposite?: (%, %) -> Boolean

from AbelianMonoid

parts: % -> List JuliaFloat32

from HomogeneousAggregate JuliaFloat32

Pfaffian: % -> JuliaFloat32

from SquareMatrixCategory(n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

plenaryPower: (%, PositiveInteger) -> %

from NonAssociativeAlgebra JuliaFloat32

qcoerce: JuliaFloat32Matrix -> %

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

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

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

random: () -> % if JuliaFloat32 has Finite

from Finite

rank: % -> NonNegativeInteger

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

recip: % -> Union(%, failed)

from MagmaWithUnit

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

from LinearlyExplicitOver Integer

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

from LinearlyExplicitOver JuliaFloat32

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

from LinearlyExplicitOver Integer

reducedSystem: Matrix % -> Matrix JuliaFloat32

from LinearlyExplicitOver JuliaFloat32

retract: % -> Fraction Integer

from RetractableTo Fraction Integer

retract: % -> Integer

from RetractableTo Integer

retract: % -> JuliaFloat32

from RetractableTo JuliaFloat32

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

from RetractableTo Fraction Integer

retractIfCan: % -> Union(Integer, failed)

from RetractableTo Integer

retractIfCan: % -> Union(JuliaFloat32, failed)

from RetractableTo JuliaFloat32

rightPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower: (%, PositiveInteger) -> %

from Magma

rightRecip: % -> Union(%, failed)

from MagmaWithUnit

row: (%, Integer) -> JuliaFloat32Vector

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

rowEchelon: % -> %

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

sample: %

from AbelianMonoid

scalarMatrix: JuliaFloat32 -> %

from SquareMatrixCategory(n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

size?: (%, NonNegativeInteger) -> Boolean

from Aggregate

size: () -> NonNegativeInteger if JuliaFloat32 has Finite

from Finite

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

from Comparable

square?: % -> Boolean

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

squareMatrix: JuliaFloat32Matrix -> %

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

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

from CancellationAbelianMonoid

symmetric?: % -> Boolean

from RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

trace: % -> JuliaFloat32

from SquareMatrixCategory(n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

zero?: % -> Boolean

from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Aggregate

Algebra JuliaFloat32

BasicType

BiModule(%, %)

BiModule(JuliaFloat32, JuliaFloat32)

CancellationAbelianMonoid

CoercibleFrom Fraction Integer

CoercibleFrom Integer

CoercibleFrom JuliaFloat32

CoercibleTo JuliaFloat32Matrix

CoercibleTo OutputForm

Comparable if JuliaFloat32 has Finite

ConvertibleTo InputForm if JuliaFloat32 has Finite

ConvertibleTo String

DifferentialExtension JuliaFloat32

DifferentialRing

Evalable JuliaFloat32 if JuliaFloat32 has Evalable JuliaFloat32

Finite if JuliaFloat32 has Finite

finiteAggregate

FullyLinearlyExplicitOver JuliaFloat32

FullyRetractableTo JuliaFloat32

Hashable if JuliaFloat32 has Finite

HomogeneousAggregate JuliaFloat32

InnerEvalable(JuliaFloat32, JuliaFloat32) if JuliaFloat32 has Evalable JuliaFloat32

JuliaType

LeftModule %

LeftModule JuliaFloat32

LinearlyExplicitOver Integer if JuliaFloat32 has LinearlyExplicitOver Integer

LinearlyExplicitOver JuliaFloat32

Magma

MagmaWithUnit

Module JuliaFloat32

Monoid

NonAssociativeAlgebra JuliaFloat32

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

PartialDifferentialRing Symbol if JuliaFloat32 has PartialDifferentialRing Symbol

RectangularMatrixCategory(n, n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

RetractableTo Fraction Integer

RetractableTo Integer

RetractableTo JuliaFloat32

RightModule %

RightModule Integer if JuliaFloat32 has LinearlyExplicitOver Integer

RightModule JuliaFloat32

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

SquareMatrixCategory(n, JuliaFloat32, JuliaFloat32Vector, JuliaFloat32Vector)

TwoSidedRecip

unitsKnown