FreeDivisionAlgebra(VAR, F)¶

addColumns!: (%, NonNegativeInteger, NonNegativeInteger, F) -> %: addColumns!(f, i, j, alpha) adds alpha*column(i) to column(j) in A and subtracts row(j) from row(i) in s (in the ALS of f), i.e. (A*U)(U^-1*s) = v.

addColumnsRows!: (%, NonNegativeInteger, NonNegativeInteger, F) -> %: addColumnsRows!(f, i, j, alpha) adds alpha*column(i) to column(j) and subtracts alpha*row(j) from row(i) in the ALS of f.

addMIN: (%, %) -> %: addMIN(f,g) uses addALS(f,g) with minimization.

addRows!: (%, NonNegativeInteger, NonNegativeInteger, F) -> %: addRows!(f, i, j, alpha) adds alpha*row(i) to row(j) in the ALS of f.

addRowsColumns!: (%, NonNegativeInteger, NonNegativeInteger, F) -> %: addRowsColumns!(f, i, j, alpha) adds alpha*row(i) to row(j) and subtracts alpha*column(j) from column(i) in the ALS of f.

admissibleLinearSystem: % -> OutputForm: admissibleLinearSystem(f) output as ALS.

annihilate?: (%, %) -> Boolean: from Rng

antiCommutator: (%, %) -> %: from NonAssociativeSemiRng

appendSupport!: (%, List FreeMonoid VAR) -> %: appendSupport! (f, lst) appends variables not in the support.

associates?: (%, %) -> Boolean: from EntireRing

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

blockElimination: (%, List NonNegativeInteger, List NonNegativeInteger, Boolean, List NonNegativeInteger, List NonNegativeInteger, Boolean) -> List Matrix F: blockElimination(f, rsrc, rdst, flg_u, csrc, cdst, flg_v) returns transformation matrices if it is possible to eliminate all entries in rdst x cdst (including columns in u if flg_u = true, including rows in v if flg_v = true) by using rows in rsrc and columns in csrc. Otherwise an empty list.

blockElimination: (%, List NonNegativeInteger, List NonNegativeInteger, List NonNegativeInteger, List NonNegativeInteger) -> List Matrix F: blockElimination(f, rsrc, rdst, csrc, cdst) flg_u = true, flg_v = true

blockStructure: % -> Matrix NonNegativeInteger: blockStructure(f) analyzes the structure of the ALS of f and detects blocks with respect to an upper triangular structure. Entry (i,1) contains the first row, (i,2) the last row, (i,3) the size and (i,4) if block i is refined.

characteristic: () -> NonNegativeInteger: from NonAssociativeRing

coerce: % -> OutputForm: coerce(f) prints the ALS of f if the debug flag is set and a rational expression if the alternative output flag is set.

coerce: % -> XDistributedPolynomial(VAR, F): coerce(f) converts the element to XDPOLY (if possible).

coerce: F -> %: coerce(c) converts the constant c into an element of the free field represented by an ALS in minimal refined form.
coerce: Fraction Integer -> %: from Algebra Fraction Integer

coerce: FreeMonoid VAR -> %: coerce(m) converts the monoid m into an element of the free field represented by an ALS in minimal refined form.
coerce: Integer -> %: from NonAssociativeRing

coerce: XDistributedPolynomial(VAR, F) -> %: coerce(p) converts the polynomial p to an element in the free field represented by an minimal admissible linear system.

columnSpan: % -> Stream Matrix XDistributedPolynomial(VAR, F): columnSpan(f) computes the column span for a regular element, that is (v', Mv', M^2v’, …) where PAs=Pv=v’ with PA = I-M.

commutator: (%, %) -> %: from NonAssociativeRng

copy: % -> %: copy(f) gives a copy of the element f.

copy: (%, F) -> %: copy(f, alpha) gives a copy of element f multiplied by alpha.

dimension: % -> NonNegativeInteger: dimension(f) returns the dimension of the ALS.

disableAlternativeOutput: % -> %: disableAlternativeOutput(f) disable output as rational expression.

disableDebugOutput: % -> %: disableDebugOutput(f) disable displaying the ALS.

display: (%, List Symbol) -> OutputForm: display(f,[s]) prints the element f as A*(s_1,s_2,…,s_n)’ = v.

display: (%, OutputForm) -> OutputForm: display(f,sol) prints the element f as A*sol = v.

elt: (%, NonNegativeInteger) -> F: elt(f, i) returns v(i) from the ALS of f.

elt: (%, NonNegativeInteger, NonNegativeInteger) -> XDistributedPolynomial(VAR, F): elt(f, i, j) returns A(i,j) from the ALS of f.

enableAlternativeOutput: % -> %: enableAlternativeOutput(f) enable output as rational expression.

enableDebugOutput: % -> %: enableDebugOutput(f) enable displaying the ALS.

exquo: (%, %) -> Union(%, failed): from EntireRing

extendedALS: % -> %: extendedALS(f) returns an extended ALS for f, that is, 1*f (with a scalar first row).

factor: % -> List %: factor(f) factorizes f in f=f_1*f_2*…*f_k with atoms (irreducible elements) f_i. Notice that this factorization is unique only with respect to similiarity.

factorizationEquations: (%, NonNegativeInteger, NonNegativeInteger) -> List Polynomial F: factorizationEquations(f,k_rows,k_cols) for debugging purposes (interface LINPEN)

factorizationGroebner: (%, NonNegativeInteger, NonNegativeInteger) -> List Polynomial F: factorizationGroebner(f,k_rows,k_cols) for debugging purposes (interface LINPEN)

factorizationSolve: (%, NonNegativeInteger, NonNegativeInteger) -> List List Equation Polynomial F: factorizationSolve(f,k_rows,k_cols) returns a (possible empty) list of solutions for an admissible transformation to create an upper right block of zeros of size k_rows times k_cols.

factorizationTransformations: (%, NonNegativeInteger, NonNegativeInteger, List Equation Polynomial F) -> List Matrix F: factorizationTransformations(f,k_rows,k_cols,sol) for debugging purposes (interface LINPEN)

factorize: (%, NonNegativeInteger) -> List %: factorize(f,k) factorizes f in f=g*h with rank(g)=k if possible (if necessary by using non-linear techniques).

factors: % -> List %: factors(f) analysis the block structure of the system matrix of the ALS of f to split f into factors.

insertRowsColumns: (%, List NonNegativeInteger, List NonNegativeInteger) -> %: insertRowsColumns(f, lst_row, lst_col) returns a new system with rows and columns inserted. An index k means a new row/column between k and k+1. The number of rows and columns have to be the same!

interval: (NonNegativeInteger, NonNegativeInteger) -> List NonNegativeInteger: interval(i, j) creates list [i, i+1, …, j]

inv: % -> %: from DivisionRing

inverse: % -> %: inverse(f) f^-1 using invertMIN.

invertALS: % -> %: invertALS(f) computes f^-1 in terms of the ALS for f. There is no check if f is invertible!

invertMIN: % -> %: invertMIN(f) uses invertSTD(f) and minimization to construct a minimal system for f^-1. Linear techniques are used to get a fine pivot block structure.

invertSTD: % -> %: invertSTD(f) computes the standard inverse of f in terems of the admissible linear system There is no check if f is invertible!

latex: % -> String: from SetCategory

leftFactor: (%, NonNegativeInteger) -> %: leftFactor(f,k) returns the left factor of rank k of a polynomial f or 1 if it's not possible by linear techniques.

leftFamily: % -> List OutputForm: leftFamily(f) prints the left family s=A^-1*v.

leftMinimization: (%, NonNegativeInteger, NonNegativeInteger) -> %: leftMinimization(f, i_min, i_max) tries to apply a left minimization step with respect to the pivot block with the rows/columns (i_min, …, i_max).

leftPower: (%, NonNegativeInteger) -> %: from MagmaWithUnit
leftPower: (%, PositiveInteger) -> %: from Magma

leftRecip: % -> Union(%, failed): from MagmaWithUnit

linearization: % -> Matrix %: linearization(f) returns the element f as linearization with entries represented by admissible linear systems in minimal refined form.

linearization: % -> Matrix XDistributedPolynomial(VAR, F): linearization(f) returns the element f as linearization.

matrix: % -> Matrix XDistributedPolynomial(VAR, F): matrix(f) returns the matrix of the ALS of f.

matrix: (%, FreeMonoid VAR) -> Matrix F: matrix(f,m) returns the coefficient matrix for the monomial m of the ALS of f.

minimal?: % -> Boolean: minimal?(f) is f represented by a minimal ALS?

minimize: % -> %: minimize(f) minimizes the unterlying ALS by applying left and right block minimization steps. Minimality is only guaranteed if the remaining blocks are refined.

multiplyALS: (%, %) -> %: multiplyALS(f,g) computes f*g in terms of the admissible linear systems for f and g (without minimization).

multiplyColumn!: (%, NonNegativeInteger, F) -> %: multiplyColumn!(f, i, alpha) multiplies column(i) by alpha in the ALS of f.

multiplyMIN: (%, %) -> %: multiplyMIN(f,g) uses multiplyALS(f,g) with minimization.

multiplyRow!: (%, NonNegativeInteger, F) -> %: multiplyRow!(f, i, alpha) multiplies row(i) by alpha in the ALS of f.

mutable?: % -> Boolean: mutable?(f) is the underlying ALS of f mutable?

new: (FreeMonoid VAR, F) -> %: new(m,c) creates a monomial element with coefficient c.

new: (LinearMultivariateMatrixPencil F, List FreeMonoid VAR) -> %: new(lp, lst) creates an element by the linear multivariate matrix pencil lp and the list of monomials lst.

new: F -> %: new(c) creates a constant element.

normalALS: % -> %: normalALS(f) removes a scalar first row of an (extended) ALS.

normalize!: % -> %: normalize!(f) rescales the rows such that the first nonzero entry of the coefficient matrix in the diagonal is one. The right hand side is normalized by normalizeRHS! and the non-zero entry is in the last row of the corresponding block.

normalizeDIAG!: % -> %: normalizeDIAG!(f) rescales the rows such that the first nonzero entry of the coefficient matrix in the diagonal is one.

normalizePLS!: % -> %: normalizePLS!(f) scales and rearranges rows and columns of the system matrix such that the constant part of the system matrix is the identity matrix (possibly of smaller size).

normalizeRHS!: % -> %: normalizeRHS!(f) eliminates non-zero entries in the right hand side of ALS with respect of the non-zero entry with the highest index.

one?: % -> Boolean: from MagmaWithUnit

opposite?: (%, %) -> Boolean: from AbelianMonoid

pencil: % -> LinearMultivariateMatrixPencil F: pencil(f) returns a pointer to the underlying pencil.

plenaryPower: (%, PositiveInteger) -> %: from NonAssociativeAlgebra F

polynomial?: % -> Boolean: polynomial?(f) is the ALS in polynomial form?

polynomial: % -> XDistributedPolynomial(VAR, F): polynomial(f) returns f as XDPOLY (if possible)

qaddColumns!: (%, NonNegativeInteger, NonNegativeInteger, F) -> %: addColumns!(f, i, j, alpha) adds alpha*column(i) to column(j) in A and subtracts row(j) from row(i) in s (in the ALS of f), i.e. (A*U)(U^-1*s) = v.

qaddRows!: (%, NonNegativeInteger, NonNegativeInteger, F) -> %: addRows!(f, i, j, alpha) adds alpha*row(i) to row(j) in the ALS of f.

qelt: (%, NonNegativeInteger, NonNegativeInteger) -> XDistributedPolynomial(VAR, F): qelt(f, i, j) returns A(i,j) from the ALS of f.

qnew: (NonNegativeInteger, List FreeMonoid VAR) -> %: qnew(n, lst) creates an empty ALS of dimension n.

qnew: NonNegativeInteger -> %: qnew(n) creates an empty ALS of dimension n.

qregular?: (%, NonNegativeInteger, NonNegativeInteger) -> Boolean: qregular?(f, i_min, i_max) does the specified diagonal block define a regular element?

qswapColumns!: (%, NonNegativeInteger, NonNegativeInteger) -> %: swapColumns!(f, i, j) exchanges columns i and j in the ALS of f.

qswapRows!: (%, NonNegativeInteger, NonNegativeInteger) -> %: swapRows!(f, i, j) exchanges rows i and j in the ALS of f.

qzero?: (%, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger) -> Boolean: qzero?(f, i_min, i_max, j_min, j_max) is the spezified block zero (in the system matrix)?

qzero?: (%, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger, FreeMonoid VAR) -> Boolean: qzero?(f, i_min, i_max, j_min, j_max, m) is the spezified block zero in the (system) matrix corresponding to the monomial m?

qzero?: (%, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger) -> Boolean: qzero?(f, i_min, i_max, j_min, j_max, l) is the spezified block zero in matrix l?

rank: % -> NonNegativeInteger: rank(f) returns the rank of the element f, that is, the dimension of a minimal admissible linear system (for f).

ratexpr: % -> OutputForm: ratexpr(f) analysis the block structure of the admissible linear system to write f as rational expression.

ratexprInverse: (%, Boolean) -> OutputForm: ratexprInverse(f, flg) returns f in output form if it is a polynomial, (f)^-1 if f^-1 is a polynomial, “r<rank>” if the system is minimal and “d<dim>” in general.

recip: % -> Union(%, failed): from MagmaWithUnit

refine!: % -> %: refine!(f) refines f using non-linear techniques.

refine!: (%, Boolean) -> %: refine!(f, flg) refines the underlying admissible admissible linear system using simple and linear techniques and if flg=true also non-linear techniques (Groebner basis).

refined?: % -> Boolean: refined?(f) is f represented by a refined ALS?

refinementEquations: (%, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger, Boolean, Boolean) -> List Polynomial F: refinementEquations(f,i_min,i_max,k_rows,flg_u,flg_r) for debugging purposes (interface LINPEN)

refinementGroebner: (%, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger, Boolean, Boolean) -> List Polynomial F: refinementGroebner(f,i_min,i_max,k_rows,flg_u,flg_r) computes a Groebner basis for the ideal generated by the equations for creating a zero block with k rows within the pivot block i_min..i_max and conditions to guarantee invertible transformations.

refinementSolve: (%, NonNegativeInteger, NonNegativeInteger, NonNegativeInteger, Boolean, Boolean) -> List List Equation Polynomial F: refinementSolve(f,i_min,i_max,k_rows,flg_u,flg_r) Computes a list of solutions (for the entries in transformation matrices) to create a lower left block of zeros with k rows in the pivot block i_min..i_max.

refinementTransformations: (%, NonNegativeInteger, NonNegativeInteger, List Equation Polynomial F) -> List Matrix F: refinementTransformations(f,i_min,i_max,sol) for debugging purposes (interface LINPEN)

refineUR!: % -> %: refineUR!(f) uses linear techniques to create upper right blocks of zeros in staircase form (as far as possible).

refineUR!: (%, NonNegativeInteger) -> %: refineUR!(f,k) uses linear techniques to create an upper right block of zeros with k rows (if possible).

regular?: % -> Boolean: regular?(f) is f a regular element?

removeRowsColumns: (%, List NonNegativeInteger, List NonNegativeInteger) -> %: removeRowsColumns(f, lst_row, lst_col) returns a new system with the specified rows and columns removed. The number of rows and columns have to be the same!

representation: % -> List Matrix XDistributedPolynomial(VAR, F): representation(f) returns the element f as linear representation (u,A,v).

rightFactor: (%, NonNegativeInteger) -> %: rightFactor(f,k) returns the right factor of rank k of a polynomial f or 1 if it's not possible by linear techniques.

rightFamily: % -> List OutputForm: rightFamily(f) prints the right family t=u*A^-1.

rightMinimization: (%, NonNegativeInteger, NonNegativeInteger) -> %: rightMinimization(f, i_min, i_max) tries to apply a right minimization step with respect to the pivot block with the rows/columns (i_min, …, i_max).

rightPower: (%, NonNegativeInteger) -> %: from MagmaWithUnit
rightPower: (%, PositiveInteger) -> %: from Magma

rightRecip: % -> Union(%, failed): from MagmaWithUnit

rowSpan: % -> Stream Matrix XDistributedPolynomial(VAR, F): rowSpan(f) computes the row span for a regular element, that is (u; uM; uM^2; …) where PAs=Pv with PA = I-M.

sample: %: from AbelianMonoid

scalar?: % -> Boolean: scalar?(f) is f scalar?

scalar?: (%, NonNegativeInteger, NonNegativeInteger) -> Boolean: scalar?(f, i, j) is A(i,j) scalar?

scaleALS: (%, F) -> %: scaleALS(f, alpha) computes alpha*f by scaling the right hand side of the ALS for f.

setelt!: (%, NonNegativeInteger, F) -> F: setelt!(f, i, alpha) sets v(i) = alpha in the ALS of f.

setelt!: (%, NonNegativeInteger, NonNegativeInteger, XDistributedPolynomial(VAR, F)) -> XDistributedPolynomial(VAR, F): setelt!(f, i, j, p) sets A(i,j) = p in the ALS of f (where p has degree less equal one) if the system is in polynomial form and j>i.

setRefined!: (%, NonNegativeInteger) -> %: setRefined!(f,max_sze) sets the internal flag if the system is refined (over the ground field) up to the specified block size.

solutionVector: % -> Matrix XDistributedPolynomial(VAR, F): solutionVector(f) computes the solution vector s of As=v if f is polynomial.

solutionVector: (%, NonNegativeInteger) -> Matrix XDistributedPolynomial(VAR, F): solutionVector(f, k) computes the approximated solution vector up to powers M^k v' where PAs=Pv=v’ with PA = I-M.

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

summands: % -> List %: summands(f) analysis the block structure of the system matrix of the ALS of f to split f into summands.

swapColumns!: (%, NonNegativeInteger, NonNegativeInteger) -> %: swapColumns!(f, i, j) exchanges columns i and j in the ALS of f.

swapRows!: (%, NonNegativeInteger, NonNegativeInteger) -> %: swapRows!(f, i, j) exchanges rows i and j in the ALS of f.

swapRowsColumns!: (%, NonNegativeInteger, NonNegativeInteger) -> %: swapRowsColumns!(f, i, j) exchanges rows i and j and columns j and i in the ALS of f.

toggleAlternativeOutput: % -> %: toggleAlternativeOutput(f) enable/disable output as rational expression.

toggleDebugOutput: % -> %: toggleDebugOutput(f) enable/disable ALS.

transformationMatrix: % -> Matrix F: transformationMatrix(f) returns the identity matrix to be modified and used within transformRows! or transformColumns!