fdalg.spad line 8 [edit on github]
The elements of the Free Field are represented by Admissible Linear Systems (ALS) in standard form ...
f * U column transformation
T * f row transformation
f + alpha adds the scalar alpha to f.
alpha + f adds the scalar alpha to f.
f - alpha subtracts the scalar alpha from f.
alpha - f adds the scalar alpha to -f.
f / g computes f * g^-1 for nonzero element g.
f / alpha computes f / alpha for nonzero alpha.
alpha / f computes alpha / f for nonzero f.
f^n returns f^n.
f^n returns f^n.
addALS(f,g) computes f+g in terms of the admissible linear systems for f and g (without minimization).
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!(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(f,g) uses addALS(f,g) with minimization.
addRows!(f, i, j, alpha) adds alpha*row(i) to row(j) in the ALS of 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(f) output as ALS.
appendSupport! (f, lst) appends variables not in the support.
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(f, rsrc, rdst, csrc, cdst) flg_u = true, flg_v = true
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.
coerce(c) converts the constant c into an element of the free field represented by an ALS in minimal refined form.
coerce(m) converts the monoid m into an element of the free field represented by an ALS in minimal refined form.
coerce(p) converts the polynomial p to an element in the free field represented by an minimal admissible linear system.
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(f) converts the element to XDPOLY (if possible).
columnSpan(f) computes the column span for a regular element, that is (v', Mv', M^2v', ...) where PAs=Pv=v' with PA = I-M.
copy(f) gives a copy of the element f.
copy(f, alpha) gives a copy of element f multiplied by alpha.
dimension(f) returns the dimension of the ALS.
disableAlternativeOutput(f) disable output as rational expression.
disableDebugOutput(f) disable displaying the ALS.
display(f,[s]) prints the element f as A*(s_1,s_2,...,s_n)' = v.
display(f,sol) prints the element f as A*sol = v.
elt(f, i) returns v(i) from the ALS of f.
elt(f, i, j) returns A(i,j) from the ALS of f.
enableAlternativeOutput(f) enable output as rational expression.
enableDebugOutput(f) enable displaying the ALS.
extendedALS(f) returns an extended ALS for f, that is, 1*f (with a scalar first row).
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 similarity.
factorizationEquations(f,k_rows,k_cols) for debugging purposes (interface LINPEN)
factorizationGroebner(f,k_rows,k_cols) for debugging purposes (interface LINPEN)
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(f,k_rows,k_cols,sol) for debugging purposes (interface LINPEN)
factorize(f,k) factorizes f in f=g*h with rank(g)=k if possible (if necessary by using non-linear techniques).
factors(f) analysis the block structure of the system matrix of the ALS of f to split f into factors.
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(i, j) creates list [i, i+1, ..., j]
inverse(f) f^-1 using invertMIN.
invertALS(f) computes f^-1 in terms of the ALS for f. There is no check if f is invertible!
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(f) computes the standard inverse of f in terems of the admissible linear system There is no check if f is invertible!
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(f) prints the left family s=A^-1*v.
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).
linearization(f) returns the element f as linearization with entries represented by admissible linear systems in minimal refined form.
linearization(f) returns the element f as linearization.
matrix(f,m) returns the coefficient matrix for the monomial m of the ALS of f.
matrix(f) returns the matrix of the ALS of f.
minimal?(f) is f represented by a minimal ALS?
minimize(f) minimizes the underlying ALS by applying left and right block minimization steps. Minimality is only guaranteed if the remaining blocks are refined.
multiplyALS(f,g) computes f*g in terms of the admissible linear systems for f and g (without minimization).
multiplyColumn!(f, i, alpha) multiplies column(i) by alpha in the ALS of f.
multiplyMIN(f,g) uses multiplyALS(f,g) with minimization.
multiplyRow!(f, i, alpha) multiplies row(i) by alpha in the ALS of f.
mutable?(f) is the underlying ALS of f mutable?
new(c) creates a constant element.
new(m,c) creates a monomial element with coefficient c.
new(lp, lst) creates an element by the linear multivariate matrix pencil lp and the list of monomials lst.
normalALS(f) removes a scalar first row of an (extended) ALS.
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!(f) rescales the rows such that the first nonzero entry of the coefficient matrix in the diagonal is one.
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!(f) eliminates non-zero entries in the right hand side of ALS with respect of the non-zero entry with the highest index.
pencil(f) returns a pointer to the underlying pencil.
polynomial(f) returns f as XDPOLY (if possible)
polynomial?(f) is the ALS in polynomial form?
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.
addRows!(f, i, j, alpha) adds alpha*row(i) to row(j) in the ALS of f.
qelt(f, i, j) returns A(i,j) from the ALS of f.
qnew(n) creates an empty ALS of dimension n.
qnew(n, lst) creates an empty ALS of dimension n.
qregular?(f, i_min, i_max) does the specified diagonal block define a regular element?
swapColumns!(f, i, j) exchanges columns i and j in the ALS of f.
swapRows!(f, i, j) exchanges rows i and j in the ALS of f.
qzero?(f, i_min, i_max, j_min, j_max) is the specified block zero (in the system matrix)?
qzero?(f, i_min, i_max, j_min, j_max, m) is the specified block zero in the (system) matrix corresponding to the monomial m?
qzero?(f, i_min, i_max, j_min, j_max, l) is the specified block zero in matrix l?
rank(f) returns the rank of the element f, that is, the dimension of a minimal admissible linear system (for f).
ratexpr(f) analysis the block structure of the admissible linear system to write f as rational expression.
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.
refine!(f) refines f using non-linear techniques.
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).
refineUR!(f) uses linear techniques to create upper right blocks of zeros in staircase form (as far as possible).
refineUR!(f,k) uses linear techniques to create an upper right block of zeros with k rows (if possible).
refined?(f) is f represented by a refined ALS?
refinementEquations(f,i_min,i_max,k_rows,flg_u,flg_r) for debugging purposes (interface LINPEN)
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(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(f,i_min,i_max,sol) for debugging purposes (interface LINPEN)
regular?(f) is f a regular element?
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(f) returns the element f as linear representation (u,A,v).
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(f) prints the right family t=u*A^-1.
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).
rowSpan(f) computes the row span for a regular element, that is (u; uM; uM^2; ...) where PAs=Pv with PA = I-M.
scalar?(f) is f scalar?
scalar?(f, i, j) is A(i,j) scalar?
scaleALS(f, alpha) computes alpha*f by scaling the right hand side of the ALS for f.
setRefined!(f,max_sze) sets the internal flag if the system is refined (over the ground field) up to the specified block size.
setelt!(f, i, alpha) sets v(i) = alpha in the ALS of 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.
solutionVector(f) computes the solution vector s of As=v if f is polynomial.
solutionVector(f, k) computes the approximated solution vector up to powers M^k v' where PAs=Pv=v' with PA = I-M.
summands(f) analysis the block structure of the system matrix of the ALS of f to split f into summands.
swapColumns!(f, i, j) exchanges columns i and j in the ALS of f.
swapRows!(f, i, j) exchanges rows i and j in the ALS of f.
swapRowsColumns!(f, i, j) exchanges rows i and j and columns j and i in the ALS of f.
toggleAlternativeOutput(f) enable/disable output as rational expression.
toggleDebugOutput(f) enable/disable ALS.
transformColumns!(f, U) transforms the ALS of f from the right.
transformRows!(f, T) transforms the ALS of f from the left.
transformationMatrix(f) returns the identity matrix to be modified and used within transformRows! or transformColumns!
variables(f) returns a list of the variables.
vector(f) returns v from the ALS of f.
vector(f) returns v from the ALS of f.
zero?(f, i, j) is A(i,j) zero?
NonAssociativeAlgebra(Fraction(Integer))
RightModule(Fraction(Integer))
LeftModule(%)
BiModule(%, %)
Algebra(F)
RightModule(%)
BiModule(F, F)
Module(F)
BiModule(Fraction(Integer), Fraction(Integer))
RightModule(F)
LeftModule(F)