# olibdb

kind: o
name: qdiagonal?
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger,NonNegativeInteger)->Boolean
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{qdiagonal?(p,{} k_min,{} k_max,{} l)} is the matrix \spad{l} diagonal between \spad{k_min} and k_max? (no range check)


kind: o
name: qdiagonal
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger,NonNegativeInteger)->List(R)
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{qdiagonal(p,{} k_min,{} k_max,{} l)} returns the entries along the diagonal between \spad{k_min} and \spad{k_max}. (no range check)


kind: o
name: qelt
exposed: x
type: (%,Dom)->Im
params: cEltableAggregate(Dom,Im)
comment:
\spad{qelt(u,{} x)} applies \spad{u} to \spad{x} without checking whether \spad{x} is in the domain of \spad{u}. If \spad{x} is not in the domain of \spad{u} a memory-access violation may occur. If a check on whether \spad{x} is in the domain of \spad{u} is required,{} use the function \spad{elt}.


kind: o
name: qelt
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger)->List(R)
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{elt(p,{} i,{} j)} returns the elements (\spad{i},{}\spad{j}) from the linear pencil \spad{p} as a list (no check).


kind: o
name: qelt
exposed: x
type: (%,Integer,Integer)->R
params: cRectangularMatrixCategory(m,n,R,Row,Col)
comment:
\spad{qelt(m,{} i,{} j)} returns the element in the \spad{i}th row and \spad{j}th column of the matrix \spad{m}. Note: there is NO error check to determine if indices are in the proper ranges.


kind: o
name: qelt
exposed: x
type: (%,Integer,Integer)->R
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{qelt(m,{} i,{} j)} returns the element in the \spad{i}th row and \spad{j}th column of the array \spad{m} NO error check to determine if indices are in proper ranges


kind: o
name: qelt
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger,NonNegativeInteger)->R
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{elt(p,{} i,{} j,{} l)} returns the element (\spad{i},{}\spad{j}) in matrix \spad{l} of the linear pencil \spad{p} (no index-check).


kind: o
name: qequal?
exposed: n
type: (%,List(NonNegativeInteger),%,List(NonNegativeInteger),NonNegativeInteger)->Boolean
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{qequal?(p,{} pos_p,{} q,{} pos_q,{} offset)} checks,{} if the matrices are equal starting at offset.


kind: o
name: qinterval
exposed: x
type: (R,R)->%
params: cIntervalCategory(R)
comment:
\spad{qinterval(inf,{} sup)} creates a new interval \spad{[inf,{} sup]},{} without checking the ordering on the elements.


kind: o
name: qnew
exposed: n
type: (NonNegativeInteger,NonNegativeInteger,NonNegativeInteger)->%
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{qnew(m,{} n,{} l)} creates an empty linear pencil with \spad{l} matrices with \spad{m} rows and \spad{n} columns.


kind: o
name: qnilpotent?
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger,NonNegativeInteger)->Boolean
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{qnilpotent?(p,{} k_min,{} k_max,{} l)} ist the matrix \spad{l} nilpotent with respect to the specified block? (no range check)


kind: o
name: qPot
exposed: n
type: (Vector(GF),Integer)->Vector(GF)
params: pInnerNormalBasisFieldFunctions(GF)
comment:
\spad{qPot(v,{} e)} computes \spad{v^(q^e)},{} interpreting \spad{v} as an element of normal basis field,{} \spad{q} the size of the ground field. This is done by a cyclic \spad{e}-shift of the vector \spad{v}.


kind: o
name: qrowIndices
exposed: n
type: (%,NonNegativeInteger)->List(List(NonNegativeInteger))
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{qrowIndices(p,{} off)} returns a list of row indices for nonzero elements for every column starting at the specified offset. (no range check)


kind: o
name: qrowIndices
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger)->List(List(NonNegativeInteger))
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{qrowIndices(p,{} off,{} l)} returns a list of row indices for nonzero elements in matrix \spad{l} for every column starting at the specified offset. (no range check)


kind: o
name: qrowIndices
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger,NonNegativeInteger)->List(NonNegativeInteger)
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{qrowIndices(p,{} off,{} j,{} l)} returns a list of row indices for nozero elements in column \spad{j} in matrix \spad{l} (no range check)


kind: o
name: qscaleBlock!
exposed: n
params: dLinearMultivariateMatrixPencil(R)
type:
(%,NonNegativeInteger,NonNegativeInteger,NonNegativeInteger,NonNegativeInteger,NonNegativeInteger,R)->%

comment:
\spad{qscalesubMatrix!(p,{} i_min,{} i_max,{} j_min,{} j_max,{} l,{} alpha)} multiplies the entries in the specified block of matrix \spad{l} with alpha.


kind: o
name: qsemizero?
exposed: n
params: dLinearMultivariateMatrixPencil(R)
type:
(%,NonNegativeInteger,NonNegativeInteger,NonNegativeInteger,NonNegativeInteger,NonNegativeInteger)->Boolean

comment:
\spad{qsemizero?(p,{} i_min,{} i_max,{} j_min,{} j_max,{} l)} checks,{} if the specified submatrix is zero except for matrix \spad{l} (no index check).


kind: o
name: qsetelt!
exposed: x
type: (%,Dom,Im)->Im
params: cEltableAggregate(Dom,Im)
abbrev: has(%,shallowlyMutable)
comment:
\spad{qsetelt!(u,{} x,{} y)} sets the image of \spad{x} to be \spad{y} under \spad{u},{} without checking that \spad{x} is in the domain of \spad{u}. If such a check is required use the function \spad{setelt!}.


kind: o
name: qsetelt!
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger,List(R))->List(R)
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{qsetelt!(p,{} i,{} j,{} lst)} sets the element (\spad{i},{}\spad{j}) in the matrices of the linear pencil \spad{p} according to the elements in \spad{lst}.


kind: o
name: qsetelt!
exposed: x
type: (%,Integer,Integer,R)->R
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{qsetelt!(m,{} i,{} j,{} r)} sets the element in the \spad{i}th row and \spad{j}th column of \spad{m} to \spad{r} NO error check to determine if indices are in proper ranges


kind: o
name: qsetelt!
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger,NonNegativeInteger,R)->R
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{qselelt!(p,{} i,{} j,{} l,{} alpha)} sets the element (\spad{i},{}\spad{j}) in matrix \spad{l} of the linear pencil \spad{p} to alpha.


kind: o
name: qsetfirst!
exposed: x
type: (%,S)->S
params: cUnaryRecursiveAggregate(S)
abbrev: has(%,shallowlyMutable)
comment:
\spad{qsetfirst!(u,{} x)} destructively changes the first element of \spad{u} to \spad{x} without checking for errors.


kind: o
name: qsetrest!
exposed: x
type: (%,%)->%
params: cUnaryRecursiveAggregate(S)
abbrev: has(%,shallowlyMutable)
comment:
\spad{qsetrest!(u,{} v)} destructively changes the rest of \spad{u} to \spad{v} without checking for errors.


kind: o
name: qShiftAction
exposed: n
type: (D,NonNegativeInteger,NonNegativeInteger,V)->D
params: pFractionFreeFastGaussian(D,V)
comment:
\spad{qShiftAction(q,{} k,{} l,{} g)} gives the coefficient of \spad{x^k} in \spad{z^l} \spad{g}(\spad{x}),{} where \spad{z*}(a+b*x+c*x^2+d*x^3+...) = (a+q*b*x+q^2*c*x^2+q^3*d*x^3+...). In terms of sequences,{} z*u(\spad{n})=q^n*u(\spad{n}).


kind: o
name: qShiftC
exposed: n
type: (D,NonNegativeInteger)->List(D)
params: pFractionFreeFastGaussian(D,V)
comment:
\spad{qShiftC} gives the coefficients \spad{c_}{\spad{k},{} \spad{k}} in the expansion <x^k> \spad{z} \spad{g}(\spad{x}) = sum_{\spad{i=0}}\spad{^k} \spad{c_}{\spad{k},{} \spad{i}} <x^i> \spad{g}(\spad{x}),{} where \spad{z} acts on \spad{g}(\spad{x}) by shifting. In fact,{} the result is [1,{} \spad{q},{} \spad{q^2},{} ...]


kind: o
name: qswapColumns!
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger)->%
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{qswapColumns!(p,{} i,{} j)} exchanges columns \spad{i} and \spad{j} in all matrices of the linear pencil \spad{p} (no index check)


kind: o
name: qswapRows!
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger)->%
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{qswapRows!(p,{} i,{} j)} exchanges rows \spad{i} and \spad{j} in all matrices of the linear pencil \spad{p} (no index check).


kind: o
name: quadraticNonResidue
exposed: n
type: ()->%
params: dInnerPrimeField(p)
comment:
\spad{quadraticNonResidue()} computes the smallest non negative integer,{} which represents a quadratic non residue.


kind: o
name: quartic2
exposed: n
params: pRootUtilities(R,F)
comment: \spad{quartic2(p,{} a0)} should be local but conditional
type:
(SparseUnivariatePolynomial(F),F)->Union(Record(reals:List(F),complexes:List(Record(real:F,imag:F))),failed)


kind: o
name: quasiAlgebraicSet
exposed: n
type: (List(Dpoly),Dpoly)->%
params: dQuasiAlgebraicSet(R,Var,Expon,Dpoly)
comment:
\spad{quasiAlgebraicSet(pl,{} q)} returns the quasi-algebraic set with defining equations \spad{p} = 0 for \spad{p} belonging to the list \spad{pl},{} and defining inequation \spad{q} \spad{~=} 0.


kind: o
name: quasiComponent
exposed: x
type: (%)->Record(close:List(P),open:List(P))
params: cTriangularSetCategory(R,E,V,P)
comment:
\spad{quasiComponent(ts)} returns \spad{[lp,{} lq]} where \spad{lp} is the list of the members of \spad{ts} and \spad{lq}is \spad{initials(ts)}.


kind: o
name: quasiMonic?
exposed: x
type: (%)->Boolean
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{quasiMonic?(p)} returns \spad{false} if \spad{p} belongs to \spad{R},{} otherwise returns \spad{true} iff the initial of \spad{p} lies in the base ring \spad{R}.


kind: o
name: quasiMonicPolynomials
exposed: n
type: (List(P))->Record(goodPols:List(P),badPols:List(P))
params: pPolynomialSetUtilitiesPackage(R,E,V,P)
comment:
\spad{quasiMonicPolynomials(lp)} returns \spad{qmps,{} nqmps} where \spad{qmps} is a list of the quasi-monic polynomials in \spad{lp} and \spad{nqmps} are the other ones.


kind: o
name: queue
exposed: x
type: (List(S))->%
params: dQueue(S)
comment:
\spad{queue([x,{} y,{} ...,{} z])} creates a queue with first (top) element \spad{x},{} second element \spad{y},{} ...,{} and last (bottom) element \spad{z}.


kind: o
name: quickSort
exposed: x
type: ((S,S)->Boolean,V)->V
params: pFiniteLinearAggregateSort(S,V)
comment:
\spad{quickSort(f,{} agg)} sorts the aggregate agg with the ordering function \spad{f} using the quicksort algorithm.


kind: o
name: quo
exposed: x
type: (%,%)->%
params: cEuclideanDomain
comment:
\spad{x quo y} is the same as \spad{divide(x,{} y).quotient}. See \spadfunFrom{divide}{EuclideanDomain}.


kind: o
name: quoByVar
exposed: x
type: (%)->%
params: cUnivariateTaylorSeriesCategory(Coef)
comment:
\spad{quoByVar(a0 + a1 x + a2 x^2 + ...)} returns \spad{a1 + a2 x + a3 x^2 + ...} Thus,{} this function substracts the constant term and divides by the series variable. This function is used when Laurent series are represented by a Taylor series and an order.


kind: o
name: quote
exposed: x
type: ()->%
params: dCharacter
comment:
\spad{quote()} provides the string quote character,{} \spad{}.
o,quote,1,n,(%)->%,dOutputForm,",\spad{quote(f)} creates the form \spad{f} with a prefix quote.
o,quoted?,1,n,(%)->Boolean,dPattern(R),",\spad{quoted?(p)} tests if \spad{p} is of the form \spad{'s} for a symbol \spad{s}.
o,quotedOperators,1,x,(%)->List(Symbol),dRewriteRule(Base


kind: p
name: GroebnerInternalPackage
exposed: n
params: (Dom,Expon,Dpol)
abbrev: GBINTERN
comment: This package provides low level tools for Groebner basis computations.
type:
(Dom:GcdDomain,Expon:OrderedAbelianMonoidSup,Dpol:Join(FiniteAbelianMonoidRing(Dom,Expon),etc))->etc


kind: p
name: GroebnerPackage
exposed: x
params: (Dom,Expon,Dpol)
abbrev: GB
type:
(Dom:GcdDomain,Expon:OrderedAbelianMonoidSup,Dpol:Join(FiniteAbelianMonoidRing(Dom,Expon),etc))->etc

comment:
\spadtype{GroebnerPackage} computes groebner bases for polynomial ideals. The basic computation provides a distinguished set of generators for polynomial ideals over fields. This basis allows an easy test for membership: the operation \spadfun{normalForm} returns zero on ideal members. When the provided coefficient domain,{} Dom,{} is not a field,{} the result is equivalent to considering the extended ideal with \spadtype{Fraction(Dom)} as coefficients,{} but considerably more efficient since all calculations are performed in Dom. Additional argument info and redcrit can be given to provide incremental information during computation. Argument info produces a computational summary for each \spad{s}-polynomial. Argument redcrit prints out the reduced critical pairs. The term ordering is determined by the polynomial type used. Suggested types include \spadtype{DistributedMultivariatePolynomial},{} \spadtype{HomogeneousDistributedMultivariatePolynomial},{} \spadtype{GeneralDistributedMultivariatePolynomial}.


kind: p
name: GroebnerSolve
exposed: n
type: (List(Symbol),F:GcdDomain,GcdDomain)->etc
params: (lv,F,R)
abbrev: GROEBSOL
comment:
Solve systems of polynomial equations using Groebner bases Total order Groebner bases are computed and then converted to lex ones This package is mostly intended for internal use.


kind: p
name: GroupPresentationFunctions1
exposed: n
type: (SetCategory)->etc
params: (S)
abbrev: GROUPPF1
comment:
This package implements conversion between group \indented{1}{presentation given in terms of elements of \spadtype{FreeGroup}} \indented{1}{and \spadtype{GroupPresentation}.}


kind: p
name: Guess
exposed: x
type: (F:Join(Field,etc),S:GcdDomain,EXPRR:Join(FunctionSpace(Integer),etc),(EXPRR)->F,(F)->EXPRR)->etc
params: (F,S,EXPRR,retract,coerce)
abbrev: GUESS
comment:
This package implements guessing of sequences. Packages for the most common cases are provided as \spadtype{GuessInteger},{} \spadtype{GuessPolynomial},{} etc.


kind: p
name: HallBasis
exposed: x
type: ()->etc
abbrev: HB
comment:
Generate a basis for the free Lie algebra on \spad{n} generators over a ring \spad{R} with identity up to basic commutators of length \spad{c} using the algorithm of \spad{P}. Hall as given in Serre\spad{'s} book Lie Groups \spad{--} Lie Algebras.


kind: p
name: HeuGcd
exposed: n
type: (UnivariatePolynomialCategory(Integer))->etc
params: (BP)
abbrev: HEUGCD
comment:
This package provides the functions for the heuristic integer \spad{gcd}. Geddes\spad{'s} algorithm,{} for univariate polynomials with integer coefficients


kind: p
name: IdealDecompositionPackage
exposed: x
type: (List(Symbol))->etc
params: (vl)
abbrev: IDECOMP
comment:
\indented{2}{This package provides functions for the primary decomposition of} polynomial ideals over the rational numbers. The ideals are members of the \spadtype{PolynomialIdeal} domain,{} and the polynomial generators are required to be from the \spadtype{DistributedMultivariatePolynomial} domain.


kind: p
name: InnerAlgFactor
exposed: n
params: (F,UP,AlExt,AlPol)
abbrev: IALGFACT
type:
(F:Field,UP:UnivariatePolynomialCategory(F),AlExt:Join(Field,etc),AlPol:UnivariatePolynomialCategory(AlExt))->etc

comment:
Factorization of univariate polynomials with coefficients in an algebraic extension of a field over which we can factor UP\spad{'s}.


kind: p
name: InnerCommonDenominator
exposed: n
params: (R,Q,A,B)
abbrev: ICDEN
type:
(R:IntegralDomain,Q:QuotientFieldCategory(R),A:Join(LinearAggregate(R),etc),B:Join(LinearAggregate(Q),etc))->etc

comment:
InnerCommonDenominator provides functions to compute the common denominator of a finite linear aggregate of elements of the quotient field of an integral domain.


kind: p
name: InnerEigenPackage
exposed: n
type: (Field)->etc
params: (F)
abbrev: IEP
comment:
This is a package for the exact computation of eigenvalues and eigenvectors. This package works for matrices with coefficients from a field over which we can factor polynomials. Eigenvalues in base field are always explicitly computed while the other are expressed in terms of their minimal polynomial.


kind: p
name: InnerMatrixLinearAlgebraFunctions
exposed: n
params: (R,Row,Col,M)
abbrev: IMATLIN
type:
(R:DivisionRing,Row:FiniteLinearAggregate(R),Col:FiniteLinearAggregate(R),M:MatrixCategory(R,Row,Col))->etc

comment:
\spadtype{InnerMatrixLinearAlgebraFunctions} is an internal package which provides standard linear algebra functions on domains in \spad{MatrixCategory}


kind: p
name: InnerMatrixQuotientFieldFunctions
exposed: n
params: (R,Row,Col,M,QF,Row2,Col2,M2)
abbrev: IMATQF
type:
(R:IntegralDomain,Row:FiniteLinearAggregate(R),Col:FiniteLinearAggregate(R),M:MatrixCategory(R,Row,Col),QF:QuotientFieldCategory(R),Row2:FiniteLinearAggregate(QF),Col2:FiniteLinearAggregate(QF),M2:MatrixCategory(QF,Row2,Col2))->etc

comment:
\spadtype{InnerMatrixQuotientFieldFunctions} provides functions on matrices over an integral domain which involve the quotient field of that integral domain. The functions rowEchelon and inverse return matrices with entries in the quotient field.


kind: p
name: InnerModularGcd
exposed: n
type: (R:EuclideanDomain,BP:UnivariatePolynomialCategory(R),R,(R,NonNegativeInteger)->R)->etc
params: (R,BP,pMod,nextMod)
abbrev: INMODGCD
comment:
This file contains the functions for modular \spad{gcd} algorithm for univariate polynomials with coefficients in a non-trivial euclidean domain (\spadignore{i.e.} not a field). The package parametrised by the coefficient domain,{} the polynomial domain,{} a prime,{} and a function for choosing the next prime


kind: p
name: InnerModularHermitePade
exposed: n
type: ()->etc
abbrev: IMODHP
comment:
This package solves Hermite-Pade interpolation problem \indented{1}{over ring of integer polynomials.\space{2}We use reduction modulo primes} \indented{1}{and modular reconstruction to reduce problem to polynomials modulo} \indented{1}{\$\spad{Z_p}\$.\space{2}Then we use evaluation and Lagrange interpolation to} \indented{1}{reduce problem to solving over \$\spad{Z_p}\$.}


kind: p
name: InnerMultFact
exposed: n
params: (OV,E,R,P)
abbrev: INNMFACT
type:
(OV:OrderedSet,E:OrderedAbelianMonoidSup,R:Join(EuclideanDomain,etc),P:PolynomialCategory(R,E,OV))->etc

comment:
\indented{2}{This is an inner package for factoring multivariate polynomials} over various coefficient domains in characteristic 0. The univariate factor operation is passed as a parameter. Multivariate hensel lifting is used to lift the univariate factorization


kind: p
name: InnerNormalBasisFieldFunctions
exposed: n
type: (FiniteFieldCategory)->etc
params: (GF)
abbrev: INBFF
comment:
InnerNormalBasisFieldFunctions(\spad{GF}) (unexposed): This package has functions used by every normal basis finite field extension domain.


kind: p
name: InnerNumericEigenPackage
exposed: n
type: (Field,F:Field,Par:Join(Field,etc))->etc
params: (K,F,Par)
abbrev: INEP
comment:
This package is the inner package to be used by NumericRealEigenPackage and NumericComplexEigenPackage for the computation of numeric eigenvalues and eigenvectors.


kind: p
name: InnerNumericFloatSolvePackage
exposed: n
type: (GcdDomain,F:Field,Par:Join(Field,etc))->etc
params: (K,F,Par)
abbrev: INFSP
comment:
This is an internal package for computing approximate solutions to systems of polynomial equations. The parameter \spad{K} specifies the coefficient field of the input polynomials and must be either \spad{Fraction(Integer)} or \spad{Complex(Fraction Integer)}. The parameter \spad{F} specifies where the solutions must lie and can be one of the following: \spad{Float},{} \spad{Fraction(Integer)},{} \spad{Complex(Float)},{} \spad{Complex(Fraction Integer)}. The last parameter specifies the type of the precision operand and must be either \spad{Fraction(Integer)} or \spad{Float}.


kind: p
name: InnerTrigonometricManipulations
exposed: n
params: (R,F,FG)
abbrev: ITRIGMNP
type:
(R:Join(IntegralDomain,etc),F:Join(FunctionSpace(R),etc),FG:Join(FunctionSpace(Complex(R)),etc))->etc

comment:
This package provides transformations from trigonometric functions to exponentials and logarithms,{} and back. \spad{F} and \spad{FG} should be the same type of function space.


kind: p
name: IntegerCombinatoricFunctions
exposed: x
type: (IntegerNumberSystem)->etc
params: (I)
abbrev: COMBINAT
comment:
The \spadtype{IntegerCombinatoricFunctions} package provides some standard functions in combinatorics.


kind: p
name: IntegerFactorizationPackage
exposed: n
type: (IntegerNumberSystem)->etc
params: (I)
abbrev: INTFACT
comment:
\indented{1}{This Package contains basic methods for integer factorization.} The factor operation employs trial division up to 10,{} 000. It then tests to see if \spad{n} is a perfect power before using Pollards rho method. Because Pollards method may fail,{} the result of factor may contain composite factors. We should also employ Lenstra\spad{'s} elliptic curve method.


kind: p
name: IntegerPrimesPackage
exposed: x
type: (IntegerNumberSystem)->etc
params: (I)
abbrev: PRIMES
comment:
The \spadtype{IntegerPrimesPackage} implements a modification of Rabin\spad{'s} probabilistic primality test and the utility functions \spadfun{nextPrime},{} \spadfun{prevPrime} and \spadfun{primes}.


kind: p
name: IntegerRoots
exposed: x
type: (IntegerNumberSystem)->etc
params: (I)
abbrev: IROOT
comment:
The \spadtype{IntegerRoots} package computes square roots and \indented{2}{\spad{n}th roots of integers efficiently.}


kind: p
name: IntegerSmithNormalForm
exposed: n
type: ()->etc
abbrev: ISMITH
comment:
This package computes Smith form of integer matrices. \indented{1}{It is more efficinet than general case by first using elimination} \indented{1}{with unit pivots from \spadtype{UnitGaussianElimination}.}


kind: p
name: IntegerSolveLinearPolynomialEquation
exposed: n
type: ()->etc
abbrev: INTSLPE
comment:
This package provides the implementation for the \spadfun{solveLinearPolynomialEquation} operation over the integers. It uses a lifting technique from the package GenExEuclid


kind: p
name: IntegralBasisPolynomialTools
exposed: n
type: (K:Ring,R:UnivariatePolynomialCategory(K),UP:UnivariatePolynomialCategory(R),L:Ring)->etc
params: (K,R,UP,L)
abbrev: IBPTOOLS
comment:
IntegralBasisPolynomialTools provides functions for \indented{1}{mapping functions on the coefficients of univariate and bivariate} \indented{1}{polynomials.}


kind: p
name: IntegralBasisTools
exposed: n
type: (R:Join(EuclideanDomain,etc),UP:UnivariatePolynomialCategory(R),FramedAlgebra(R,UP))->etc
params: (R,UP,F)
abbrev: IBATOOL
comment:
This package contains functions used in the packages FunctionFieldIntegralBasis and NumberFieldIntegralBasis.


kind: p
name: IntegrateSolutions
exposed: n
type: (F:Join(Field,etc),L:Join(UnivariateSkewPolynomialCategory(F),etc))->etc
params: (F,L)
abbrev: INTDSOL
comment:
\spadtype{IntegrateSolutions} implements a method \indented{1}{to compute integral of solution of differential operator.}


kind: p
name: IntegrationResultRFToFunction
exposed: x
type: (Join(GcdDomain,etc))->etc
params: (R)
abbrev: IRRF2F
comment:
\indented{2}{This package allows a sum of logs over the roots of a polynomial} \indented{2}{to be expressed as explicit logarithms and arc tangents,{} provided} \indented{2}{that the indexing polynomial can be factored into quadratics.} Date Created: 21 August 1988


kind: p
name: IntegrationResultToFunction
exposed: x
type: (R:Join(GcdDomain,etc),F:Join(AlgebraicallyClosedFunctionSpace(R),etc))->etc
params: (R,F)
abbrev: IR2F
comment:
This package allows a sum of logs over the roots of a polynomial to be expressed as explicit logarithms and arc tangents,{} provided that the indexing polynomial can be factored into quadratics.


kind: p
name: InternalRationalUnivariateRepresentationPackage
exposed: n
params: (R,E,V,P,TS)
abbrev: IRURPK
type:
(R:Join(PolynomialFactorizationExplicit,etc),E:OrderedAbelianMonoidSup,V:OrderedSet,P:RecursivePolynomialCategory(R,E,V),TS:SquareFreeRegularTriangularSetCategory(R,E,V,P))->etc

comment:
\indented{1}{An internal package for computing the rational univariate representation} \indented{1}{of a zero-dimensional algebraic variety given by a square-free} \indented{1}{triangular set.} \indented{1}{The main operation is \spadopFrom{rur}{InternalRationalUnivariateRepresentationPackage}.} \indented{1}{It is based on the {\em generic} algorithm description in [1]. \newline References:} [1] \spad{D}. LAZARD Solving Zero-dimensional Algebraic Systems \indented{4}{Journal of Symbolic Computation,{} 1992,{} 13,{} 117-131}


kind: p
name: IrrRepSymNatPackage
exposed: x
type: ()->etc
abbrev: IRSN
comment:
IrrRepSymNatPackage contains functions for computing the ordinary irreducible representations of symmetric groups on \spad{n} letters {\em {1,{} 2,{} ...,{} n}} in Young\spad{'s} natural form and their dimensions. These representations can be labelled by number partitions of \spad{n},{} \spadignore{i.e.} a weakly decreasing sequence of integers summing up to \spad{n},{} \spadignore{e.g.} {\em [3,{} 3,{} 3,{} 1]} labels an irreducible representation for \spad{n} equals 10. Note: whenever a \spadtype{List Integer} appears in a signature,{} a partition required.


kind: p
name: JetCoordinateTransformation
exposed: n
params: (JB1,JB2,Y,W)
abbrev: JCT
type:
(JetBundleCategory,JB2:JetBundleCategory,Vector(JetBundleExpression(JB2)),Vector(JetBundleExpression(JB2)))->etc

comment:
\spadtype{JetCoordinateTransformation} implements changes of local coordinates. Given are the changes of the coordinates of the base space,{} \spadignore{i.e.} the independent and dependent variables. The transformations of the derivatives are computed via the chain rule. \spad{Y} (\spad{W}) contains expressions for the old variables in terms of the new ones.


kind: p
name: JetGroebner
exposed: n
params: (R,JB,LJV,P,E)
abbrev: JGB
type:
(R:GcdDomain,JB:JetBundleCategory,LJV:List(JB),P:Join(JetBundleFunctionCategory(JB),etc),DirectProductCategory(#(LJV),NonNegativeInteger))->etc

comment:
\spadtype{JetGroebner} provides a procedure to compute Groebner bases for arbitrary domains of jet polynomials. Two internal procedures transform to and from \spadtype{DistributedJetBundlePolynomial} where the actual computation is done. The argument \spad{LJV} contains all jet variables effectively occurring in the polynomials. The ordering is determined by the ordering in \spad{P}.


kind: p
name: JFriCASSupport
exposed: n
type: ()->etc
abbrev: JFRICAS
comment:
\indented{1}{The package \spad{JFriCASSupport} provides a number of service} functions to more easily switch on/off certain formats,{} in particular the use of the FormatMathJax formatter. Use \spad{setFormat! FormatMathJax} to switch on MathJax output or \spad{setFormats [FormatMathJax,{} Format1D]} to enable several output formats.


kind: p
name: Kovacic
exposed: n
type: (F:Join(CharacteristicZero,etc),UP:UnivariatePolynomialCategory(F))->etc
params: (F,UP)
abbrev: KOVACIC
comment:
\spadtype{Kovacic} provides a modified Kovacic\spad{'s} algorithm for solving explicitly irreducible 2nd order linear ordinary differential equations.


kind: p
name: LazardSetSolvingPackage
exposed: n
params: (R,E,V,P,TS,ST)
abbrev: LAZM3PK
type:
(R:GcdDomain,E:OrderedAbelianMonoidSup,V:OrderedSet,P:RecursivePolynomialCategory(R,E,V),RegularTriangularSetCategory(R,E,V,P),ST:SquareFreeRegularTriangularSetCategory(R,E,V,P))->etc

comment:
A package for solving polynomial systems by means of Lazard triangular sets [1]. This package provides two operations. One for solving in the sense of the regular zeros,{} and the other for solving in the sense of the Zariski closure. Both produce square-free regular sets. Moreover,{} the decompositions do not contain any redundant component. However,{} only zero-dimensional regular sets are normalized,{} since normalization may be time consumming in positive dimension. The decomposition process is that of [2].\newline


kind: p
name: LeadingCoefDetermination
exposed: n
type: (OV:OrderedSet,E:OrderedAbelianMonoidSup,Z:GcdDomain,P:PolynomialCategory(Z,E,OV))->etc
params: (OV,E,Z,P)
abbrev: LEADCDET
comment:
Package for leading coefficient determination in the lifting step. Package working for every unique factorization domain \spad{R} . Uses algorithm given in section 3 of [1] generalized to arbitrary unique factorization domain.


kind: p
name: LexTriangularPackage
exposed: n
type: (GcdDomain,ls:List(Symbol))->etc
params: (R,ls)
abbrev: LEXTRIPK
comment:
A package for solving polynomial systems with finitely many solutions. The decompositions are given by means of regular triangular sets. The computations use lexicographical Groebner bases. The main operations are \spadopFrom{lexTriangular}{LexTriangularPackage} and \spadopFrom{squareFreeLexTriangular}{LexTriangularPackage}. The second one provide decompositions by means of square-free regular triangular sets. Both are based on the {\em lexTriangular} method described in [1]. They differ from the algorithm described in [2] by the fact that multiciplities of the roots are not kept. With the \spadopFrom{squareFreeLexTriangular}{LexTriangularPackage} operation all multiciplities are removed. With the other operation some multiciplities may remain. Both operations admit an optional argument to produce normalized triangular sets. \newline


kind: p
name: LinearOrdinaryDifferentialOperator3Aux
exposed: n
type: (Coeff:Ring,A:AbelianMonoidRing(Coeff,NonNegativeInteger),R:Join(DifferentialRing,etc))->etc
params: (Coeff,A,R)
abbrev: LODO3AUX
comment:
\spad{LinearOrdinaryDifferentialOperator3Aux} is \indented{1}{a helper for \spad{LinearOrdinaryDifferentialOperator3}} \indented{1}{defining appropriate derivative.}


kind: p
name: LinearOrdinaryDifferentialOperatorFactorizer2
exposed: n
type: (Symbol,cen:Expression(Integer))->etc
params: (var,cen)
abbrev: LODOF2
comment:
\spadtype{LinearOrdinaryDifferentialOperatorFactorizer2} provides a factorizer for linear ordinary differential operators whose coefficients are rational functions.


kind: p
name: LinearOrdinaryDifferentialOperatorFactorizer
exposed: n
type: (F:Join(Field,etc),UP:UnivariatePolynomialCategory(F))->etc
params: (F,UP)
abbrev: LODOF
comment:
\spadtype{LinearOrdinaryDifferentialOperatorFactorizer} provides a factorizer for linear ordinary differential operators whose coefficients are rational functions.


kind: p
name: LinearOrdinaryDifferentialOperatorsOps
exposed: n
type: (A:Field,L:LinearOrdinaryDifferentialOperatorCategory(A))->etc
params: (A,L)
abbrev: LODOOPS
comment:
\spad{LinearOrdinaryDifferentialOperatorsOps} provides symmetric products and sums for linear ordinary differential operators.


kind: p
name: LinearPolynomialEquationByFractions
exposed: n
type: (PolynomialFactorizationExplicit)->etc
params: (R)
abbrev: LPEFRAC
comment:
Given a PolynomialFactorizationExplicit ring,{} this package provides a defaulting rule for the \spad{solveLinearPolynomialEquation} operation,{} by moving into the field of fractions,{} and solving it there via the \spad{multiEuclidean} operation.


kind: p
name: LinearSystemMatrixPackage1
exposed: x
type: (Field)->etc
params: (F)
abbrev: LSMP1
comment:
This package solves linear system in the matrix form \spad{AX = B}. It is essentially a particular instantiation of the package \spadtype{LinearSystemMatrixPackage} for Matrix and Vector. This package\spad{'s} existence makes it easier to use \spadfun{solve} in the FriCAS interpreter.


kind: p
name: LinearSystemMatrixPackage
exposed: x
params: (F,Row,Col,M)
abbrev: LSMP
comment: This package solves linear system in the matrix form \spad{AX = B}.
type:
(F:Field,Row:Join(FiniteLinearAggregate(F),etc),Col:Join(FiniteLinearAggregate(F),etc),M:MatrixCategory(F,Row,Col))->etc


kind: p
name: LinGroebnerPackage
exposed: n
type: (List(Symbol),F:GcdDomain)->etc
params: (lv,F)
abbrev: LGROBP
comment:
\indented{1}{Given a Groebner basis \spad{B} with respect to the total degree ordering for a} zero-dimensional ideal \spad{I},{} compute a Groebner basis with respect to the lexicographical ordering by using linear algebra. This is an internal package,{} operations in this package may crash the system on invalid input.


kind: p
name: ListFunctions2
exposed: x
type: (Type,B:Type)->etc
params: (A,B)
abbrev: LIST2
comment:
\spadtype{ListFunctions2} implements utility functions that operate on two kinds of lists,{} each with a possibly different type of element.


kind: p
name: ListFunctions3
exposed: x
type: (Type,B:Type,C:Type)->etc
params: (A,B,C)
abbrev: LIST3
comment:
\spadtype{ListFunctions3} implements utility functions that operate on three kinds of lists,{} each with a possibly different type of element.


kind: p
name: ListToMap
exposed: x
type: (SetCategory,B:Type)->etc
params: (A,B)
abbrev: LIST2MAP
comment:
\spadtype{ListToMap} allows mappings to be described by a pair of lists of equal lengths. The image of an element \spad{x},{} which appears in position \spad{n} in the first list,{} is then the \spad{n}th element of the second list. A default value or default function can be specified to be used when \spad{x} does not appear in the first list. In the absence of defaults,{} an error will occur in that case.


kind: p
name: LLLReduction
exposed: n
type: ()->etc
abbrev: LLLRED
comment:
This package implements \spad{LLL} reduction. Before \indented{1}{use user must set appropriate floating point precision.\space{2}Too} \indented{1}{low precision may cause nontermination.\space{2}Higher precisions} \indented{1}{require more compute time.}


kind: p
name: LODOConvertions
exposed: n
type: (Coeff:Ring,Ab:AbelianMonoidRing(Coeff,NonNegativeInteger),R:Join(DifferentialRing,etc))->etc
params: (Coeff,Ab,R)
abbrev: LODOCONV
comment:
\spadtype{LODOConvertions} implements conversion between \indented{1}{\spadtype{LinearOrdinaryDifferentialOperator1} and} \indented{1}{\spadtype{LinearOrdinaryDifferentialOperator3} and back.}


kind: p
name: LUDecomposition
exposed: n
type: (Field)->etc
params: (D)
abbrev: LUD
comment:
\spadtype{LUDecomposition} contains procedures to solve linear systems of equations or to compute inverses using a LU decomposition.


kind: p
name: MakeFloatCompiledFunction
exposed: x
type: (ConvertibleTo(InputForm))->etc
params: (S)
abbrev: MKFLCFN
comment:
MakeFloatCompiledFunction transforms top-level objects into compiled Lisp functions whose arguments are Lisp floats. This by-passes the \Language{} compiler and interpreter,{} thereby gaining several orders of magnitude.


kind: p
name: MakeRecord
exposed: x
type: (Type,T:Type)->etc
params: (S,T)
abbrev: MKRECORD
comment:
MakeRecord is used internally by the interpreter to create record types which are used for doing parallel iterations on streams.


kind: p
name: MathematicalSymbols
exposed: n
type: ()->etc
abbrev: MATHSYM
comment:
MathematicalSymbols defines several mathematical symbols,{} mostly Greek letters and multiletter Greek symbols.


kind: p
name: MatrixCategoryFunctions2
exposed: x
params: (R1,Row1,Col1,M1,R2,Row2,Col2,M2)
abbrev: MATCAT2
type:
(R1:Join(SemiRng,etc),Row1:FiniteLinearAggregate(R1),Col1:FiniteLinearAggregate(R1),M1:MatrixCategory(R1,Row1,Col1),R2:Join(SemiRng,etc),Row2:FiniteLinearAggregate(R2),Col2:FiniteLinearAggregate(R2),M2:MatrixCategory(R2,Row2,Col2))->etc

comment:
\spadtype{MatrixCategoryFunctions2} provides functions between two matrix domains. The functions provided are \spadfun{map} and \spadfun{reduce}.


kind: p
name: MatrixCommonDenominator
exposed: x
type: (R:IntegralDomain,Q:QuotientFieldCategory(R))->etc
params: (R,Q)
abbrev: MCDEN
comment:
MatrixCommonDenominator provides functions to compute the common denominator of a matrix of elements of the quotient field of an integral domain.


kind: p
name: MatrixLinearAlgebraFunctions
exposed: x
params: (R,Row,Col,M)
abbrev: MATLIN
comment: \spadtype{MatrixLinearAlgebraFunctions} provides functions to compute inverses and canonical forms.
type:
(R:CommutativeRing,Row:FiniteLinearAggregate(R),Col:FiniteLinearAggregate(R),M:MatrixCategory(R,Row,Col))->etc


kind: p
name: MatrixManipulation
exposed: n
params: (R,Row,Col,M)
abbrev: MAMA
type:
(R:Type,Row:FiniteLinearAggregate(R),Col:FiniteLinearAggregate(R),M:TwoDimensionalArrayCategory(R,Row,Col))->etc

comment:
Some functions for manipulating (dense) matrices. Supported are various kinds of slicing,{} splitting and stacking of matrices. The functions resemble operations often used in numerical linear algebra algorithms.


kind: p
name: ModularAlgebraicGcd2
exposed: n
params: (PT,MP,MPT,MD,ME,MO)
abbrev: MAGCD2
type:
(PT:Type,MP:Type,MPT:Type,MD:Type,ModularEvaluationCategory(PT,MP),ModularAlgebraicGcdOperations(MP,MPT,MD))->etc

comment:
This package computes \spad{gcd} over field of algebraic \indented{1}{functions over \spad{Q} using modular method based on \spad{M}. Monagan and} \indented{1}{van Hoej paper.} \indented{1}{Core modular operations are passed as parameter (MO) to this} \indented{1}{package.\space{2}Similarly,{} evaluation functions are passed as} \indented{1}{parameter ME.}


kind: p
name: ModularAlgebraicGcd
exposed: n
type: (MPT:Type,MD:Type,ModularAlgebraicGcdOperations(Polynomial(Integer),MPT,MD))->etc
params: (MPT,MD,MO)
abbrev: MAGCD
comment:
ModularAlgebraicGcd(\spad{MPT},{} \spad{MD},{} MO) is a compatibility \indented{1}{wrapper around \spad{ModularAlgebraicGcd2}.}


kind: p
name: ModularFactorizationGeneral
exposed: n
type: (PA:Type,MMT:Type,MD:Type,PMD:Type,ModularFactorizationOperations(PA,MMT,MD,PMD))->etc
params: (PA,MMT,MD,PMD,MO)
abbrev: MODFACTG
comment:
This package implements factorization of polynomials over finite fields using a variant of Kaltofen-Shoup method. Nontrivial data have abstract representation,{} operations are provided by matching package.


kind: p
name: ModularHermitePade
exposed: n
type: ()->etc
abbrev: MODHP
comment:
This package provides modular Hermite-Pade solvers \indented{1}{for a few rings.\space{2}Solver over integers is implemented in this} \indented{1}{package.\space{2}Also it contains interfaces to solver over \$\spad{Z_p}\$ and} \indented{1}{solver over ring of integer polynomials.}


kind: p
name: MonoidRingFunctions2
exposed: x
type: (Ring,S:Ring,M:Monoid)->etc
params: (R,S,M)
abbrev: MRF2
comment:
\spad{MonoidRingFunctions2} implements functions between two monoid rings defined with the same monoid over different rings.


kind: p
name: MoreSystemCommands
exposed: x
type: ()->etc
abbrev: MSYSCMD
comment:
\spadtype{MoreSystemCommands} implements an interface with the system command facility. These are the commands that are issued from source files or the system interpreter and they start with a close parenthesis,{} \spadignore{e.g.} \spadsys{)what} commands.


kind: p
name: MPolyCatFunctions2
exposed: x
params: (VarSet,E1,E2,R,S,PR,PS)
abbrev: MPC2
comment: Utilities for MPolyCat.
type:
(VarSet:OrderedSet,E1:OrderedAbelianMonoidSup,E2:OrderedAbelianMonoidSup,R:Ring,S:Ring,PR:PolynomialCategory(R,E1,VarSet),PS:PolynomialCategory(S,E2,VarSet))->etc


kind: p
name: MPolyCatFunctions3
exposed: n
params: (Vars1,Vars2,E1,E2,R,PR1,PR2)
abbrev: MPC3
comment: This package \undocumented
type:
(Vars1:OrderedSet,Vars2:OrderedSet,E1:OrderedAbelianMonoidSup,E2:OrderedAbelianMonoidSup,R:Ring,PR1:PolynomialCategory(R,E1,Vars1),PR2:PolynomialCategory(R,E2,Vars2))->etc


kind: p
name: MPolyCatPolyFactorizer
exposed: n
params: (E,OV,R,PPR)
abbrev: MPCPF
type:
(E:OrderedAbelianMonoidSup,OV:Join(OrderedSet,etc),R:EuclideanDomain,PPR:PolynomialCategory(Polynomial(R),E,OV))->etc

comment:
\indented{3}{This package exports a factor operation for multivariate polynomials} with coefficients which are polynomials over some ring \spad{R} over which we can factor. It is used internally by packages such as the solve package which need to work with polynomials in a specific set of variables with coefficients which are polynomials in all the other variables.


kind: p
name: MPolyCatRationalFunctionFactorizer
exposed: x
params: (E,OV,R,PRF)
abbrev: MPRFF
type:
(E:OrderedAbelianMonoidSup,OV:Join(OrderedSet,etc),R:IntegralDomain,PRF:PolynomialCategory(Fraction(Polynomial(R)),E,OV))->etc

comment:
\indented{3}{This package exports a factor operation for multivariate polynomials} with coefficients which are rational functions over some ring \spad{R} over which we can factor. It is used internally by packages such as primary decomposition which need to work with polynomials with rational function coefficients,{} \spadignore{i.e.} themselves fractions of polynomials.


kind: p
name: MRationalFactorize
exposed: n
params: (E,OV,R,P)
abbrev: MRATFAC
type:
(E:OrderedAbelianMonoidSup,OV:OrderedSet,R:Join(EuclideanDomain,etc),P:PolynomialCategory(Fraction(R),E,OV))->etc

comment:
\indented{1}{MRationalFactorize contains the factor function for multivariate} polynomials over the quotient field of a ring \spad{R} such that the package MultivariateFactorize can factor multivariate polynomials over \spad{R}.


kind: p
name: MultipleMap
exposed: n
params: (R1,UP1,UPUP1,R2,UP2,UPUP2)
abbrev: MMAP
comment: Lifting of a map through 2 levels of polynomials.
type:
(R1:IntegralDomain,UP1:UnivariatePolynomialCategory(R1),UPUP1:UnivariatePolynomialCategory(Fraction(UP1)),R2:IntegralDomain,UP2:UnivariatePolynomialCategory(R2),UPUP2:UnivariatePolynomialCategory(Fraction(UP2)))->etc


kind: p
name: MultiVariableCalculusFunctions
exposed: n
params: (S,F,FLAF,FLAS)
abbrev: MCALCFN
type:
(S:SetCategory,F:PartialDifferentialRing(S),FLAF:FiniteLinearAggregate(F),FLAS:FiniteLinearAggregate(S))->etc

comment:
\indented{1}{\spadtype{MultiVariableCalculusFunctions} Package provides several} \indented{1}{functions for multivariable calculus.} These include gradient,{} hessian and jacobian,{} divergence and laplacian. Various forms for banded and sparse storage of matrices are included.


kind: p
name: MultivariateFactorize
exposed: x
params: (OV,E,R,P)
abbrev: MULTFACT
type:
(OV:OrderedSet,E:OrderedAbelianMonoidSup,R:Join(PolynomialFactorizationExplicit,etc),P:PolynomialCategory(R,E,OV))->etc

comment:
\indented{2}{This is the top level package for doing multivariate factorization} over basic domains like \spadtype{Integer} or \spadtype{Fraction Integer}.


kind: p
name: MultivariateLifting
exposed: n
type: (E:OrderedAbelianMonoidSup,OV:OrderedSet,R:IntegralDomain,P:PolynomialCategory(R,E,OV))->etc
params: (E,OV,R,P)
abbrev: MLIFT
comment:
This package provides the functions for the multivariate lifting,{} using an algorithm of Paul Wang. This package will work for every euclidean domain \spad{R} which has property \spad{F},{} \spadignore{i.e.} there exists a factor operation in \spad{R[x]}.


kind: p
name: MultivariateSquareFree
exposed: n
type: (E:OrderedAbelianMonoidSup,OV:OrderedSet,R:EuclideanDomain,P:PolynomialCategory(R,E,OV))->etc
params: (E,OV,R,P)
abbrev: MULTSQFR
comment:
This package provides the functions for the computation of the square free decomposition of a multivariate polynomial. It uses modular reduction and the package \spad{MultivariateLifting} for the multivariate lifting.


kind: p
name: NaiveBeckermannLabahnModular
exposed: n
type: ()->etc
abbrev: NBLM
comment:
This package solves (multipoint) Hermite-Pade \indented{1}{interpolation problem over \$\spad{Z_p}\$,{} where \$\spad{p}\$ is machine} \indented{1}{sized prime.\space{2}We use quadratic algorithm from 94} \indented{1}{Beckermann and Labahn paper (with modification to handle} \indented{1}{multipoint case).}


kind: p
name: NewSparseUnivariatePolynomialFunctions2
exposed: n
type: (Ring,S:Ring)->etc
params: (R,S)
abbrev: NSUP2
comment:
This package lifts a mapping from coefficient rings \spad{R} to \spad{S} to a mapping from sparse univariate polynomial over \spad{R} to a sparse univariate polynomial over \spad{S}. Note that the mapping is assumed to send zero to zero,{} since it will only be applied to the non-zero coefficients of the polynomial.


kind: p
name: NewtonInterpolation
exposed: n
type: (IntegralDomain)->etc
params: (F)
abbrev: NEWTON
comment:
This package exports Newton interpolation for the special case where the result is known to be in the original integral domain


kind: p
name: NGroebnerPackage
exposed: n
type: (Dom:LeftOreRing,Expon:OrderedAbelianMonoidSup,Dpol:SolvableSkewPolynomialCategory(Dom,Expon))->etc
params: (Dom,Expon,Dpol)
abbrev: NGROEB
comment:
This is package computes noncommutative Groebner basis. Based on commutative version. Note that this package accepts rings as base domain,{} however computed basis is over left fraction field. Computations are done in fraction free way (coefficients stay in base ring).


kind: p
name: NoneFunctions1
exposed: x
type: (Type)->etc
params: (S)
abbrev: NONE1
comment:
\spadtype{NoneFunctions1} implements functions on \spadtype{None}. It includes a particularly dangerous coercion from any other type to \spadtype{None}.


kind: p
name: NonLinearFirstOrderODESolver
exposed: n
type: (R:Join(Comparable,etc),F:Join(AlgebraicallyClosedFunctionSpace(R),etc))->etc
params: (R,F)
abbrev: NODE1
comment:
NonLinearFirstOrderODESolver provides a function for finding closed form first integrals of nonlinear ordinary differential equations of order 1.


kind: p
name: NonLinearSolvePackage
exposed: n
type: (IntegralDomain)->etc
params: (R)
abbrev: NLINSOL
comment:
NonLinearSolvePackage is an interface to \spadtype{SystemSolvePackage} that attempts to retract the coefficients of the equations before solving. The solutions are given in the algebraic closure of \spad{R} whenever possible.


kind: p
name: NormalizationPackage
exposed: x
params: (R,E,V,P,TS)
abbrev: NORMPK
type:
(R:GcdDomain,E:OrderedAbelianMonoidSup,V:OrderedSet,P:RecursivePolynomialCategory(R,E,V),TS:RegularTriangularSetCategory(R,E,V,P))->etc

comment:
A package for computing normalized associates of univariate polynomials with coefficients in a tower of simple extensions of a field.


kind: p
name: NormInMonogenicAlgebra
exposed: x
params: (R,PolR,E,PolE)
abbrev: NORMMA
type:
(R:GcdDomain,PolR:UnivariatePolynomialCategory(R),E:MonogenicAlgebra(R,PolR),PolE:UnivariatePolynomialCategory(E))->etc

comment:
This package implements the norm of a polynomial with coefficients in a monogenic algebra (using resultants)


kind: p
name: NormRetractPackage
exposed: n
params: (F,ExtF,SUEx,ExtP,n)
abbrev: NORMRETR
comment: This package \undocumented
type:
(F:FiniteFieldCategory,ExtF:FiniteAlgebraicExtensionField(F),SUEx:UnivariatePolynomialCategory(ExtF),ExtP:UnivariatePolynomialCategory(SUEx),PositiveInteger)->etc


kind: p
name: NPCoef
exposed: n
params: (BP,E,OV,R,P)
abbrev: NPCOEF
type:
(UnivariatePolynomialCategory(R),E:OrderedAbelianMonoidSup,OV:OrderedSet,R:IntegralDomain,P:PolynomialCategory(R,E,OV))->etc

comment:
Package for the determination of the coefficients in the lifting process. Used by \spadtype{MultivariateLifting}. This package will work for every integral domain \spad{R}. The same method is described in [1] section 2.3.4.


kind: p
name: NumberFieldIntegralBasis
exposed: n
type: (UP:UnivariatePolynomialCategory(Integer),FramedAlgebra(Integer,UP))->etc
params: (UP,F)
abbrev: NFINTBAS
comment:
In this package \spad{F} is a framed algebra over the integers (typically \spad{F = Z[a]} for some algebraic integer a). The package provides functions to compute the integral closure of \spad{Z} in the quotient field of \spad{F}.


kind: p
name: NumberFormats
exposed: n
type: ()->etc
abbrev: NUMFMT
comment:
NumberFormats provides function to format and read arabic and roman numbers,{} to convert numbers to strings and to read floating-point numbers.


kind: p
name: NumericalOrdinaryDifferentialEquations
exposed: x
type: ()->etc
abbrev: NUMODE
comment:
This package is a suite of functions for the numerical integration of an ordinary differential equation of \spad{n} variables: \blankline \indented{8}{\centerline{dy/dx = \spad{f}(\spad{y},{} \spad{x})\space{5}\spad{y} is an \spad{n}-vector}} \blankline \par All the routines are based on a 4-th order Runge-Kutta kernel. These routines generally have as arguments: \spad{n},{} the number of dependent variables; \spad{x1},{} the initial point; \spad{h},{} the step size; \spad{y},{} a vector of initial conditions of length \spad{n} which upon exit contains the solution at \spad{x1 + h}; \spad{derivs},{} a function which computes the right hand side of the ordinary differential equation: \spad{derivs(dydx,{} y,{} x)} computes \spad{dydx},{} a vector which contains the derivative information. \blankline \par In order of increasing complexity: \begin{items} \blankline \item \spad{rk4(y,{} n,{} x1,{} h,{} derivs)} advances the solution vector to \spad{x1 + h} and return the values in \spad{y}. \blankline \item \spad{rk4(y,{} n,{} x1,{} h,{} derivs,{} t1,{} t2,{} t3,{} t4)} is the same as \spad{rk4(y,{} n,{} x1,{} h,{} derivs)} except that you must provide 4 scratch arrays \spad{t1}-\spad{t4} of size \spad{n}. \blankline \item Starting with \spad{y} at \spad{x1},{} \spad{rk4f(y,{} n,{} x1,{} x2,{} ns,{} derivs)} uses \spad{ns} fixed steps of a 4-th order Runge-Kutta integrator to advance the solution vector to \spad{x2} and return the values in \spad{y}. Argument \spad{x2},{} is the final point,{} and \spad{ns},{} the number of steps to take. \blankline \item \spad{rk4qc(y,{} n,{} x1,{} step,{} eps,{} yscal,{} derivs)} takes a 5-th order Runge-Kutta step with monitoring of local truncation to ensure accuracy and adjust stepsize. The function takes two half steps and one full step and scales the difference in solutions at the final point. If the error is within \spad{eps},{} the step is taken and the result is returned. If the error is not within \spad{eps},{} the stepsize if decreased and the procedure is tried again until the desired accuracy is reached. Upon input,{} an trial step size must be given and upon return,{} an estimate of the next step size to use is returned as well as the step size which produced the desired accuracy. The scaled error is computed as \centerline{\spad{error = MAX(ABS((y2steps(i) - y1step(i))/yscal(i)))}} and this is compared against \spad{eps}. If this is greater than \spad{eps},{} the step size is reduced accordingly to \centerline{\spad{hnew = 0.9 * hdid * (error/eps)^(-1/4)}} If the error criterion is satisfied,{} then we check if the step size was too fine and return a more efficient one. If \spad{error} > \spad{eps} * (6.0E-04) then the next step size should be \centerline{\spad{hnext} = 0.9 * hdid * (\spad{error}/\spad{eps})^(\spad{-1/5})} Otherwise \spad{hnext = 4.0 * hdid} is returned. A more detailed discussion of this and related topics can be found in the book Numerical Recipes by \spad{W}.Press,{} \spad{B}.\spad{P}. Flannery,{} \spad{S}.A. Teukolsky,{} \spad{W}.\spad{T}. Vetterling published by Cambridge University Press. Argument \spad{step} is a record of 3 floating point numbers \spad{(to_try ,{} did ,{} next)},{} \spad{eps} is the required accuracy,{} \spad{yscal} is the scaling vector for the difference in solutions. On input,{} \spad{step.to_try} should be the guess at a step size to achieve the accuracy. On output,{} \spad{step.did} contains the step size which achieved the accuracy and \spad{step.next} is the next step size to use. \blankline \item \spad{rk4qc(y,{} n,{} x1,{} step,{} eps,{} yscal,{} derivs,{} t1,{} t2,{} t3,{} t4,{} t5,{} t6,{} t7)} is the same as \spad{rk4qc(y,{} n,{} x1,{} step,{} eps,{} yscal,{} derivs)} except that the user must provide the 7 scratch arrays \spad{t1-t7} of size \spad{n}. \blankline \item \spad{rk4a(y,{} n,{} x1,{} x2,{} eps,{} h,{} ns,{} derivs)} is a driver program which uses \spad{rk4qc} to integrate \spad{n} ordinary differential equations starting at \spad{x1} to \spad{x2},{} keeping the local truncation error to within \spad{eps} by changing the local step size. The scaling vector is defined as \centerline{\spad{yscal(i) = abs(y(i)) + abs(h*dydx(i)) + tiny}} where \spad{y(i)} is the solution at location \spad{x},{} \spad{dydx} is the ordinary differential equation\spad{'s} right hand side,{} \spad{h} is the current step size and \spad{tiny} is 10 times the smallest positive number representable. The user must supply an estimate for a trial step size and the maximum number of calls to \spad{rk4qc} to use. Argument \spad{x2} is the final point,{} \spad{eps} is local truncation,{} \spad{ns} is the maximum number of call to \spad{rk4qc} to use. \end{items}


kind: p
name: NumericalQuadrature
exposed: x
type: (FloatingPointSystem)->etc
params: (F)
abbrev: NUMQUAD
comment:
This suite of routines performs numerical quadrature using algorithms derived from the basic trapezoidal rule. Because the error term of this rule contains only even powers of the step size (for open and closed versions),{} fast convergence can be obtained if the integrand is sufficiently smooth. \blankline Each routine returns a Record of type TrapAns,{} which contains\indent{3} \newline value (\spadtype{Float}): \tab{20} estimate of the integral \newline error (\spadtype{Float}): \tab{20} estimate of the error in the computation \newline totalpts (\spadtype{Integer}): \tab{20} total number of function evaluations \newline success (\spadtype{Boolean}): \tab{20} if the integral was computed within the user specified error criterion \indent{0}\indent{0} To produce this estimate,{} each routine generates an internal sequence of sub-estimates,{} denoted by {\em S(i)},{} depending on the routine,{} to which the various convergence criteria are applied. The user must supply a relative accuracy,{} \spad{eps_r},{} and an absolute accuracy,{} \spad{eps_a}. Convergence is obtained when either \centerline{\spad{ABS(S(i) - S(i-1)) < eps_r * ABS(S(i-1))}} \centerline{or \spad{ABS(S(i) - S(i-1)) < eps_a}} are \spad{true} statements. \blankline The routines come in three families and three flavors: \newline\tab{3} closed: \tab{20}romberg,{} \tab{30}simpson,{} \tab{42}trapezoidal \newline\tab{3} open: \tab{20}rombergo,{} \tab{30}simpsono,{} \tab{42}trapezoidalo \newline\tab{3} adaptive closed: \tab{20}aromberg,{} \tab{30}asimpson,{} \tab{42}atrapezoidal \par The {\em S(i)} for the trapezoidal family is the value of the integral using an equally spaced absicca trapezoidal rule for that level of refinement. \par The {\em S(i)} for the simpson family is the value of the integral using an equally spaced absicca simpson rule for that level of refinement. \par The {\em S(i)} for the romberg family is the estimate of the integral using an equally spaced absicca romberg method. For the \spad{i}\spad{-}th level,{} this is an appropriate combination of all the previous trapezodial estimates so that the error term starts with the \spad{2*(i+1)} power only. \par The three families come in a closed version,{} where the formulas include the endpoints,{} an open version where the formulas do not include the endpoints and an adaptive version,{} where the user is required to input the number of subintervals over which the appropriate closed family integrator will apply with the usual convergence parameters for each subinterval. This is useful where a large number of points are needed only in a small fraction of the entire domain. \par Each routine takes as arguments: \newline \spad{f}\tab{10} integrand \newline a\tab{10} starting point \newline \spad{b}\tab{10} ending point \newline \spad{eps_r}\tab{10} relative error \newline \spad{eps_a}\tab{10} absolute error \newline \spad{nmin} \tab{10} refinement level when to start checking for convergence (> 1) \newline \spad{nmax} \tab{10} maximum level of refinement \par The adaptive routines take as an additional parameter \newline \spad{nint}\tab{10} the number of independent intervals to apply a closed \indented{1}{family integrator of the same name.} \par Notes: \newline Closed family level \spad{i} uses \spad{1 + 2^i} points. \newline Open family level \spad{i} uses \spad{1 + 3^i} points.


kind: p
name: NumericComplexEigenPackage
exposed: x
type: (Join(Field,etc))->etc
params: (Par)
abbrev: NCEP
comment:
This package computes explicitly eigenvalues and eigenvectors of matrices with entries over the complex rational numbers. The results are expressed either as complex floating numbers or as complex rational numbers depending on the type of the precision parameter.


kind: p
name: NumericContinuedFraction
exposed: x
type: (FloatingPointSystem)->etc
params: (F)
abbrev: NCNTFRAC
comment:
\spadtype{NumericContinuedFraction} provides functions \indented{2}{for converting floating point numbers to continued fractions.}


kind: p
name: NumericRealEigenPackage
exposed: x
type: (Join(Field,etc))->etc
params: (Par)
abbrev: NREP
comment:
This package computes explicitly eigenvalues and eigenvectors of matrices with entries over the Rational Numbers. The results are expressed as floating numbers or as rational numbers depending on the type of the parameter Par.


kind: p
name: OctonionCategoryFunctions2
exposed: x
type: (OctonionCategory(R),R:CommutativeRing,OS:OctonionCategory(S),S:CommutativeRing)->etc
params: (OR,R,OS,S)
abbrev: OCTCT2
comment:
\spad{OctonionCategoryFunctions2} implements functions between two octonion domains defined over different rings. The function map is used to coerce between octonion types.


kind: p
name: ODEIntegration
exposed: n
type: (R:Join(Comparable,etc),F:Join(AlgebraicallyClosedFunctionSpace(R),etc))->etc
params: (R,F)
abbrev: ODEINT
comment:
\spadtype{ODEIntegration} provides an interface to the integrator. This package is intended for use by the differential equations solver but not at top-level.


kind: p
name: OneDimensionalArrayFunctions2
exposed: x
type: (Type,B:Type)->etc
params: (A,B)
abbrev: ARRAY12
comment:
This package provides tools for operating on one-dimensional arrays with unary and binary functions involving different underlying types.


kind: p
name: OpenMathServerPackage
exposed: x
type: ()->etc
abbrev: OMSERVER
comment:
\spadtype{OpenMathServerPackage} provides the necessary operations to run FriCAS as an OpenMath server,{} reading/writing objects to/from a port. Please note the facilities available here are very basic. The idea is that a user calls \spadignore{e.g.} \spad{Omserve(4000,{} 60)} and then another process sends OpenMath objects to port 4000 and reads the result.


kind: p
name: OrderingFunctions
exposed: n
type: (NonNegativeInteger,S:OrderedAbelianMonoid)->etc
params: (dim,S)
abbrev: ORDFUNS
comment:
\indented{3}{This package provides ordering functions on vectors which} are suitable parameters for OrderedDirectProduct.


kind: p
name: PadeApproximantPackage
exposed: x
type: (R:Field,x:Symbol,pt:R)->etc
params: (R,x,pt)
abbrev: PADEPAC
comment:
This package computes reliable Pade approximants using a generalized Viskovatov continued fraction algorithm.


kind: p
name: PAdicWildFunctionFieldIntegralBasis
exposed: n
params: (K,R,UP,F)
abbrev: PWFFINTB
type:
(K:FiniteFieldCategory,R:UnivariatePolynomialCategory(K),UP:UnivariatePolynomialCategory(R),MonogenicAlgebra(R,UP))->etc

comment:
In this package \spad{K} is a finite field,{} \spad{R} is a ring of univariate polynomials over \spad{K},{} and \spad{F} is a monogenic algebra over \spad{R}. We require that \spad{F} is monogenic,{} \spadignore{i.e.} that \spad{F = K[x,{} y]/(f(x,{} y))},{} because the integral basis algorithm used will factor the polynomial \spad{f(x,{} y)}. The package provides a function to compute the integral closure of \spad{R} in the quotient field of \spad{F} as well as a function to compute a local integral basis at a specific prime.


kind: p
name: ParametricIntegration
exposed: n
type: (R:Join(GcdDomain,etc),F:Join(AlgebraicallyClosedField,etc))->etc
params: (R,F)
abbrev: INTPAR2
comment:
This package implements general parametric integration. \indented{1}{Most work is delegated to other packages.}


kind: p
name: ParametricLinearEquations
exposed: n
params: (R,Var,Expon,GR)
abbrev: PLEQN
type:
(R:Join(EuclideanDomain,etc),Var:Join(OrderedSet,etc),Expon:OrderedAbelianMonoidSup,GR:PolynomialCategory(R,Expon,Var))->etc

comment:
This package completely solves a parametric linear system of equations by decomposing the set of all parametric values for which the linear system is consistent into a union of quasi-algebraic sets (which need not be irredundant,{} but most of the time is). Each quasi-algebraic set is described by a list of polynomials that vanish on the set,{} and a list of polynomials that vanish at no point of the set. For each quasi-algebraic set,{} the solution of the linear system is given,{} as a particular solution and a basis of the homogeneous system. The parametric linear system should be given in matrix form,{} with a coefficient matrix and a right hand side vector. The entries of the coefficient matrix and right hand side vector should be polynomials in the parametric variables,{} over a Euclidean domain of characteristic zero. \blankline If the system is homogeneous,{} the right hand side need not be given. The right hand side can also be replaced by an indeterminate vector,{} in which case,{} the conditions required for consistency will also be given.


kind: p
name: ParametricRischDE
exposed: n
type: (R:Join(GcdDomain,etc),F:Join(TranscendentalFunctionCategory,etc))->etc
params: (R,F)
abbrev: RDEPAR
comment:
This package implements parametric RDE solver. Only \indented{1}{simplest algebraic cases are implemented,{} the rest of algebraic} \indented{1}{case is unimplemented.\space{2}The code throws errors on inimplmented} \indented{1}{cases.}


kind: p
name: PartialFractionPackage
exposed: x
type: (Join(EuclideanDomain,etc))->etc
params: (R)
abbrev: PFRPAC
comment:
The package \spadtype{PartialFractionPackage} gives an easier to use interface to \spadtype{PartialFraction}. The user gives a fraction of polynomials,{} and a variable and the package converts it to the proper datatype for the \spadtype{PartialFraction} domain.


kind: p
name: PartitionsAndPermutations
exposed: x
type: ()->etc
abbrev: PARTPERM
comment:
PartitionsAndPermutations contains functions for generating streams of integer partitions,{} and streams of sequences of integers composed from a multi-set.


kind: p
name: PatternMatchIntegration
exposed: n
type: (R:Join(Comparable,etc),F:Join(AlgebraicallyClosedField,etc))->etc
params: (R,F)
abbrev: INTPM
comment:
\spadtype{PatternMatchIntegration} provides functions that use the pattern matcher to find some indefinite and definite integrals involving special functions and found in the literature.


kind: p
name: PatternMatchPolynomialCategory
exposed: n
params: (S,E,V,R,P)
abbrev: PMPLCAT
comment: This package provides pattern matching functions on polynomials.
type:
(S:SetCategory,E:OrderedAbelianMonoidSup,V:OrderedSet,R:Join(Ring,etc),P:Join(PolynomialCategory(R,E,V),etc))->etc


kind: p
name: PermutationGroupExamples
exposed: x
type: ()->etc
abbrev: PGE
comment:
PermutationGroupExamples provides permutation groups for some classes of groups: symmetric,{} alternating,{} dihedral,{} cyclic,{} direct products of cyclic,{} which are in fact the finite abelian groups of symmetric groups called Young subgroups. Furthermore,{} Rubik\spad{'s} group as permutation group of 48 integers and a list of sporadic simple groups derived from the atlas of finite groups.


kind: p
name: PiCoercions
exposed: x
type: (Join(Comparable,etc))->etc
params: (R)
abbrev: PICOERCE
comment:
\indented{1}{Provides a coercion from the symbolic fractions in \%\spad{pi} with} integer coefficients to any Expression type. Date Created: 21 Feb 1990


kind: p
name: PlotFunctions1
exposed: n
type: (ConvertibleTo(InputForm))->etc
params: (S)
abbrev: PLOT1
comment:
\spad{PlotFunctions1} provides facilities for plotting curves where functions \spad{SF} \spad{->} \spad{SF} are specified by giving an expression


kind: p
name: PointsOfFiniteOrder
exposed: n
params: (R0,F,UP,UPUP,R)
abbrev: PFO
comment: This package provides function for testing whether a divisor on a curve is a torsion divisor.
type:
(R0:Join(Comparable,etc),F:FunctionSpace(R0),UP:UnivariatePolynomialCategory(F),UPUP:UnivariatePolynomialCategory(Fraction(UP)),R:FunctionFieldCategory(F,UP,UPUP))->etc


kind: p
name: PointsOfFiniteOrderRational
exposed: n
params: (UP,UPUP,R)
abbrev: PFOQ
comment: This package provides function for testing whether a divisor on a curve is a torsion divisor.
type:
(UP:UnivariatePolynomialCategory(Fraction(Integer)),UPUP:UnivariatePolynomialCategory(Fraction(UP)),R:FunctionFieldCategory(Fraction(Integer),UP,UPUP))->etc


kind: p
name: PointsOfFiniteOrderTools
exposed: n
params: (UP,UPUP)
abbrev: PFOTOOLS
comment: Utilities for PFOQ and PFO.
type:
(UP:UnivariatePolynomialCategory(Fraction(Integer)),UPUP:UnivariatePolynomialCategory(Fraction(UP)))->etc


kind: p
name: PolyGroebner
exposed: x
type: (GcdDomain)->etc
params: (F)
abbrev: PGROEB
comment:
Groebner functions for \spad{P} \spad{F} \indented{2}{This package is an interface package to the groebner basis} package which allows you to compute groebner bases for polynomials in either lexicographic ordering or total degree ordering refined by reverse lex. The input is the ordinary polynomial type which is internally converted to a type with the required ordering. The resulting grobner basis is converted back to ordinary polynomials. The ordering among the variables is controlled by an explicit list of variables which is passed as a second argument. The coefficient domain is allowed to be any \spad{gcd} domain,{} but the groebner basis is computed as if the polynomials were over a field.


kind: p
name: PolynomialAN2Expression
exposed: x
type: ()->etc
abbrev: PAN2EXPR
comment:
This package provides a coerce from polynomials over algebraic numbers to \spadtype{Expression Integer}.


kind: p
name: PolynomialCategoryLifting
exposed: n
params: (E,Vars,R,P,S)
abbrev: POLYLIFT
type:
(E:OrderedAbelianMonoidSup,Vars:OrderedSet,R:Join(SemiRng,etc),P:PolynomialCategory(R,E,Vars),S:etc)->etc

comment:
This package provides a very general map function,{} which given a set \spad{S} and polynomials over \spad{R} with maps from the variables into \spad{S} and the coefficients into \spad{S},{} maps polynomials into \spad{S}. \spad{S} is assumed to support \spad{+},{} \spad{*} and \spad{^}.


kind: p
name: PolynomialCategoryQuotientFunctions
exposed: n
type: (E:OrderedAbelianMonoidSup,V:OrderedSet,R:Ring,P:PolynomialCategory(R,E,V),F:Join(Field,etc))->etc
params: (E,V,R,P,F)
abbrev: POLYCATQ
comment:
This package transforms multivariate polynomials or fractions into univariate polynomials or fractions,{} and back.


kind: p
name: PolynomialCommonDenominator
exposed: n
params: (R,Q,E,VarSet,P)
abbrev: PCDEN
type:
(R:IntegralDomain,Q:QuotientFieldCategory(R),E:OrderedAbelianMonoidSup,VarSet:OrderedSet,P:PolynomialCategory(Q,E,VarSet))->etc

comment:
PolynomialCommonDenominator provides \indented{1}{functions to compute and clear the common denominator of the} \indented{1}{coefficients of polynomials over the quotient field.}


kind: p
name: PolynomialEvaluationUtilities
exposed: n
type: ()->etc
abbrev: PEVALUT
comment:
This package implements evaluation functions \indented{1}{useful for modular algorithms.\space{2}Computations work} \indented{1}{on integer polynomials,{} but most is done modulo a prime} \indented{1}{which is provided via parameters,{} either explicitly or} \indented{1}{through a state parameter (state also caches needed buffers).} \indented{1}{Some functions work on fractions.\space{2}To avoid useless \spad{GCD}} \indented{1}{computations during evaluation fractions may be represented} \indented{1}{as a record.}


kind: p
name: PolynomialFactorizationByRecursion
exposed: n
params: (R,E,VarSet,S)
abbrev: PFBR
type:
(R:PolynomialFactorizationExplicit,E:OrderedAbelianMonoidSup,VarSet:OrderedSet,S:PolynomialCategory(R,E,VarSet))->etc

comment:
PolynomialFactorizationByRecursion(\spad{R},{} \spad{E},{} \spad{VarSet},{} \spad{S}) is used for factorization of sparse univariate polynomials over a domain \spad{S} of multivariate polynomials over \spad{R}.


kind: p
name: PolynomialFunctions2
exposed: x
type: (Ring,S:Ring)->etc
params: (R,S)
abbrev: POLY2
comment:
\indented{2}{This package takes a mapping between coefficient rings,{} and lifts} it to a mapping between polynomials over those rings.


kind: p
name: PolynomialGcdPackage
exposed: n
type: (E:OrderedAbelianMonoidSup,OV:OrderedSet,R:EuclideanDomain,P:PolynomialCategory(R,E,OV))->etc
params: (E,OV,R,P)
abbrev: PGCD
comment:
\indented{2}{This package computes multivariate polynomial \spad{gcd}\spad{'s} using} a hensel lifting strategy. The constraint on the coefficient domain is imposed by the lifting strategy. It is assumed that the coefficient domain has the property that almost all specializations preserve the degree of the \spad{gcd}.


kind: p
name: PolynomialRoots
exposed: n
params: (E,V,R,P,F)
abbrev: POLYROOT
comment: computes \spad{n}-th roots of quotients of multivariate polynomials
type:
(E:OrderedAbelianMonoidSup,V:OrderedSet,R:IntegralDomain,P:PolynomialCategory(R,E,V),F:Join(Field,etc))->etc


kind: p
name: PolynomialSetUtilitiesPackage
exposed: n
type: (R:IntegralDomain,E:OrderedAbelianMonoidSup,V:OrderedSet,P:RecursivePolynomialCategory(R,E,V))->etc
params: (R,E,V,P)
abbrev: PSETPK
comment:
This package provides modest routines for polynomial system solving. The aim of many of the operations of this package is to remove certain factors in some polynomials in order to avoid unnecessary computations in algorithms involving splitting techniques by partial factorization.


kind: p
name: PolynomialSolveByFormulas
exposed: n
type: (UnivariatePolynomialCategory(F),F:Join(Field,etc),Join(PolynomialFactorizationExplicit,etc))->etc
params: (UP,F,RR)
abbrev: SOLVEFOR
comment:
This package factors the formulas out of the general solve code,{} allowing their recursive use over different domains. Care is taken to introduce few radicals so that radical extension domains can more easily simplify the results.


kind: p
name: PolynomialSquareFree
exposed: n
type: (VarSet:OrderedSet,E:OrderedAbelianMonoidSup,RC:GcdDomain,P:PolynomialCategory(RC,E,VarSet))->etc
params: (VarSet,E,RC,P)
abbrev: PSQFR
comment:
This package computes square-free decomposition of multivariate polynomials over a coefficient ring which is an arbitrary \spad{gcd} domain. The requirement on the coefficient domain guarantees that the \spadfun{content} can be removed so that factors will be primitive as well as square-free. Over an infinite ring of finite characteristic,{} it may not be possible to guarantee that the factors are square-free.


kind: p
name: PolynomialToUnivariatePolynomial
exposed: x
type: (Symbol,R:Ring)->etc
params: (x,R)
abbrev: POLY2UP
comment:
This package is primarily to help the interpreter do coercions. It allows you to view a polynomial as a univariate polynomial in one of its variables with coefficients which are again a polynomial in all the other variables.


kind: p
name: PosetFactory
exposed: n
type: (SetCategory)->etc
params: (S)
abbrev: POSETF
comment:
Provides functions to construct various small posets including powerset. Perhaps it should be called a 'powerlist' but since we do not expect duplicates or require specific ordering it is essentially the same.


kind: p
name: PowerSeriesLimitPackage
exposed: x
type: (R:Join(GcdDomain,etc),FE:Join(AlgebraicallyClosedField,etc))->etc
params: (R,FE)
abbrev: LIMITPS
comment:
PowerSeriesLimitPackage implements limits of expressions in one or more variables as one of the variables approaches a limiting value. Included are two-sided limits,{} left- and right- hand limits,{} and limits at plus or minus infinity.


kind: p
name: PrecomputedAssociatedEquations
exposed: n
type: (R:IntegralDomain,L:LinearOrdinaryDifferentialOperatorCategory(R))->etc
params: (R,L)
abbrev: PREASSOC
comment:
\spadtype{PrecomputedAssociatedEquations} stores some generic precomputations which speed up the computations of the associated equations needed for factoring operators.


kind: p
name: PrimGCD
exposed: n
type: ()->etc
abbrev: PRIGCD3
comment:
This is unfinished package for computing primitive \indented{1}{\spad{gcd} over algebraic extensions.\space{2}Algebraic extension is defined} \indented{1}{by list of polynomial forming triangular system.} \indented{1}{Currently implemented is only trial division.}


kind: p
name: PrimitiveArrayFunctions2
exposed: x
type: (Type,B:Type)->etc
params: (A,B)
abbrev: PRIMARR2
comment:
This package provides tools for operating on primitive arrays with unary and binary functions involving different underlying types.


kind: p
name: PrimitiveRatDE
exposed: n
params: (F,UP,L,LQ)
abbrev: ODEPRIM
type:
(F:Join(Field,etc),UP:UnivariatePolynomialCategory(F),L:LinearOrdinaryDifferentialOperatorCategory(UP),LQ:LinearOrdinaryDifferentialOperatorCategory(Fraction(UP)))->etc

comment:
\spad{PrimitiveRatDE} provides functions for in-field solutions of linear \indented{1}{ordinary differential equations,{} in the transcendental case.} \indented{1}{The derivation to use is given by the parameter \spad{L}.}


kind: p
name: PrimitiveRatRicDE
exposed: n
params: (F,UP,L,LQ)
abbrev: ODEPRRIC
comment: In-field solution of Riccati equations,{} primitive case.
type:
(F:Join(Field,etc),UP:UnivariatePolynomialCategory(F),L:LinearOrdinaryDifferentialOperatorCategory(UP),LinearOrdinaryDifferentialOperatorCategory(Fraction(UP)))->etc


kind: p
name: PseudoLinearNormalForm
exposed: n
type: (Field)->etc
params: (K)
abbrev: PSEUDLIN
comment:
PseudoLinearNormalForm provides a function for computing a block-companion form for pseudo-linear operators.


kind: p
name: PseudoRemainderSequence
exposed: n
type: (R:IntegralDomain,polR:UnivariatePolynomialCategory(R))->etc
params: (R,polR)
abbrev: PRS
comment:
This package contains some functions: \spadopFrom{discriminant}{PseudoRemainderSequence},{} \spadopFrom{resultant}{PseudoRemainderSequence},{} \spadopFrom{subResultantGcd}{PseudoRemainderSequence},{} \spadopFrom{chainSubResultants}{PseudoRemainderSequence},{} \spadopFrom{degreeSubResultant}{PseudoRemainderSequence},{} \spadopFrom{lastSubResultant}{PseudoRemainderSequence},{} \spadopFrom{resultantEuclidean}{PseudoRemainderSequence},{} \spadopFrom{subResultantGcdEuclidean}{PseudoRemainderSequence},{} \spadopFrom{\spad{semiSubResultantGcdEuclidean1}}{PseudoRemainderSequence},{} \spadopFrom{\spad{semiSubResultantGcdEuclidean2}}{PseudoRemainderSequence},{} etc. These procedures are coming from improvements of the subresultants algorithm.


kind: p
name: PureAlgebraicIntegration
exposed: n
type: (R:Join(GcdDomain,etc),F:Join(FunctionSpace(R),etc),L:SetCategory)->etc
params: (R,F,L)
abbrev: INTPAF
comment:
This package provides functions for integration,{} limited integration,{} extended integration and the risch differential equation for pure algebraic integrands.


kind: p
name: PureAlgebraicLODE
exposed: n
params: (F,UP,UPUP,R)
abbrev: ODEPAL
comment: In-field solution of an linear ordinary differential equation,{} pure algebraic case.
type:
(F:Join(Field,etc),UP:UnivariatePolynomialCategory(F),UPUP:UnivariatePolynomialCategory(Fraction(UP)),R:FunctionFieldCategory(F,UP,UPUP))->etc


kind: p
name: PushVariables
exposed: n
params: (R,E,OV,PPR)
abbrev: PUSHVAR
comment: This package \undocumented{}
type:
(R:Ring,E:OrderedAbelianMonoidSup,OV:Join(OrderedSet,etc),PPR:PolynomialCategory(Polynomial(R),E,OV))->etc


kind: p
name: QuasiAlgebraicSet2
exposed: n
type: (List(Symbol))->etc
params: (vl)
abbrev: QALGSET2
comment:
\spadtype{QuasiAlgebraicSet2} adds a function \spadfun{radicalSimplify} which uses \spadtype{IdealDecompositionPackage} to simplify the representation of a quasi-algebraic set. A quasi-algebraic set is the intersection of a Zariski closed set,{} defined as the common zeros of a given list of polynomials (the defining polynomials for equations),{} and a principal Zariski open set,{} defined as the complement of the common zeros of a polynomial \spad{f} (the defining polynomial for the inequation). Quasi-algebraic sets are implemented in the domain \spadtype{QuasiAlgebraicSet},{} where two simplification routines are provided: \spadfun{idealSimplify} and \spadfun{simplify}. The function \spadfun{radicalSimplify} is added for comparison study only. Because the domain \spadtype{IdealDecompositionPackage} provides facilities for computing with radical ideals,{} it is necessary to restrict the ground ring to the domain \spadtype{Fraction Integer},{} and the polynomial ring to be of type \spadtype{DistributedMultivariatePolynomial}. The routine \spadfun{radicalSimplify} uses these to compute groebner basis of radical ideals and is inefficient and restricted when compared to the two in \spadtype{QuasiAlgebraicSet}.


kind: p
name: QuasiComponentPackage
exposed: x
params: (R,E,V,P,TS)
abbrev: QCMPACK
type:
(R:GcdDomain,E:OrderedAbelianMonoidSup,V:OrderedSet,P:RecursivePolynomialCategory(R,E,V),TS:RegularTriangularSetCategory(R,E,V,P))->etc

comment:
A package for removing redundant quasi-components and redundant branches when decomposing a variety by means of quasi-components of regular triangular sets. \newline


kind: p
name: QuaternionCategoryFunctions2
exposed: x
type: (QuaternionCategory(R),R:CommutativeRing,QS:QuaternionCategory(S),S:CommutativeRing)->etc
params: (QR,R,QS,S)
abbrev: QUATCT2
comment:
\spadtype{QuaternionCategoryFunctions2} implements functions between two quaternion domains. The function \spadfun{map} is used by the system interpreter to coerce between quaternion types.


kind: p
name: QuotientFieldCategoryFunctions2
exposed: x
type: (A:IntegralDomain,B:IntegralDomain,R:QuotientFieldCategory(A),S:QuotientFieldCategory(B))->etc
params: (A,B,R,S)
abbrev: QFCAT2
comment:
This package extends a function between integral domains to a mapping between their quotient fields.


kind: p
name: RadicalEigenPackage
exposed: x
type: ()->etc
abbrev: REP
comment:
Package for the computation of eigenvalues and eigenvectors. This package works for matrices with coefficients which are rational functions over the integers. (see \spadtype{Fraction Polynomial Integer}). The eigenvalues and eigenvectors are expressed in terms of radicals.


kind: p
name: RadicalSolvePackage
exposed: x
type: (Join(PolynomialFactorizationExplicit,etc))->etc
params: (R)
abbrev: SOLVERAD
comment:
This package tries to find solutions expressed in terms of radicals for systems of equations of rational functions with coefficients in an integral domain \spad{R}.


kind: p
name: RandomNumberSource
exposed: x
type: ()->etc
abbrev: RANDSRC
comment:
Random number generators \indented{1}{All random numbers used in the system should originate from} \indented{1}{the same generator.\space{2}This package is intended to be the source.}


kind: p
name: RationalFactorize
exposed: n
type: (UnivariatePolynomialCategory(Fraction(Integer)))->etc
params: (RP)
abbrev: RATFACT
comment:
Factorization of extended polynomials with rational coefficients. This package implements factorization of extended polynomials whose coefficients are rational numbers. It does this by taking the \spad{lcm} of the coefficients of the polynomial and creating a polynomial with integer coefficients. The algorithm in \spadtype{GaloisGroupFactorizer} is then used to factor the integer polynomial. The result is normalized with respect to the original \spad{lcm} of the denominators.


kind: p
name: RationalFunctionDefiniteIntegration
exposed: x
type: (Join(EuclideanDomain,etc))->etc
params: (R)
abbrev: DEFINTRF
comment:
\spadtype{RationalFunctionDefiniteIntegration} provides functions to compute definite integrals of rational functions.


kind: p
name: RationalFunctionFactor
exposed: x
type: (UnivariatePolynomialCategory(Fraction(Polynomial(Integer))))->etc
params: (UP)
abbrev: RFFACT
comment:
Factorization of univariate polynomials with coefficients which are rational functions with integer coefficients.


kind: p
name: RationalLODE
exposed: n
type: (F:Join(Field,etc),UP:UnivariatePolynomialCategory(F))->etc
params: (F,UP)
abbrev: ODERAT
comment:
\spad{RationalLODE} provides functions for in-field solutions of linear \indented{1}{ordinary differential equations,{} in the rational case.}


kind: p
name: RationalUnivariateRepresentationPackage
exposed: n
type: (Join(PolynomialFactorizationExplicit,etc),List(Symbol))->etc
params: (R,ls)
abbrev: RURPK
comment:
\indented{1}{A package for computing the rational univariate representation} \indented{1}{of a zero-dimensional algebraic variety given by a regular} \indented{1}{triangular set. This package is essentially an interface for the} \spadtype{InternalRationalUnivariateRepresentationPackage} constructor. It is used in the \spadtype{ZeroDimensionalSolvePackage} for solving polynomial systems with finitely many solutions.


kind: p
name: RealZeroPackage
exposed: x
type: (UnivariatePolynomialCategory(Integer))->etc
params: (Pol)
abbrev: REAL0
comment:
\indented{2}{This package provides functions for finding the real zeros} of univariate polynomials over the integers to arbitrary user-specified precision. The results are returned as a list of isolating intervals which are expressed as records with left and right rational number components.


kind: p
name: RealZeroPackageQ
exposed: x
type: (UnivariatePolynomialCategory(Fraction(Integer)))->etc
params: (Pol)
abbrev: REAL0Q
comment:
\indented{2}{This package provides functions for finding the real zeros} of univariate polynomials over the rational numbers to arbitrary user-specified precision. The results are returned as a list of isolating intervals,{} expressed as records with left and right rational number components.


kind: p
name: RectangularMatrixCategoryFunctions2
exposed: x
params: (m,n,R1,Row1,Col1,M1,R2,Row2,Col2,M2)
abbrev: RMCAT2
type:
(m:NonNegativeInteger,n:NonNegativeInteger,R1:Join(SemiRng,etc),Row1:DirectProductCategory(n,R1),Col1:DirectProductCategory(m,R1),M1:RectangularMatrixCategory(m,n,R1,Row1,Col1),R2:Join(SemiRng,etc),Row2:DirectProductCategory(n,R2),Col2:DirectProductCategory(m,R2),M2:RectangularMatrixCategory(m,n,R2,Row2,Col2))->etc

comment:
\spadtype{RectangularMatrixCategoryFunctions2} provides functions between two matrix domains. The functions provided are \spadfun{map} and \spadfun{reduce}.


kind: p
name: RecurrenceOperator
exposed: n
type: (R:Join(Comparable,etc),F:Join(FunctionSpace(R),etc))->etc
params: (R,F)
abbrev: RECOP
comment:
This package provides an operator for the \spad{n}-th term of a recurrence and an operator for the coefficient of \spad{x^n} in a function specified by a functional equation.


kind: p
name: ReducedDivisor
exposed: n
params: (F1,UP,UPUP,R,F2)
abbrev: RDIV
type:
(F1:Field,UP:UnivariatePolynomialCategory(F1),UPUP:UnivariatePolynomialCategory(Fraction(UP)),R:FunctionFieldCategory(F1,UP,UPUP),F2:Join(Finite,etc))->etc

comment:
This package finds the order of a divisor over a field \indented{1}{using reduction to finite field.}


kind: p
name: ReduceLODE
exposed: n
params: (F,L,UP,A,LO)
abbrev: ODERED
comment: Elimination of an algebraic from the coefficients of a linear ordinary differential equation.
type:
(F:Field,L:LinearOrdinaryDifferentialOperatorCategory(F),UP:UnivariatePolynomialCategory(F),A:MonogenicAlgebra(F,UP),LO:LinearOrdinaryDifferentialOperatorCategory(A))->etc


kind: p
name: ReductionOfOrder
exposed: n
type: (F:Field,L:LinearOrdinaryDifferentialOperatorCategory(F))->etc
params: (F,L)
abbrev: REDORDER
comment:
\spadtype{ReductionOfOrder} provides functions for reducing the order of linear ordinary differential equations once some solutions are known.


kind: p
name: RegularSetDecompositionPackage
exposed: x
params: (R,E,V,P,TS)
abbrev: RSDCMPK
type:
(R:GcdDomain,E:OrderedAbelianMonoidSup,V:OrderedSet,P:RecursivePolynomialCategory(R,E,V),TS:RegularTriangularSetCategory(R,E,V,P))->etc

comment:
A package providing a new algorithm for solving polynomial systems by means of regular chains. Two ways of solving are proposed: in the sense of Zariski closure (like in Kalkbrener\spad{'s} algorithm) or in the sense of the regular zeros (like in Wu,{} Wang or Lazard methods). This algorithm is valid for nay type of regular set. It does not care about the way a polynomial is added in an regular set,{} or how two quasi-components are compared (by an inclusion-test),{} or how the invertibility test is made in the tower of simple extensions associated with a regular set. These operations are realized respectively by the domain \spad{TS} and the packages \spadtype{QCMPACK}(\spad{R},{} \spad{E},{} \spad{V},{} \spad{P},{} \spad{TS}) and \spadtype{RSETGCD}(\spad{R},{} \spad{E},{} \spad{V},{} \spad{P},{} \spad{TS}). The same way it does not care about the way univariate polynomial \spad{gcd} (with coefficients in the tower of simple extensions associated with a regular set) are computed. The only requirement is that these \spad{gcd} need to have invertible initials (normalized or not). WARNING. There is no need for a user to call directly any operation of this package since they can be accessed by the domain \spad{TS}. Thus,{} the operations of this package are not documented.\newline


kind: p
name: RegularTriangularSetGcdPackage
exposed: x
params: (R,E,V,P,TS)
abbrev: RSETGCD
comment:
An internal package for computing gcds and resultants of univariate polynomials with coefficients in a tower of simple extensions of a field.\newline


kind: p
name: RepresentationPackage1
exposed: x
type: (Ring)->etc
params: (R)
abbrev: REP1
comment:
\spad{RepresentationPackage1} provides functions for representation theory for finite groups and algebras. The package creates permutation representations and uses tensor products and its symmetric and antisymmetric components to create new representations of larger degree from given ones. Note: instead of having parameters from \spadtype{Permutation} this package allows list notation of permutations as well: \spadignore{e.g.} \spad{[1,{} 4,{} 3,{} 2]} denotes permutes 2 and 4 and fixes 1 and 3.


kind: p
name: RepresentationPackage2
exposed: x
type: (Ring)->etc
params: (R)
abbrev: REP2
comment:
\spad{RepresentationPackage2} provides functions for working with modular representations of finite groups and algebra. The routines in this package are created,{} using ideas of \spad{R}. Parker,{} (the meat-Axe) to get smaller representations from bigger ones,{} \spadignore{i.e.} finding sub- and factormodules,{} or to show,{} that such the representations are irreducible. Note: most functions are randomized functions of Las Vegas type \spadignore{i.e.} every answer is correct,{} but with small probability the algorithm fails to get an answer.


kind: p
name: RetractSolvePackage
exposed: n
type: (Q:IntegralDomain,R:Join(IntegralDomain,etc))->etc
params: (Q,R)
abbrev: RETSOL
comment:
RetractSolvePackage is an interface to \spadtype{SystemSolvePackage} that attempts to retract the coefficients of the equations before solving.


kind: p
name: SmithNormalForm
exposed: x
params: (R,Row,Col,M)
abbrev: SMITH
comment: \spadtype{SmithNormalForm} is a package which provides some standard canonical forms for matrices.
type:
(R:EuclideanDomain,Row:FiniteLinearAggregate(R),Col:FiniteLinearAggregate(R),M:MatrixCategory(R,Row,Col))->etc


kind: p
name: SortedCache
exposed: n
type: (CachableSet)->etc
params: (S)
abbrev: SCACHE
comment:
A sorted cache of a cachable set \spad{S} is a dynamic structure that keeps the elements of \spad{S} sorted and assigns an integer to each element of \spad{S} once it is in the cache. This way,{} equality and ordering on \spad{S} are tested directly on the integers associated with the elements of \spad{S},{} once they have been entered in the cache.


kind: p
name: SparsePolynomialCoercionHelpers
exposed: n
type: (Ring,VarSet1:OrderedSet,VarSet2:OrderedSet)->etc
params: (R,VarSet1,VarSet2)
abbrev: SMPCOER
comment:
This package contains a function which speeds up \indented{1}{coercion in an important special case.}


kind: p
name: SquareFreeQuasiComponentPackage
exposed: x
params: (R,E,V,P,TS)
abbrev: SFQCMPK
comment:
A internal package for removing redundant quasi-components and redundant branches when decomposing a variety by means of quasi-components of regular triangular sets. \newline


kind: p
name: SquareFreeRegularSetDecompositionPackage
exposed: x
params: (R,E,V,P,TS)
abbrev: SRDCMPK
type:
(R:GcdDomain,E:OrderedAbelianMonoidSup,V:OrderedSet,P:RecursivePolynomialCategory(R,E,V),TS:SquareFreeRegularTriangularSetCategory(R,E,V,P))->etc

comment:
A package providing a new algorithm for solving polynomial systems by means of regular chains. Two ways of solving are provided: in the sense of Zariski closure (like in Kalkbrener\spad{'s} algorithm) or in the sense of the regular zeros (like in Wu,{} Wang or Lazard- Moreno methods). This algorithm is valid for nay type of regular set. It does not care about the way a polynomial is added in an regular set,{} or how two quasi-components are compared (by an inclusion-test),{} or how the invertibility test is made in the tower of simple extensions associated with a regular set. These operations are realized respectively by the domain \spad{TS} and the packages \spad{QCMPPK(R,{} E,{} V,{} P,{} TS)} and \spad{RSETGCD(R,{} E,{} V,{} P,{} TS)}. The same way it does not care about the way univariate polynomial gcds (with coefficients in the tower of simple extensions associated with a regular set) are computed. The only requirement is that these gcds need to have invertible initials (normalized or not). WARNING. There is no need for a user to call directly any operation of this package since they can be accessed by the domain \spadtype{TS}. Thus,{} the operations of this package are not documented.\newline


kind: p
name: SquareFreeRegularTriangularSetGcdPackage
exposed: x
params: (R,E,V,P,TS)
abbrev: SFRGCD
comment:
A internal package for computing gcds and resultants of univariate polynomials with coefficients in a tower of simple extensions of a field. There is no need to use directly this package since its main operations are available from \spad{TS}. \newline


kind: p
name: StorageEfficientMatrixOperations
exposed: n
type: (Ring)->etc
params: (R)
abbrev: MATSTOR
comment:
This package provides standard arithmetic operations on matrices. The functions in this package store the results of computations in existing matrices,{} rather than creating new matrices. This package works only for matrices of type Matrix and uses the internal representation of this type.


kind: p
name: STransformPackage
exposed: x
params: (R,UTSR,ULSR,UPSR)
abbrev: STRANS
comment: A package to compute Taylor and Puiseux series of \spad{S}-transforms.
type:
(R:Join(CommutativeRing,etc),UTSR:UnivariateTaylorSeriesCategory(R),ULSR:UnivariateLaurentSeriesConstructorCategory(R,UTSR),UPSR:UnivariatePuiseuxSeriesConstructorCategory(R,ULSR))->etc


kind: p
name: StreamExponentialSeriesOperations
exposed: n
type: (CommutativeRing)->etc
params: (Coef)
abbrev: STEXPS
comment:
StreamExponentialSeriesOperations implements arithmetic of exponential power series,{} where a power series is represented by a stream of its coefficients.


kind: p
name: StreamExponentialSeriesTranscendentalFunctions
exposed: n
type: (Join(Algebra(Fraction(Integer)),etc))->etc
params: (Coef)
abbrev: STEXPST
comment:
\indented{1}{StreamExponentialSeriesTranscendentalFunctions implements} \indented{1}{exp and log of exponential power series,{}} where a power series is represented by a stream of its coefficients.


kind: p
name: StreamTaylorSeriesOperations
exposed: n
type: (Ring)->etc
params: (A)
abbrev: STTAYLOR
comment:
StreamTaylorSeriesOperations implements Taylor series arithmetic,{} where a Taylor series is represented by a stream of its coefficients,{} see corresponding operations in the category Ring.


kind: p
name: StreamTranscendentalFunctions
exposed: n
type: (Algebra(Fraction(Integer)))->etc
params: (Coef)
abbrev: STTF
comment:
StreamTranscendentalFunctions implements transcendental functions on Taylor series,{} where a Taylor series is represented by a stream of its coefficients.


kind: p
name: StreamTranscendentalFunctionsNonCommutative
exposed: n
type: (Algebra(Fraction(Integer)))->etc
params: (Coef)
abbrev: STTFNC
comment:
StreamTranscendentalFunctionsNonCommutative implements transcendental functions on Taylor series over a non-commutative ring,{} where a Taylor series is represented by a stream of its coefficients.


kind: p
name: StructuralConstantsPackage
exposed: x
type: (IntegralDomain)->etc
params: (R)
abbrev: SCPKG
comment:
StructuralConstantsPackage provides functions creating structural constants from a multiplication tables or a basis of a matrix algebra and other useful functions in this context.


kind: p
name: SturmHabichtPackage
exposed: x
type: (R:OrderedIntegralDomain,UP:UnivariatePolynomialCategory(R))->etc
params: (R,UP)
abbrev: SHP
comment:
This package provides functions for counting real roots of univariate polynomials over an OrderedIntegralDomain.


kind: p
name: SymmetricGroupCombinatoricFunctions
exposed: x
type: ()->etc
abbrev: SGCF
comment:
SymmetricGroupCombinatoricFunctions contains combinatoric functions concerning symmetric groups and representation theory: list young tableaus,{} improper partitions,{} subsets bijection of Coleman.


kind: p
name: SymmetryAnalysis
exposed: n
type: (JetBundleCategory,xi:Union(Symbol,List(Symbol)),eta:Union(Symbol,List(Symbol)))->etc
params: (JB1,xi,eta)
abbrev: SYMANA
comment:
\spad{SymmetryAnalysis(JB,{} \spad{xi},{} eta)} provides procedures for the symmetry analysis of differential equations over a given jet bundle. Currently there exist only some procedures to set up the determining system for the symmetry generators of Lie point symmetries.


kind: p
name: SystemODESolver
exposed: n
type: (F:Field,LO:LinearOrdinaryDifferentialOperatorCategory(F))->etc
params: (F,LO)
abbrev: ODESYS
comment:
SystemODESolver provides tools for triangulating and solving some systems of linear ordinary differential equations.


kind: p
name: SystemSolvePackage
exposed: x
type: (IntegralDomain)->etc
params: (R)
abbrev: SYSSOLP
comment:
Symbolic solver for systems of rational functions with coefficients in an integral domain \spad{R}. The systems are solved in the field of rational functions over \spad{R}. Solutions are exact of the form variable = value when the value is a member of the coefficient domain \spad{R}. Otherwise the solutions are implicitly expressed as roots of univariate polynomial equations over \spad{R}. Care is taken to guarantee that the denominators of the input equations do not vanish on the solution sets. The arguments to solve can either be given as equations or as rational functions interpreted as equal to zero. The user can specify an explicit list of symbols to be solved for,{} treating all other symbols appearing as parameters or omit the list of symbols in which case the system tries to solve with respect to all symbols appearing in the input.


kind: p
name: TableauxBumpers
exposed: n
type: (OrderedSet)->etc
params: (S)
abbrev: TABLBUMP
comment:
TableauBumpers implements the Schenstead-Knuth correspondence between sequences and pairs of Young tableaux. The 2 Young tableaux are represented as a single tableau with pairs as components.


kind: p
name: TabulatedComputationPackage
exposed: n
type: (SetCategory,Entry:SetCategory)->etc
params: (Key,Entry)
abbrev: TBCMPPK
comment:
\spad{TabulatedComputationPackage(Key ,{} Entry)} provides some modest support for dealing with operations with type \spad{Key -> Entry}. The result of such operations can be stored and retrieved with this package by using a hash-table. The user does not need to worry about the management of this hash-table. However,{} only one hash-table is built by calling \spad{TabulatedComputationPackage(Key ,{} Entry)}.


kind: p
name: TaylorSolve
exposed: n
params: (F,UTSF,UTSSMPF)
abbrev: UTSSOL
type:
(F:Field,UTSF:UnivariateTaylorSeriesCategory(F),UTSSMPF:UnivariateTaylorSeriesCategory(SparseMultivariatePolynomialExpressions(F)))->etc


kind: p
name: TexFormat1
exposed: x
type: (SetCategory)->etc
params: (S)
abbrev: TEX1
comment:
\spadtype{TexFormat1} provides a utility coercion for changing to TeX format anything that has a coercion to the standard output format.


kind: p
name: TopLevelDrawFunctionsForAlgebraicCurves
exposed: x
type: (R:Join(IntegralDomain,etc),Ex:FunctionSpace(R))->etc
params: (R,Ex)
abbrev: DRAWCURV
comment:
TopLevelDrawFunctionsForAlgebraicCurves provides top level functions for drawing non-singular algebraic curves.


kind: p
name: TopLevelDrawFunctionsForCompiledFunctions
exposed: x
type: ()->etc
abbrev: DRAWCFUN
comment:
TopLevelDrawFunctionsForCompiledFunctions provides top level functions for drawing graphics of expressions.


kind: p
name: TopLevelDrawFunctionsForPoints
exposed: x
type: ()->etc
abbrev: DRAWPT
comment:
TopLevelDrawFunctionsForPoints provides top level functions for drawing curves and surfaces described by sets of points.


kind: p
name: TranscendentalManipulations
exposed: x
type: (R:Join(Comparable,etc),F:Join(FunctionSpace(R),etc))->etc
params: (R,F)
abbrev: TRMANIP
comment:
TranscendentalManipulations provides functions to simplify and expand expressions involving transcendental operators.


kind: p
name: TransSolvePackage
exposed: x
type: (Join(Comparable,etc))->etc
params: (R)
abbrev: SOLVETRA
comment:
This package tries to find solutions of equations of type Expression(\spad{R}). This means expressions involving transcendental,{} exponential,{} logarithmic and nthRoot functions. After trying to transform different kernels to one kernel by applying several rules,{} it calls zerosOf for the SparseUnivariatePolynomial in the remaining kernel. For example the expression \spad{sin(x)*cos(x)-2} will be transformed to \indented{3}{\spad{-2 tan(x/2)^4 -2 tan(x/2)^3 -4 tan(x/2)^2 +2 tan(x/2) -2}} by using the function normalize and then to \indented{3}{\spad{-2 tan(x)^2 + tan(x) -2}} with help of subsTan. This function tries to express the given function in terms of \spad{tan(x/2)} to express in terms of \spad{tan(x)} . Other examples are the expressions \spad{sqrt(x+1)+sqrt(x+7)+1} or \indented{1}{\spad{sqrt(sin(x))+1} .}


kind: p
name: TransSolvePackageService
exposed: n
type: (Join(Comparable,etc))->etc
params: (R)
abbrev: SOLVESER
comment:
This package finds the function \spad{func3} where \spad{func1} and \spad{func2} \indented{1}{are given and\space{2}\spad{func1} = \spad{func3}(\spad{func2}) .\space{2}If there is no solution then} \indented{1}{function \spad{func1} will be returned.} \indented{1}{An example would be\space{2}\spad{func1 := 8*X^3+32*X^2-14*X ::EXPR INT} and} \indented{1}{\spad{func2 := 2*X ::EXPR INT} convert them via univariate} \indented{1}{to FRAC SUP EXPR INT and then the solution is \spad{func3 := X^3+X^2-X}} \indented{1}{of type FRAC SUP EXPR INT}


kind: p
name: TriangularMatrixOperations
exposed: n
params: (R,Row,Col,M)
abbrev: TRIMAT
type:
(R:IntegralDomain,Row:FiniteLinearAggregate(R),Col:FiniteLinearAggregate(R),M:MatrixCategory(R,Row,Col))->etc

comment:
This package provides functions that compute fraction-free inverses of upper and lower triangular matrices over a integral domain. By fraction-free inverses we mean the following: given a matrix \spad{B} with entries in \spad{R} and an element \spad{d} of \spad{R} such that \spad{d} * inv(\spad{B}) also has entries in \spad{R},{} we return \spad{d} * inv(\spad{B}). Thus,{} it is not necessary to pass to the quotient field in any of our computations.


kind: p
name: TrigonometricManipulations
exposed: x
type: (R:Join(GcdDomain,etc),F:Join(AlgebraicallyClosedField,etc))->etc
params: (R,F)
abbrev: TRIGMNIP
comment:
\spadtype{TrigonometricManipulations} provides transformations from trigonometric functions to complex exponentials and logarithms,{} and back.


kind: p
name: TwoDimensionalArrayFunctions
exposed: n
params: (A,RA,CA,MA,B,RB,CB,MB)
abbrev: ARRAY22
type:
(A:Type,RA:FiniteLinearAggregate(A),CA:FiniteLinearAggregate(A),MA:TwoDimensionalArrayCategory(A,RA,CA),B:Type,RB:FiniteLinearAggregate(B),CB:FiniteLinearAggregate(B),MB:TwoDimensionalArrayCategory(B,RB,CB))->etc


kind: p
name: TwoDimensionalPlotClipping
exposed: n
type: ()->etc
abbrev: CLIP
comment:
\indented{1}{The purpose of this package is to provide reasonable plots of} functions with singularities.


kind: p
name: TwoFactorize
exposed: n
type: (FiniteFieldCategory)->etc
params: (F)
abbrev: TWOFACT
comment:
A basic package for the factorization of bivariate polynomials over a finite field. The functions here represent the base step for the multivariate factorizer.


kind: p
name: U32VectorPolynomialOperations
exposed: n
type: ()->etc
abbrev: POLYVEC
comment:
This is a low-level package which implements operations \indented{1}{on vectors treated as univariate modular polynomials.\space{2}Most} \indented{1}{operations takes modulus as parameter.\space{2}Modulus is machine} \indented{1}{sized prime which should be small enough to avoid overflow} \indented{1}{in intermediate calculations.}


kind: p
name: Unittest
exposed: n
type: ()->etc
abbrev: TESTUNIT
comment:
Unittest is a package that provides functions for regression \indented{13}{testing.\space{2}Note that it calls the interpreter,{} thus,{} all} \indented{13}{functions require that their arguments be passed as strings.}


kind: p
name: UnittestAux
exposed: n
type: (BasicType)->etc
params: (R)
abbrev: TESTAUX
comment:
UnittestAux is an auxiliary package to Unittest,{} that performs \indented{13}{checking of tests,{} dealing also with fatal errors.}


kind: p
name: UnittestCount
exposed: n
type: ()->etc
abbrev: TESTCNT
comment:
UnittestCount is a package that keeps track of statistics \indented{13}{collected during testing.\space{2}It is separate from} \indented{13}{\spadtype{UnittestAux} because the latter takes an argument,{}} \indented{13}{and we want the state to be common for all arguments.}


kind: p
name: UnivariateLaurentSeriesFunctions2
exposed: x
type: (Coef1:Ring,Coef2:Ring,var1:Symbol,var2:Symbol,cen1:Coef1,cen2:Coef2)->etc
params: (Coef1,Coef2,var1,var2,cen1,cen2)
abbrev: ULS2
comment:
Mapping package for univariate Laurent series \indented{2}{This package allows one to apply a function to the coefficients of} \indented{2}{a univariate Laurent series.}


kind: p
name: UnivariatePolynomialCategoryFunctions2
exposed: x
params: (R,PR,S,PS)
abbrev: UPOLYC2
type:
(R:Join(SemiRng,etc),PR:UnivariatePolynomialCategory(R),S:Join(SemiRng,etc),PS:UnivariatePolynomialCategory(S))->etc

comment:
Mapping from polynomials over \spad{R} to polynomials over \spad{S} given a map from \spad{R} to \spad{S} assumed to send zero to zero.


kind: p
name: UnivariatePolynomialDecompositionPackage
exposed: x
type: (R:IntegralDomain,UP:UnivariatePolynomialCategory(R))->etc
params: (R,UP)
abbrev: UPDECOMP
comment:
UnivariatePolynomialDecompositionPackage implements functional decomposition of univariate polynomial with coefficients in an \spad{IntegralDomain} of \spad{CharacteristicZero}.


kind: p
name: UnivariatePolynomialDivisionPackage
exposed: n
type: (R:IntegralDomain,UP:UnivariatePolynomialCategory(R))->etc
params: (R,UP)
abbrev: UPDIVP
comment:
UnivariatePolynomialDivisionPackage provides a division for non monic univarite polynomials with coefficients in an \spad{IntegralDomain}.


kind: p
name: UnivariatePolynomialFunctions2
exposed: x
type: (Symbol,R:Ring,y:Symbol,S:Ring)->etc
params: (x,R,y,S)
abbrev: UP2
comment:
This package lifts a mapping from coefficient rings \spad{R} to \spad{S} to a mapping from \spadtype{UnivariatePolynomial}(\spad{x},{} \spad{R}) to \spadtype{UnivariatePolynomial}(\spad{y},{} \spad{S}). Note that the mapping is assumed to send zero to zero,{} since it will only be applied to the non-zero coefficients of the polynomial.


kind: p
name: UnivariatePolynomialMultiplicationPackage
exposed: x
type: (R:Ring,U:UnivariatePolynomialCategory(R))->etc
params: (R,U)
abbrev: UPMP
comment:
This package implements Karatsuba\spad{'s} trick for multiplying (large) univariate polynomials. It could be improved with a version doing the work on place and also with a special case for squares. We've done this in Basicmath,{} but we believe that this out of the scope of FriCAS.


kind: p
name: UnivariatePolynomialSquareFree
exposed: n
type: (RC:IntegralDomain,P:Join(UnivariatePolynomialCategory(RC),etc))->etc
params: (RC,P)
abbrev: UPSQFREE
comment:
This package provides for square-free decomposition of univariate polynomials over arbitrary rings,{} \spadignore{i.e.} a partial factorization such that each factor is a product of irreducibles with multiplicity one and the factors are pairwise relatively prime. If the ring has characteristic zero,{} the result is guaranteed to satisfy this condition. If the ring is an infinite ring of finite characteristic,{} then it may not be possible to decide when polynomials contain factors which are \spad{p}th powers. In this case,{} the flag associated with that polynomial is set to nil (meaning that that polynomials are not guaranteed to be square-free).


kind: p
name: UnivariatePuiseuxSeriesFunctions2
exposed: x
type: (Coef1:Ring,Coef2:Ring,var1:Symbol,var2:Symbol,cen1:Coef1,cen2:Coef2)->etc
params: (Coef1,Coef2,var1,var2,cen1,cen2)
abbrev: UPXS2
comment:
Mapping package for univariate Puiseux series. This package allows one to apply a function to the coefficients of a univariate Puiseux series.


kind: p
name: UnivariateSkewPolynomialCategoryOps
exposed: n
type: (R:Ring,C:UnivariateSkewPolynomialCategory(R))->etc
params: (R,C)
abbrev: OREPCTO
comment:
\spad{UnivariateSkewPolynomialCategoryOps} provides products and \indented{1}{divisions of univariate skew polynomials.}


kind: p
name: UnivariateTaylorSeriesFunctions2
exposed: x
params: (Coef1,Coef2,UTS1,UTS2)
abbrev: UTS2
type:
(Coef1:Ring,Coef2:Ring,UTS1:UnivariateTaylorSeriesCategory(Coef1),UTS2:UnivariateTaylorSeriesCategory(Coef2))->etc

comment:
Mapping package for univariate Taylor series. \indented{2}{This package allows one to apply a function to the coefficients of} \indented{2}{a univariate Taylor series.}


kind: p
name: UnivariateTaylorSeriesODESolver
exposed: n
type: (Coef:Algebra(Fraction(Integer)),UTS:UnivariateTaylorSeriesCategory(Coef))->etc
params: (Coef,UTS)
abbrev: UTSODE
comment:
\indented{1}{This package provides Taylor series solutions to regular} linear or non-linear ordinary differential equations of arbitrary order.


kind: p
name: UserDefinedVariableOrdering
exposed: x
type: ()->etc
abbrev: UDVO
comment:
This packages provides functions to allow the user to select the ordering on the variables and operators for displaying polynomials,{} fractions and expressions. The ordering affects the display only and not the computations.


kind: p
name: UTSodetools
exposed: n
params: (F,UP,L,UTS)
abbrev: UTSODETL
type:
(F:Ring,UP:UnivariatePolynomialCategory(F),L:LinearOrdinaryDifferentialOperatorCategory(UP),UTS:UnivariateTaylorSeriesCategory(F))->etc

comment:
\spad{RUTSodetools} provides tools to interface with the series \indented{1}{ODE solver when presented with linear ODEs.}


kind: p
name: VectorFunctions2
exposed: x
type: (Type,B:Type)->etc
params: (A,B)
abbrev: VECTOR2
comment:
\indented{2}{This package provides operations which all take as arguments} vectors of elements of some type \spad{A} and functions from \spad{A} to another of type \spad{B}. The operations all iterate over their vector argument and either return a value of type \spad{B} or a vector over \spad{B}.


kind: p
name: ViewportPackage
exposed: n
type: ()->etc
abbrev: VIEW
comment:
ViewportPackage provides functions for creating GraphImages and TwoDimensionalViewports from lists of lists of points.


kind: p
name: WeierstrassPreparation
exposed: n
type: (Field)->etc
params: (R)
abbrev: WEIER
comment:
This package implements the Weierstrass preparation theorem \spad{f} for multivariate power series. weierstrass(\spad{v},{} \spad{p}) where \spad{v} is a variable,{} and \spad{p} is a TaylorSeries(\spad{R}) in which there is term of form c*v^s where \spad{c} is a constant. Let \spad{s} be minimal as above. The result is a list of TaylorSeries coefficients A[\spad{i}] of the equivalent polynomial A = A[0] + A[1]\spad{*v} + A[2]\spad{*v^2} + ... + A[\spad{s}-1]\spad{*v^}(\spad{s}-1) + \spad{v^s} such that p=A*B ,{} \spad{B} being a TaylorSeries of minimum degree 0


kind: p
name: WildFunctionFieldIntegralBasis
exposed: n
params: (K,R,UP,F)
abbrev: WFFINTBS
type:
(K:FiniteFieldCategory,R:UnivariatePolynomialCategory(K),UP:UnivariatePolynomialCategory(R),FramedAlgebra(R,UP))->etc

comment:
In this package \spad{K} is a finite field,{} \spad{R} is a ring of univariate polynomials over \spad{K},{} and \spad{F} is a framed algebra over \spad{R}. The package provides a function to compute the integral closure of \spad{R} in the quotient field of \spad{F} as well as a function to compute a local integral basis at a specific prime.


kind: p
name: XDistributedPolynomialFunctions
exposed: n
type: (OrderedSet,F:Field)->etc
params: (VAR,F)
abbrev: XDPOLYF
comment:
Using the Hankel matrix of a noncommutative polynomial one can determine the rank (Matrices de Hankel by Fliess). The extended Ho-Algorithmus (Fornasini+Marchesini) is used to create a minimal linear representation. Another approach is implemented in NonCommutativeRationalFunctions.


kind: p
name: XExponentialPackage
exposed: n
type: (R:Join(Ring,etc),VarSet:OrderedSet,XPOLY:XPolynomialsCat(VarSet,R))->etc
params: (R,VarSet,XPOLY)
abbrev: XEXPPKG
comment:
This package provides computations of logarithms and exponentials for polynomials in non-commutative variables. \newline Author: Michel Petitot (petitot@lifl.\spad{fr}).


kind: p
name: ZeroDimensionalSolvePackage
exposed: x
type: (Join(OrderedRing,etc),ls:List(Symbol),ls2:List(Symbol))->etc
params: (R,ls,ls2)
abbrev: ZDSOLVE
comment:
A package for computing symbolically the complex and real roots of zero-dimensional algebraic systems over the integer or rational numbers. Complex roots are given by means of univariate representations of irreducible regular chains. Real roots are given by means of tuples of coordinates lying in the \spadtype{RealClosure} of the coefficient ring. This constructor takes three arguments. The first one \spad{R} is the coefficient ring. The second one \spad{ls} is the list of variables involved in the systems to solve. The third one must be \spad{concat(ls,{} s)} where \spad{s} is an additional symbol used for the univariate representations. WARNING: The third argument is not checked. All operations are based on triangular decompositions. The default is to compute these decompositions directly from the input system by using the \spadtype{RegularChain} domain constructor. The lexTriangular algorithm can also be used for computing these decompositions (see the \spadtype{LexTriangularPackage} package constructor). For that purpose,{} the operations \spadopFrom{univariateSolve}{ZeroDimensionalSolvePackage},{} \spadopFrom{realSolve}{ZeroDimensionalSolvePackage} and \spadopFrom{positiveSolve}{ZeroDimensionalSolvePackage} admit an optional argument. \newline Author: Marc Moreno Maza.


kind: x
name: DifferentialPolynomialCategory&
exposed: n
params: (A,R,S,V,E)
abbrev: DPOLCAT-
type:
(DifferentialPolynomialCategory(R,S,V,E),R:Ring,S:OrderedSet,V:DifferentialVariableCategory(S),E:OrderedAbelianMonoidSup)->etc

comment:
\spadtype{DifferentialPolynomialCategory} is a category constructor specifying basic functions in an ordinary differential polynomial ring with a given ordered set of differential indeterminates. In addition,{} it implements defaults for the basic functions. The functions \spadfun{order} and \spadfun{weight} are extended from the set of derivatives of differential indeterminates to the set of differential polynomials. Other operations provided on differential polynomials are \spadfun{leader},{} \spadfun{initial},{} \spadfun{separant},{} \spadfun{differentialVariables},{} and \spadfun{isobaric?}. Furthermore,{} if the ground ring is a differential ring,{} then evaluation (substitution of differential indeterminates by elements of the ground ring or by differential polynomials) is provided by \spadfun{eval}. A convenient way of referencing derivatives is provided by the functions \spadfun{makeVariable}. \blankline To construct a domain using this constructor,{} one needs to provide a ground ring \spad{R},{} an ordered set \spad{S} of differential indeterminates,{} a ranking \spad{V} on the set of derivatives of the differential indeterminates,{} and a set \spad{E} of exponents in bijection with the set of differential monomials in the given differential indeterminates. \blankline


kind: x
name: FiniteDivisorCategory&
exposed: n
params: (S,F,UP,UPUP,R)
abbrev: FDIVCAT-
type:
(FiniteDivisorCategory(F,UP,UPUP,R),F:Field,UP:UnivariatePolynomialCategory(F),UPUP:UnivariatePolynomialCategory(Fraction(UP)),R:FunctionFieldCategory(F,UP,UPUP))->etc

comment:
This category describes finite rational divisors on a curve,{} that is finite formal sums SUM(\spad{n} * \spad{P}) where the \spad{n}\spad{'s} are integers and the \spad{P}\spad{'s} are finite rational points on the curve.


kind: x
name: FunctionFieldCategory&
exposed: n
params: (S,F,UP,UPUP)
abbrev: FFCAT-
comment: This category is a model for the function field of a plane algebraic curve.
type:
(FunctionFieldCategory(F,UP,UPUP),F:UniqueFactorizationDomain,UP:UnivariatePolynomialCategory(F),UPUP:UnivariatePolynomialCategory(Fraction(UP)))->etc


kind: x
name: MatrixCategory&
exposed: n
params: (S,R,Row,Col)
abbrev: MATCAT-
type:
(MatrixCategory(R,Row,Col),R:AbelianMonoid,Row:FiniteLinearAggregate(R),Col:FiniteLinearAggregate(R))->etc

comment:
\spadtype{MatrixCategory} is a general matrix category which allows different representations and indexing schemes. Rows and columns may be extracted with rows returned as objects of type Row and columns returned as objects of type Col. A domain belonging to this category will be shallowly mutable. The index of the 'first' row may be obtained by calling the function \spadfun{minRowIndex}. The index of the 'first' column may be obtained by calling the function \spadfun{minColIndex}. The index of the first element of a Row is the same as the index of the first column in a matrix and vice versa.


kind: x
name: MaybeSkewPolynomialCategory&
exposed: n
params: (S,R,E,VarSet)
abbrev: GPOLCAT-
type:
(MaybeSkewPolynomialCategory(R,E,VarSet),R:Join(SemiRng,etc),E:OrderedAbelianMonoidSup,VarSet:OrderedSet)->etc

comment:
The category for general multi-variate possibly skew polynomials over a ring \spad{R},{} in variables from VarSet,{} with exponents from the \spadtype{OrderedAbelianMonoidSup}.


kind: x
name: PolynomialCategory&
exposed: n
params: (S,R,E,VarSet)
abbrev: POLYCAT-
type:
(PolynomialCategory(R,E,VarSet),R:Join(SemiRng,etc),E:OrderedAbelianMonoidSup,VarSet:OrderedSet)->etc

comment:
The category for general multi-variate polynomials over a ring \spad{R},{} in variables from VarSet,{} with exponents from the \spadtype{OrderedAbelianMonoidSup}. Here variables commute with the coefficients.


kind: x
name: PolynomialSetCategory&
exposed: n
params: (S,R,E,VarSet,P)
abbrev: PSETCAT-
type:
(PolynomialSetCategory(R,E,VarSet,P),R:Ring,E:OrderedAbelianMonoidSup,VarSet:OrderedSet,P:RecursivePolynomialCategory(R,E,VarSet))->etc

comment:
A category for finite subsets of a polynomial ring. Such a set is only regarded as a set of polynomials and not identified to the ideal it generates. So two distinct sets may generate the same the ideal. Furthermore,{} for \spad{R} being an integral domain,{} a set of polynomials may be viewed as a representation of the ideal it generates in the polynomial ring \spad{(R)^(-1) P},{} or the set of its zeros (described for instance by the radical of the previous ideal,{} or a split of the associated affine variety) and so on. So this category provides operations about those different notions.


kind: x
name: RealRootCharacterizationCategory&
exposed: n
params: (S,TheField,ThePols)
abbrev: RRCC-
type:
(RealRootCharacterizationCategory(TheField,ThePols),TheField:Join(OrderedRing,etc),ThePols:UnivariatePolynomialCategory(TheField))->etc

comment:
\spadtype{RealRootCharacterizationCategory} provides common access functions for all real root codings.


kind: x
name: RectangularMatrixCategory&
exposed: n
params: (S,m,n,R,Row,Col)
abbrev: RMATCAT-
type:
(RectangularMatrixCategory(m,n,R,Row,Col),m:NonNegativeInteger,n:NonNegativeInteger,R:Join(SemiRng,etc),Row:DirectProductCategory(n,R),Col:DirectProductCategory(m,R))->etc

comment:
\spadtype{RectangularMatrixCategory} is a category of matrices of fixed dimensions. The dimensions of the matrix will be parameters of the domain. Domains in this category will be \spad{R}-modules and will be non-mutable.


kind: x
name: RegularTriangularSetCategory&
exposed: n
params: (S,R,E,V,P)
abbrev: RSETCAT-
type:
(RegularTriangularSetCategory(R,E,V,P),R:GcdDomain,E:OrderedAbelianMonoidSup,V:OrderedSet,P:RecursivePolynomialCategory(R,E,V))->etc

comment:
The category of regular triangular sets,{} introduced under the name regular chains in [1] (and other papers). In [3] it is proved that regular triangular sets and towers of simple extensions of a field are equivalent notions. In the following definitions,{} all polynomials and ideals are taken from the polynomial ring \spad{k[x1,{} ...,{} xn]} where \spad{k} is the fraction field of \spad{R}. The triangular set \spad{[t1,{} ...,{} tm]} is regular iff for every \spad{i} the initial of \spad{ti+1} is invertible in the tower of simple extensions associated with \spad{[t1,{} ...,{} \spad{ti}]}. A family \spad{[T1,{} ...,{} Ts]} of regular triangular sets is a split of Kalkbrener of a given ideal \spad{I} iff the radical of \spad{I} is equal to the intersection of the radical ideals generated by the saturated ideals of the \spad{[T1,{} ...,{} \spad{Ti}]}. A family \spad{[T1,{} ...,{} Ts]} of regular triangular sets is a split of Kalkbrener of a given triangular set \spad{T} iff it is a split of Kalkbrener of the saturated ideal of \spad{T}. Let \spad{K} be an algebraic closure of \spad{k}. Assume that \spad{V} is finite with cardinality \spad{n} and let \spad{A} be the affine space \spad{K^n}. For a regular triangular set \spad{T} let denote by \spad{W(T)} the set of regular zeros of \spad{T}. A family \spad{[T1,{} ...,{} Ts]} of regular triangular sets is a split of Lazard of a given subset \spad{S} of \spad{A} iff the union of the \spad{W(\spad{Ti})} contains \spad{S} and is contained in the closure of \spad{S} (\spad{w}.\spad{r}.\spad{t}. Zariski topology). A family \spad{[T1,{} ...,{} Ts]} of regular triangular sets is a split of Lazard of a given triangular set \spad{T} if it is a split of Lazard of \spad{W(T)}. Note that if \spad{[T1,{} ...,{} Ts]} is a split of Lazard of \spad{T} then it is also a split of Kalkbrener of \spad{T}. The converse is \spad{false}. This category provides operations related to both kinds of splits,{} the former being related to ideals decomposition whereas the latter deals with varieties decomposition. See the example illustrating the \spadtype{RegularTriangularSet} constructor for more explanations about decompositions by means of regular triangular sets. \newline


kind: x
name: SquareMatrixCategory&
exposed: n
params: (S,ndim,R,Row,Col)
abbrev: SMATCAT-
type:
(SquareMatrixCategory(ndim,R,Row,Col),ndim:NonNegativeInteger,R:Join(SemiRng,etc),Row:DirectProductCategory(ndim,R),Col:DirectProductCategory(ndim,R))->etc

comment:
\spadtype{SquareMatrixCategory} is a general square matrix category which allows different representations and indexing schemes. Rows and columns may be extracted with rows returned as objects of type Row and columns returned as objects of type Col.


kind: x
name: TaylorSeriesExpansion&
exposed: n
params: (S,Coef,Expon,Var,PS,UTS)
abbrev: TSEREXP-
comment: Category for operations needed by Taylor expansions.
type:
(TaylorSeriesExpansion(Coef,Expon,Var,PS,UTS),Coef:Algebra(Fraction(Integer)),Expon:OrderedAbelianMonoid,Var:OrderedSet,PS:PowerSeriesCategory(Coef,Expon,Var),UTS:UnivariateTaylorSeriesCategory(Coef))->etc


kind: x
name: TriangularSetCategory&
exposed: n
params: (S,R,E,V,P)
abbrev: TSETCAT-
type:
(TriangularSetCategory(R,E,V,P),R:IntegralDomain,E:OrderedAbelianMonoidSup,V:OrderedSet,P:RecursivePolynomialCategory(R,E,V))->etc

comment:
The category of triangular sets of multivariate polynomials with coefficients in an integral domain. Let \spad{R} be an integral domain and \spad{V} a finite ordered set of variables,{} say \spad{X1 < X2 < ... < Xn}. A set \spad{S} of polynomials in \spad{R[X1,{} X2,{} ...,{} Xn]} is triangular if no elements of \spad{S} lies in \spad{R},{} and if two distinct elements of \spad{S} have distinct main variables. Note that the empty set is a triangular set. A triangular set is not necessarily a (lexicographical) Groebner basis and the notion of reduction related to triangular sets is based on the recursive view of polynomials. We recall this notion here and refer to [1] for more details. A polynomial \spad{P} is reduced \spad{w}.\spad{r}.\spad{t} a non-constant polynomial \spad{Q} if the degree of \spad{P} in the main variable of \spad{Q} is less than the main degree of \spad{Q}. A polynomial \spad{P} is reduced \spad{w}.\spad{r}.\spad{t} a triangular set \spad{T} if it is reduced \spad{w}.\spad{r}.\spad{t}. every polynomial of \spad{T}. \newline


kind: x
name: TwoDimensionalArrayCategory&
exposed: n
params: (S,R,Row,Col)
abbrev: ARR2CAT-
type:
(TwoDimensionalArrayCategory(R,Row,Col),R:Type,Row:IndexedAggregate(Integer,R),Col:IndexedAggregate(Integer,R))->etc

comment:
\indented{1}{TwoDimensionalArrayCategory is a general array category which} allows different representations and indexing schemes. Rows and columns may be extracted with rows returned as objects of type Row and columns returned as objects of type Col. The index of the 'first' row may be obtained by calling the function 'minRowIndex'. The index of the 'first' column may be obtained by calling the function 'minColIndex'. The index of the first element of a 'Row' is the same as the index of the first column in an array and vice versa.


kind: x
name: UnivariateLaurentSeriesConstructorCategory&
exposed: n
params: (S,Coef,UTS)
abbrev: ULSCCAT-
type:
(UnivariateLaurentSeriesConstructorCategory(Coef,UTS),Coef:Ring,UTS:UnivariateTaylorSeriesCategory(Coef))->etc

comment:
This is a category of univariate Laurent series constructed from univariate Taylor series. A Laurent series is represented by a pair \spad{[n,{} f(x)]},{} where \spad{n} is an arbitrary integer and \spad{f(x)} is a Taylor series. This pair represents the Laurent series \spad{x^n * f(x)}.


kind: x
name: UnivariatePuiseuxSeriesConstructorCategory&
exposed: n
params: (S,Coef,ULS)
abbrev: UPXSCCA-
type:
(UnivariatePuiseuxSeriesConstructorCategory(Coef,ULS),Coef:Ring,ULS:UnivariateLaurentSeriesCategory(Coef))->etc

comment:
This is a category of univariate Puiseux series constructed from univariate Laurent series. A Puiseux series is represented by a pair \spad{[r,{} f(x)]},{} where \spad{r} is a positive rational number and \spad{f(x)} is a Laurent series. This pair represents the Puiseux series \spad{f(x^r)}.


