# olibdb

kind: o
name: integrate
exposed: n
type: (A,Stream(A))->Stream(A)
params: pStreamTaylorSeriesOperations(A)
abbrev: has(A,Algebra(Fraction(Integer)))
comment:
\spad{integrate(r,{} a)} returns the integral of the power series \spad{a} with respect to the power series variable where \spad{r} denotes the constant of integration. Thus \spad{integrate(a,{} [a0,{} a1,{} a2,{} ...]) = [a,{} a0,{} a1/2,{} a2/3,{} ...]}.


kind: o
name: integrate
exposed: n
type: (%,PositiveInteger)->%
params: cJetBundleCategory
comment:
\spad{integrate(jv,{} i)} is like \spad{integrateIfCan(jv,{} i)} but yields an error,{} if the integration is not possible.


kind: o
name: integrate
exposed: n
type: (%,Symbol)->%
params: cUnivariateSeriesWithRationalExponents(Coef,Expon)
abbrev:
AND(has(Coef,Algebra(Fraction(Integer))),has(Coef,SIGNATURE(integrate,Coef(Coef,Symbol))),has(Coef,SIGNATURE(variables,List(Symbol)(Coef))))

comment:
\spad{integrate(f(x),{} y)} returns an anti-derivative of the power series \spad{f(x)} with respect to the variable \spad{y}.


kind: o
name: integrate
exposed: n
type: (%,Variable(var))->%
params: dSparseUnivariateTaylorSeries(Coef,var,cen)
abbrev: has(Coef,Algebra(Fraction(Integer)))
comment:
\spad{integrate(f(x),{} x)} returns an anti-derivative of the power series \spad{f(x)} with constant coefficient 0. We may integrate a series when we can divide coefficients by integers.


kind: o
name: integrate
exposed: x
params: pRationalFunctionDefiniteIntegration(R)
type:
(Fraction(Polynomial(R)),SegmentBinding(OrderedCompletion(Expression(R))))->Union(f1:OrderedCompletion(Expression(R)),f2:List(OrderedCompletion(Expression(R))),fail:failed,pole:potentialPole)

comment:
\spad{integrate(f,{} x = a..b)} returns the integral of \spad{f(x)dx} from a to \spad{b}. Error: if \spad{f} has a pole for \spad{x} between a and \spad{b}.


kind: o
name: integrate
exposed: x
params: pRationalFunctionDefiniteIntegration(R)
type:
(Fraction(Polynomial(R)),SegmentBinding(OrderedCompletion(Fraction(Polynomial(R)))))->Union(f1:OrderedCompletion(Expression(R)),f2:List(OrderedCompletion(Expression(R))),fail:failed,pole:potentialPole)

comment:
\spad{integrate(f,{} x = a..b)} returns the integral of \spad{f(x)dx} from a to \spad{b}. Error: if \spad{f} has a pole for \spad{x} between a and \spad{b}.


kind: o
name: integrate
exposed: x
type: (Fraction(Polynomial(R)),Symbol)->Union(Expression(R),List(Expression(R)))
params: pIntegrationResultRFToFunction(R)
abbrev: has(R,CharacteristicZero)
comment:
\spad{integrate(f,{} x)} returns the integral of \spad{f(x)dx} where \spad{x} is viewed as a real variable.


kind: o
name: integrate
exposed: x
params: pElementaryFunctionDefiniteIntegration(R,F)
type:
(F,SegmentBinding(OrderedCompletion(F)))->Union(f1:OrderedCompletion(F),f2:List(OrderedCompletion(F)),fail:failed,pole:potentialPole)

comment:
\spad{integrate(f,{} x = a..b)} returns the integral of \spad{f(x)dx} from a to \spad{b}. Error: if \spad{f} has a pole for \spad{x} between a and \spad{b}.


kind: o
name: integrate
exposed: x
type: (%,Symbol)->%
params: dPolynomial(R)
abbrev: has(R,Algebra(Fraction(Integer)))
comment:
\spad{integrate(p,{} x)} computes the integral of \spad{p*dx},{} \spadignore{i.e.} integrates the polynomial \spad{p} with respect to the variable \spad{x}.


kind: o
name: integrate
exposed: x
type: (UPS,Distribution(R))->S
params: pDistributionPolynomialPackage(R,S,UPS)
comment:
\spad{integrate(p,{} d)} integrates the polynomial \spad{p} against the distribution \spad{d}. Same as \spad{eval(d,{} p)}.


kind: o
name: integrate
exposed: x
type: (%,Var)->%
params: cMultivariateTaylorSeriesCategory(Coef,Var)
abbrev: has(Coef,Algebra(Fraction(Integer)))
comment:
\spad{integrate(f,{} x)} returns the anti-derivative of the power series \spad{f(x)} with respect to the variable \spad{x} with constant coefficient 1. We may integrate a series when we can divide coefficients by integers.


kind: o
name: integrate
exposed: n
type: (%,Var,Coef)->%
params: dSparseMultivariateTaylorSeries(Coef,Var,SMP)
abbrev: has(Coef,Algebra(Fraction(Integer)))
comment:
\spad{integrate(s,{} v,{} c)} is the integral of \spad{s} with respect \indented{1}{to \spad{v} and having \spad{c} as the constant of integration.}


kind: o
name: integrate
exposed: x
params: pRationalFunctionDefiniteIntegration(R)
type:
(Fraction(Polynomial(R)),SegmentBinding(OrderedCompletion(Expression(R))),String)->Union(f1:OrderedCompletion(Expression(R)),f2:List(OrderedCompletion(Expression(R))),fail:failed,pole:potentialPole)

comment:
\spad{integrate(f,{} x = a..b,{} noPole)} returns the integral of \spad{f(x)dx} from a to \spad{b}. If it is not possible to check whether \spad{f} has a pole for \spad{x} between a and \spad{b} (because of parameters),{} then this function will assume that \spad{f} has no such pole. Error: if \spad{f} has a pole for \spad{x} between a and \spad{b} or if the last argument is not noPole.


kind: o
name: integrate
exposed: x
params: pRationalFunctionDefiniteIntegration(R)
type:
(Fraction(Polynomial(R)),SegmentBinding(OrderedCompletion(Fraction(Polynomial(R)))),String)->Union(f1:OrderedCompletion(Expression(R)),f2:List(OrderedCompletion(Expression(R))),fail:failed,pole:potentialPole)

comment:
\spad{integrate(f,{} x = a..b,{} noPole)} returns the integral of \spad{f(x)dx} from a to \spad{b}. If it is not possible to check whether \spad{f} has a pole for \spad{x} between a and \spad{b} (because of parameters),{} then this function will assume that \spad{f} has no such pole. Error: if \spad{f} has a pole for \spad{x} between a and \spad{b} or if the last argument is not noPole.


kind: o
name: integrate
exposed: x
params: pElementaryFunctionDefiniteIntegration(R,F)
type:
(F,SegmentBinding(OrderedCompletion(F)),String)->Union(f1:OrderedCompletion(F),f2:List(OrderedCompletion(F)),fail:failed,pole:potentialPole)

comment:
\spad{integrate(f,{} x = a..b,{} noPole)} returns the integral of \spad{f(x)dx} from a to \spad{b}. If it is not possible to check whether \spad{f} has a pole for \spad{x} between a and \spad{b} (because of parameters),{} then this function will assume that \spad{f} has no such pole. Error: if \spad{f} has a pole for \spad{x} between a and \spad{b} or if the last argument is not noPole.


kind: o
name: integrateIfCan
exposed: n
type: (%,PositiveInteger)->Union(%,failed)
params: cJetBundleCategory
comment:
\spad{integrate(jv,{} i)} integrated \spad{jv} \spad{wrt} the \spad{i}\spad{-}th independent variable,{} if possible.


kind: o
name: integrate_sols
exposed: n
params: pRationalLODE(F,UP)
comment: \spad{integrate_sols(l)} integrates the solutions of an operator \spad{l}.
type:
(LinearOrdinaryDifferentialOperator1(Fraction(UP)))->Record(ltilde:LinearOrdinaryDifferentialOperator1(Fraction(UP)),r:Union(LinearOrdinaryDifferentialOperator1(Fraction(UP)),failed))


kind: o
name: integrate_sols
exposed: n
type: (L,(L,F)->Record(particular:Union(F,failed),basis:List(F)))->Record(ltilde:L,r:Union(L,failed))
params: pIntegrateSolutions(F,L)
comment:
\spad{integrate_sols(l,{} rat_solve)} integrates the solutions of an operator \spad{l} given rat_solve(op,{} \spad{g}) that returns \spad{[failed,{} []]} if the equation \spad{op y = g} has no rational solution. Otherwise,{} the rat_solve function should return \spad{[f,{} [y1,{} ...,{} ym]]} where \spad{f} is a particular rational solution and the \spad{yi}\spad{'s} form a basis for the rational solutions of the homogeneous equation.


kind: o
name: intensity
exposed: x
type: (%,Float)->Void
params: dThreeDimensionalViewport
comment:
\spad{intensity(v,{} i)} sets the intensity of the light source to \spad{i},{} for the given three-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{ThreeDimensionalViewport}.


kind: o
name: internalAugment
exposed: x
type: (List(P),%)->%
params: cRegularTriangularSetCategory(R,E,V,P)
comment:
\spad{internalAugment(lp,{} ts)} returns \spad{ts} if \spad{lp} is empty otherwise returns \spad{internalAugment(rest lp,{} internalAugment(first lp,{} ts))}


kind: o
name: internalAugment
exposed: x
type: (P,%)->%
params: cRegularTriangularSetCategory(R,E,V,P)
comment:
\spad{internalAugment(p,{} ts)} assumes that \spad{augment(p,{} ts)} returns a singleton and returns it.


kind: o
name: internalAugment
exposed: x
type: (P,%,Boolean,Boolean,Boolean,Boolean,Boolean)->List(%)
params: dRegularTriangularSet(R,E,V,P)
comment:
\spad{internalAugment(p,{} ts,{} b1,{} b2,{} b3,{} b4,{} b5)} is an internal subroutine,{} exported only for development.


kind: o
name: internalIntegrate
exposed: n
type: (FG,Symbol)->IntegrationResult(FG)
params: pFunctionSpaceComplexIntegrationAux(G,FG)
comment:
\spad{internalIntegrate(f,{} x)} returns the integral of \spad{f(x)dx} where \spad{x} is viewed as a complex variable.


kind: o
name: internalLastSubResultant
exposed: x
type: (List(Record(val:List(P),tower:TS)),V,Boolean)->List(Record(val:P,tower:TS))
params: pRegularTriangularSetGcdPackage(R,E,V,P,TS)
comment:
\spad{internalLastSubResultant(lpwt,{} v,{} flag)} is an internal subroutine,{} exported only for development.


kind: o
name: internalLastSubResultant
exposed: x
type: (P,P,TS,Boolean,Boolean)->List(Record(val:P,tower:TS))
params: pRegularTriangularSetGcdPackage(R,E,V,P,TS)
comment:
\spad{internalLastSubResultant(p1,{} p2,{} ts,{} inv?,{} break?)} is an internal subroutine,{} exported only for development.


kind: o
name: internalSubPolSet?
exposed: x
type: (List(P),List(P))->Boolean
params: pQuasiComponentPackage(R,E,V,P,TS)
comment:
\spad{internalSubPolSet?(lp1,{} lp2)} returns \spad{true} iff \spad{lp1} is a sub-set of \spad{lp2} assuming that these lists are sorted increasingly \spad{w}.\spad{r}.\spad{t}. \spadopFrom{infRittWu?}{RecursivePolynomialCategory}.


kind: o
name: internalSubQuasiComponent?
exposed: x
type: (TS,TS)->Union(Boolean,failed)
params: pQuasiComponentPackage(R,E,V,P,TS)
comment:
\spad{internalSubQuasiComponent?(ts,{} us)} returns a boolean \spad{b} value if the fact that the regular zero set of \spad{us} contains that of \spad{ts} can be decided (and in that case \spad{b} gives this inclusion) otherwise returns \spad{failed}.


kind: o
name: internalSubQuasiComponent?
exposed: x
type: (TS,TS)->Union(Boolean,failed)
params: pSquareFreeQuasiComponentPackage(R,E,V,P,TS)
comment:
\spad{internalSubQuasiComponent?(ts,{} us)} returns a boolean \spad{b} value if the fact the regular zero set of \spad{us} contains that of \spad{ts} can be decided (and in that case \spad{b} gives this inclusion) otherwise returns \spad{failed}.


kind: o
name: internalZeroSetSplit
exposed: x
type: (List(P),Boolean,Boolean,Boolean)->List(%)
params: dRegularTriangularSet(R,E,V,P)
comment:
\spad{internalZeroSetSplit(lp,{} b1,{} b2,{} b3)} is an internal subroutine,{} exported only for development.


kind: o
name: interpolate
exposed: n
type: (List(D),List(D),NonNegativeInteger)->Fraction(SparseUnivariatePolynomial(D))
params: pFractionFreeFastGaussian(D,V)
comment:
\spad{interpolate(xlist,{} ylist,{} deg)} returns the rational function with numerator degree at most \spad{deg} and denominator degree at most \spad{\#xlist-deg-1} that interpolates the given points using fraction free arithmetic. Note that rational interpolation does not guarantee that all given points are interpolated correctly: unattainable points may make this impossible.


kind: o
name: interpolate
exposed: n
type: (List(Fraction(D)),List(Fraction(D)),NonNegativeInteger)->Fraction(SparseUnivariatePolynomial(D))
params: pFractionFreeFastGaussian(D,V)
comment:
\spad{interpolate(xlist,{} ylist,{} deg)} returns the rational function with numerator degree \spad{deg} that interpolates the given points using fraction free arithmetic.


kind: o
name: interpret
exposed: n
type: (InputForm)->R
params: pInputFormFunctions1(R)
comment:
\spad{interpret(f)} passes \spad{f} to the interpreter,{} and transforms the result into an object of type \spad{R}.


kind: o
name: interpret_in_new_env
exposed: n
type: (%)->Any
params: dInputForm
comment:
\spad{interpret_in_new_env(f)} evaluates \spad{f} in the interpreter using fresh environment which is discarded after evaluation


kind: o
name: interpretString
exposed: n
type: (String)->Any
params: pTemplateUtilities
comment:
\spad{interpretString(s)} treats a string as a piece of FriCAS input,{} by parsing and interpreting it.


kind: o
name: interReduce
exposed: n
type: (List(P))->List(P)
params: pPolynomialSetUtilitiesPackage(R,E,V,P)
comment:
\spad{interReduce(lp)} returns \spad{lq} such that \spad{lp} and \spad{lq} generate the same ideal and no polynomial in \spad{lq} is reducible by the others in the sense of Groebner bases. Since no assumptions are required the result may depend on the ordering the reductions are performed.


kind: o
name: intersect
exposed: x
type: (%,%)->%
params: cSetAggregate(S)
comment:
\spad{intersect(u,{} v)} returns the set aggregate \spad{w} consisting of elements common to both set aggregates \spad{u} and \spad{v}. Note: equivalent to the notation (not currently supported) [\spad{x} for \spad{x} in \spad{u} | member?(\spad{x},{} \spad{v})].


kind: o
name: intersect
exposed: x
type: (List(P),%)->List(%)
params: cRegularTriangularSetCategory(R,E,V,P)
comment:
\spad{intersect(lp,{} ts)} returns \spad{lts} a split of Lazard of the intersection of the affine variety associated with \spad{lp} and the regular zero set of \spad{ts}.


kind: o
name: intersection
exposed: n
type: (List(%))->%
params: dSBoundary(PT)
comment:
\spad{intersection(x)} constructs a compound boundary from the intersection of \spad{x} \spad{x:} List \% is supplied list of boundaries to form intersection.


kind: o
name: interval
exposed: x
type: (R,R)->%
params: cIntervalCategory(R)
comment:
\spad{interval(inf,{} sup)} creates a new interval,{} either \spad{[inf,{} sup]} if \spad{inf <= sup} or \spad{[sup,{} inf]} otherwise.


kind: o
name: intoMatrix
exposed: x
type: (List(P),List(OV))->Record(mat:Matrix(Fraction(P)),vec:Vector(Fraction(P)))
params: pLinearSystemPolynomialPackage(R,E,OV,P)
comment:
\spad{intoMatrix(lp,{} lvar)} converts linear in symbols lvar system of polynomials \spad{lp} = 0 into matrix form


kind: o
name: inverse
exposed: n
type: (M)->Union(M2,failed)
params: pInnerMatrixQuotientFieldFunctions(R,Row,Col,M,QF,Row2,Col2,M2)
comment:
\spad{inverse(m)} returns the inverse of the matrix \spad{m}. If the matrix is not invertible,{} failed is returned. Error: if the matrix is not square. Note: the result will have entries in the quotient field.


kind: o
name: inverse
exposed: n
type: (M)->Union(M,failed)
params: pInnerMatrixLinearAlgebraFunctions(R,Row,Col,M)
comment:
\spad{inverse(m)} returns the inverse of the matrix \spad{m}. If the matrix is not invertible,{} failed is returned. Error: if the matrix is not square.


kind: o
name: inverse
exposed: x
type: (M)->Union(M,failed)
params: pMatrixLinearAlgebraFunctions(R,Row,Col,M)
abbrev: has(R,Field)
comment:
\spad{inverse(m)} returns the inverse of the matrix. If the matrix is not invertible,{} failed is returned. Error: if the matrix is not square.


kind: o
name: inverse
exposed: x
type: (%)->Union(%,failed)
params: cSquareMatrixCategory(ndim,R,Row,Col)
abbrev: has(R,Field)
comment:
\spad{inverse(m)} returns the inverse of the matrix \spad{m},{} if that matrix is invertible and returns failed otherwise.


kind: o
name: inverseColeman
exposed: x
type: (List(Integer),List(Integer),Matrix(Integer))->List(Integer)
params: pSymmetricGroupCombinatoricFunctions
comment:
\spad{inverseColeman(alpha,{} beta,{} C)}: there is a bijection from the set of matrices having nonnegative entries and row sums {\em alpha},{} column sums {\em beta} to the set of {\em Salpha - Sbeta} double cosets of the symmetric group {\em Sn}. ({\em Salpha} is the Young subgroup corresponding to the improper partition {\em alpha}). For such a matrix \spad{C},{} inverseColeman(\spad{alpha},{} \spad{beta},{} \spad{C}) calculates the lexicographical smallest {\em \spad{pi}} in the corresponding double coset. Note: the resulting permutation {\em \spad{pi}} of {\em {1,{} 2,{} ...,{} n}} is given in list form. Notes: the inverse of this map is {\em coleman}. For details,{} see James/Kerber.


kind: o
name: inverse_cyclotomic
exposed: n
type: (Integer)->SparseUnivariatePolynomial(Integer)
params: pCyclotomicUtilities
comment:
\spad{inverse_cyclotomic(n)} computes \spad{n}-th inverse cyclotomic polynomial,{} that is \spad{(x^n - 1)/cyclotomic(n)}.


kind: o
name: inverseIntegralMatrix
exposed: x
type: ()->Matrix(Fraction(UP))
params: cFunctionFieldCategory(F,UP,UPUP)
comment:
\spad{inverseIntegralMatrix()} returns \spad{M} such that \spad{M (w1,{} ...,{} wn) = (1,{} y,{} ...,{} y^(n-1))} where \spad{(w1,{} ...,{} wn)} is the integral basis of \spadfunFrom{integralBasis}{FunctionFieldCategory}.


kind: o
name: inverseIntegralMatrixAtInfinity
exposed: x
type: ()->Matrix(Fraction(UP))
params: cFunctionFieldCategory(F,UP,UPUP)
comment:
\spad{inverseIntegralMatrixAtInfinity()} returns \spad{M} such that \spad{M (v1,{} ...,{} vn) = (1,{} y,{} ...,{} y^(n-1))} where \spad{(v1,{} ...,{} vn)} is the local integral basis at infinity returned by \spad{infIntBasis()}.


kind: o
name: inverseLaplace
exposed: x
type: (F,Symbol,Symbol)->Union(F,failed)
params: pInverseLaplaceTransform(R,F)
comment:
\spad{inverseLaplace(f,{} s,{} t)} returns the Inverse Laplace transform of \spad{f(s)} using \spad{t} as the new variable or failed if unable to find a closed form. Handles only rational \spad{f(s)}.


kind: o
name: invertALS
exposed: n
type: (%)->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{invertALS(f)} computes \spad{f^}-1 in terms of the ALS for \spad{f}. There is no check if \spad{f} is invertible!


kind: o
name: invertible?
exposed: x
type: (P,%)->Boolean
params: cRegularTriangularSetCategory(R,E,V,P)
comment:
\spad{invertible?(p,{} ts)} returns \spad{true} iff \spad{p} is invertible in the tower associated with \spad{ts}.


kind: o
name: invertible?
exposed: x
type: (P,%)->List(Record(val:Boolean,tower:%))
params: cRegularTriangularSetCategory(R,E,V,P)
comment:
\spad{invertible?(p,{} ts)} returns \spad{lbwt} where \spad{lbwt.i} is the result of \spad{invertibleElseSplit?(p,{} lbwt.i.tower)} and the list of the \spad{(lqrwt.i).tower} is a split of Kalkbrener of \spad{ts}.


kind: o
name: invertibleElseSplit?
exposed: x
type: (P,%)->Union(Boolean,List(%))
params: cRegularTriangularSetCategory(R,E,V,P)
comment:
\spad{invertibleElseSplit?(p,{} ts)} returns \spad{true} (resp. \spad{false}) if \spad{p} is invertible in the tower associated with \spad{ts} or returns a split of Kalkbrener of \spad{ts}.


kind: o
name: invertibleSet
exposed: x
type: (P,%)->List(%)
params: cRegularTriangularSetCategory(R,E,V,P)
comment:
\spad{invertibleSet(p,{} ts)} returns a split of Kalkbrener of the quotient ideal of the ideal \spad{I} by \spad{p} where \spad{I} is the radical of saturated of \spad{ts}.


kind: o
name: invertIfCan
exposed: x
type: (%)->Union(%,failed)
params: dMatrix(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{invertIfCan(m)} returns the inverse of the matrix \spad{m}. If the matrix is not invertible,{} failed is returned. Error: if the matrix is not square.


kind: o
name: invertMIN
exposed: n
type: (%)->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{invertMIN(f)} uses invertSTD(\spad{f}) and minimization to construct a minimal system for \spad{f^}-1. Linear techniques are used to get a fine pivot block structure.


kind: o
name: invertSTD
exposed: n
type: (%)->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{invertSTD(f)} computes the standard inverse of \spad{f} in terems of the admissible linear system There is no check if \spad{f} is invertible!


kind: o
name: invmultisect
exposed: n
type: (Integer,Integer,%)->%
params: dUnivariateTaylorSeries(Coef,var,cen)
comment:
\spad{invmultisect(a,{} b,{} f(x))} substitutes \spad{x^((a+b)*n)} \indented{1}{for \spad{x^n} and multiples by \spad{x^b}.}


kind: o
name: invmultisect
exposed: n
type: (Integer,Integer,Stream(A))->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{invmultisect(a,{} b,{} st)} substitutes \spad{x^((a+b)*n)} for \spad{x^n} and multiplies by \spad{x^b}.


kind: o
name: iomode
exposed: x
type: (%)->String
params: cFileCategory(Name,S)
comment:
\spad{iomode(f)} returns the status of the file \spad{f}. The input/output status of \spad{f} may be input,{} output or closed mode.


kind: o
name: irreducible?
exposed: n
type: (PA,MD)->Boolean
params: pModularFactorizationGeneral(PA,MMT,MD,PMD,MO)
comment:
\spad{irreducible?(pv,{} md)} checks if \spad{pv} is irreducible. \spad{pv} is assumed square-free and monic,{} \spad{md} is info representing finite field.


kind: o
name: irreducibleFactor
exposed: x
type: (R,NonNegativeInteger)->%
params: dFactored(R)
comment:
\spad{irreducibleFactor(base,{} exponent)} creates a factored object with a single factor whose \spad{base} is asserted to be irreducible (flag = irred).


kind: o
name: irreducibleFactors
exposed: n
type: (List(P))->List(P)
params: pPolynomialSetUtilitiesPackage(R,E,V,P)
abbrev: AND(has(R,CharacteristicZero),has(R,PolynomialFactorizationExplicit))
comment:
\spad{irreducibleFactors(lp)} returns \spad{lf} such that if \spad{lp = [p1,{} ...,{} pn]} and \spad{lf = [f1,{} ...,{} fm]} then \spad{p1*p2*...*pn=0} means \spad{f1*f2*...*fm=0},{} and the \spad{\spad{fi}} are irreducible over \spad{R} and are pairwise distinct.


kind: o
name: irreducibleRepresentation
exposed: x
type: (List(Integer))->List(Matrix(Integer))
params: pIrrRepSymNatPackage
comment:
\spad{irreducibleRepresentation(lambda)} is the list of the two irreducible representations corresponding to the partition {\em lambda} in Young\spad{'s} natural form for the following two generators of the symmetric group,{} whose elements permute {\em {1,{} 2,{} ...,{} n}},{} namely {\em (1 2)} (2-cycle) and {\em (1 2 ... n)} (\spad{n}-cycle).


kind: o
name: irreducibleRepresentation
exposed: x
type: (List(Integer),List(Permutation(Integer)))->List(Matrix(Integer))
params: pIrrRepSymNatPackage
comment:
\spad{irreducibleRepresentation(lambda,{} listOfPerm)} is the list of the irreducible representations corresponding to {\em lambda} in Young\spad{'s} natural form for the list of permutations given by {\em listOfPerm}.


kind: o
name: irreducibleRepresentation
exposed: x
type: (List(Integer),Permutation(Integer))->Matrix(Integer)
params: pIrrRepSymNatPackage
comment:
\spad{irreducibleRepresentation(lambda,{} \spad{pi})} is the irreducible representation corresponding to partition {\em lambda} in Young\spad{'s} natural form of the permutation {\em \spad{pi}} in the symmetric group,{} whose elements permute {\em {1,{} 2,{} ...,{} n}}.


kind: o
name: is?
exposed: x
type: (List(Subject),Pat)->Boolean
params: pPatternMatch(Base,Subject,Pat)
comment:
\spad{is?([e1,{} ...,{} en],{} pat)} tests if the list of expressions \spad{[e1,{} ...,{} en]} matches the pattern pat.


kind: o
name: Is
exposed: x
type: (List(Subject),Pat)->PatternMatchListResult(Base,Subject,List(Subject))
params: pPatternMatch(Base,Subject,Pat)
comment:
\spad{Is([e1,{} ...,{} en],{} pat)} matches the pattern pat on the list of expressions \spad{[e1,{} ...,{} en]} and returns the result.


kind: o
name: Is
exposed: x
type: (Subject,Pat)->List(Equation(Polynomial(Subject)))
params: pPatternMatch(Base,Subject,Pat)
abbrev: AND(has(Subject,Ring),not(has(Subject,RetractableTo(Symbol))))
comment:
\spad{Is(expr,{} pat)} matches the pattern pat on the expression \spad{expr} and returns a list of matches \spad{[v1 = e1,{} ...,{} vn = en]}; returns an empty list if either \spad{expr} is exactly equal to pat or if pat does not match \spad{expr}.


kind: o
name: Is
exposed: x
type: (Subject,Pat)->PatternMatchResult(Base,Subject)
params: pPatternMatch(Base,Subject,Pat)
abbrev: AND(not(has(Subject,RetractableTo(Symbol))),not(has(Subject,Ring)))
comment:
\spad{Is(expr,{} pat)} matches the pattern pat on the expression \spad{expr} and returns a match of the form \spad{[v1 = e1,{} ...,{} vn = en]}; returns an empty match if \spad{expr} is exactly equal to pat. returns a \spadfun{failed} match if pat does not match \spad{expr}.


kind: o
name: isAbsolutelyIrreducible?
exposed: x
type: (List(Matrix(R)))->Boolean
params: pRepresentationPackage2(R)
abbrev: has(R,Field)
comment:
\spad{isAbsolutelyIrreducible?(aG)} calls {\em isAbsolutelyIrreducible?(aG,{} 25)}. Note: the choice of 25 was rather arbitrary.


kind: o
name: isAbsolutelyIrreducible?
exposed: x
type: (List(Matrix(R)),Integer)->Boolean
params: pRepresentationPackage2(R)
abbrev: has(R,Field)
comment:
\spad{isAbsolutelyIrreducible?(aG,{} numberOfTries)} uses Norton\spad{'s} irreducibility test to check for absolute irreduciblity,{} assuming if a one-dimensional kernel is found. As no field extension changes create new elements in a one-dimensional space,{} the criterium stays \spad{true} for every extension. The method looks for one-dimensionals only by creating random elements (no fingerprints) since a run of {\em meatAxe} would have proved absolute irreducibility anyway.


kind: o
name: isAntiChain?
exposed: n
type: (%)->Boolean
params: cPoset(S)
comment:
\spad{isAntiChain?(s)} checks if \spad{s} is an antichain,{} that is any two elements in \spad{s} are incomparable.


kind: o
name: isChain?
exposed: n
type: (%)->Boolean
params: cPoset(S)
comment:
\spad{isChain?(s)} checks if \spad{s} is a chain,{} that is any two elements in \spad{s} are comparable.


kind: o
name: isDirected?
exposed: n
type: ()->Boolean
params: cFiniteGraph(S)
comment:
\spad{isDirected?()} is \spad{true} iff \% is domain consisting of directed graphs,{} \spad{false} for undirected graphs.


kind: o
name: isDirectSuccessor?
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger)->Boolean
params: cFiniteGraph(S)
comment:
\spad{isDirectSuccessor?(s,{} a,{} b)} is \spad{true} if \spad{'b'} is a direct successor of 'a' that is,{} if there is a direct arrow from 'a' to \spad{'b'}


kind: o
name: isExpt
exposed: n
type: (%)->Union(Record(val:%,exponent:NonNegativeInteger),failed)
params: dPattern(R)
comment:
\spad{isExpt(p)} returns \spad{[q,{} n]} if \spad{n > 0} and \spad{p = q ^ n},{} and failed otherwise.


kind: o
name: isExpt
exposed: x
type: (%)->Union(Record(var:VarSet,exponent:NonNegativeInteger),failed)
params: cPolynomialCategory(R,E,VarSet)
abbrev: has(R,SemiRing)
comment:
\spad{isExpt(p)} returns \spad{[x,{} n]} if polynomial \spad{p} has the form \spad{x^n} and \spad{n > 0}.


kind: o
name: isExpt
exposed: x
type: (%,BasicOperator)->Union(Record(var:K,exponent:Integer),failed)
params: cFunctionSpace2(R,K)
abbrev: has(R,Ring)
comment:
\spad{isExpt(p,{} op)} returns \spad{[x,{} n]} if \spad{p = x^n} and \spad{n ~= 0} and \spad{x = op(a)}.


kind: o
name: isExpt
exposed: x
type: (%,Symbol)->Union(Record(var:K,exponent:Integer),failed)
params: cFunctionSpace2(R,K)
abbrev: has(R,Ring)
comment:
\spad{isExpt(p,{} f)} returns \spad{[x,{} n]} if \spad{p = x^n} and \spad{n ~= 0} and \spad{x = f(a)}.


kind: o
name: isFunctional?
exposed: n
type: (%)->Boolean
params: cFiniteGraph(S)
comment:
\spad{isFunctional?(s)} returns \spad{true} if \spad{s} is a functional graph,{} that is a directed graph in which each vertex has a single outgoing arrow.


kind: o
name: isGreaterThan?
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger)->Boolean
params: cFiniteGraph(S)
comment:
\spad{isGreaterThan?(s,{} a,{} b)} is \spad{true} if we can get from vertex 'a' to \spad{'b'} through a sequence of arrows but we can\spad{'t} go in the opposite direction from \spad{'b'} to 'a'


kind: o
name: isList
exposed: n
type: (%)->Union(List(%),failed)
params: dPattern(R)
comment:
\spad{isList(p)} returns \spad{[a1,{} ...,{} an]} if \spad{p = [a1,{} ...,{} an]},{} failed otherwise.


kind: o
name: isobaric?
exposed: x
type: (%)->Boolean
params: cDifferentialPolynomialCategory(R,S,V,E)
comment:
\spad{isobaric?(p)} returns \spad{true} if every differential monomial appearing in the differential polynomial \spad{p} has same weight,{} and returns \spad{false} otherwise.


kind: o
name: isOp
exposed: n
type: (%)->Union(Record(op:BasicOperator,arg:List(%)),failed)
params: dPattern(R)
comment:
\spad{isOp(p)} returns \spad{[op,{} [a1,{} ...,{} an]]} if \spad{p = op(a1,{} ...,{} an)},{} and failed otherwise.


kind: o
name: isOp
exposed: n
type: (%,BasicOperator)->Union(List(%),failed)
params: dPattern(R)
comment:
\spad{isOp(p,{} op)} returns \spad{[a1,{} ...,{} an]} if \spad{p = op(a1,{} ...,{} an)},{} and failed otherwise.


kind: o
name: isPlus
exposed: n
type: (F)->Union(List(F),failed)
params: pPolynomialCategoryQuotientFunctions(E,V,R,P,F)
comment:
\spad{isPlus(p)} returns [\spad{m1},{} ...,{} \spad{mn}] if \spad{p = m1 + ... + mn} and \spad{n > 1},{} failed otherwise.


kind: o
name: isPlus
exposed: n
type: (%)->Union(List(%),failed)
params: dPattern(R)
comment:
\spad{isPlus(p)} returns \spad{[a1,{} ...,{} an]} if \spad{n > 1} \indented{1}{and \spad{p = a1 + ... + an},{}} and failed otherwise.


kind: o
name: isPlus
exposed: x
type: (%)->Union(List(%),failed)
params: cPolynomialCategory(R,E,VarSet)
comment:
\spad{isPlus(p)} returns \spad{[m1,{} ...,{} mn]} if polynomial \spad{p = m1 + ... + mn} and \spad{n >= 2} and each \spad{mi} is a nonzero monomial.


kind: o
name: isPointLeaf?
exposed: n
type: (%)->Boolean
params: dSceneNamedPoints(PT)
comment:
\spad{isPointLeaf?(n)} returns \spad{true} if this is a \spad{pt} node,{} that is,{} if this node contains points


kind: o
name: isSubsetOf?
exposed: n
type: (%,%)->Boolean
params: dOrientedFacet
comment:
returns \spad{true} if face 'a' is contained in face \spad{'b'}. \spad{true} subset only : returns \spad{false} if a=b


kind: o
name: is_symbol?
exposed: n
type: (OutputForm,Symbol)->Boolean
params: pOutputFormTools
comment:
\spad{is_symbol?(f,{} s)} returns \spad{true} if form is symbol \spad{s},{} otherwise returns \spad{false}


kind: o
name: isTimes
exposed: n
type: (F)->Union(List(F),failed)
params: pPolynomialCategoryQuotientFunctions(E,V,R,P,F)
comment:
\spad{isTimes(p)} returns \spad{[a1,{} ...,{} an]} if \spad{p = a1 ... an} and \spad{n > 1},{} failed otherwise.


kind: o
name: isTimes
exposed: n
type: (%)->Union(List(%),failed)
params: dPattern(R)
comment:
\spad{isTimes(p)} returns \spad{[a1,{} ...,{} an]} if \spad{n > 1} and \spad{p = a1 * ... * an},{} and failed otherwise.


kind: o
name: isTimes
exposed: x
type: (%)->Union(List(%),failed)
params: cPolynomialCategory(R,E,VarSet)
abbrev: has(R,SemiRing)
comment:
\spad{isTimes(p)} returns \spad{[a1,{} ...,{} an]} if polynomial \spad{p = a1 ... an} and \spad{n >= 2},{} and,{} for each \spad{i},{} \spad{ai} is either a nontrivial constant in \spad{R} or else of the form \spad{x^e},{} where \spad{e > 0} is an integer and \spad{x} is a member of VarSet.


kind: o
name: iteratedInitials
exposed: x
type: (%)->List(%)
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{iteratedInitials(p)} returns \spad{[]} if \spad{p} belongs to \spad{R},{} otherwise returns the list of the iterated initials of \spad{p}.


kind: o
name: jacobi2poly
exposed: n
type: (Stream(R),Stream(R))->Stream(SparseUnivariatePolynomial(R))
params: pMomentPackage(R)
comment:
\spad{jacobi2poly(aa,{} bb)} returns the stream of orthogonal polynomials corresponding to the Jacobi parameters \spad{a_n} and \spad{b_n}.


kind: o
name: jacobi
exposed: x
type: (Integer,Integer)->Integer
params: pIntegerNumberTheoryFunctions
comment:
\spad{jacobi(a,{} b)} returns the Jacobi symbol \spad{J(a/b)}. When \spad{b} is odd,{} \spad{J(a/b) = product(L(a/p) for p in factor b )}. Note: by convention,{} 0 is returned if \spad{gcd(a,{} b) ~= 1}. Iterative \spad{O(log(b)^2)} version coded by Michael Monagan June 1987.


kind: o
name: jacobian
exposed: n
type: (FLAF,FLAS)->Matrix(F)
params: pMultiVariableCalculusFunctions(S,F,FLAF,FLAS)
comment:
\spad{jacobian(vf,{} xlist)} computes the jacobian,{} the matrix of first partial derivatives,{} of the vector field \spad{vf},{} \spad{vf} a vector function of the variables listed in xlist.


kind: o
name: jacobiCn
exposed: n
type: (F,F)->F
params: pFunctionalSpecialFunction(R,F)
comment:
\spad{jacobiCn(z,{} m)} is the Jacobi elliptic \spad{cn} function,{} defined by \spad{jacobiCn(z,{} m)^2 + jacobiSn(z,{} m)^2 = 1} and \spad{jacobiCn(0,{} m) = 1}.


kind: o
name: jacobiCn
exposed: n
type: (UTS,Coef)->UTS
params: pEllipticFunctionsUnivariateTaylorSeries(Coef,UTS)
comment:
\spad{jacobiCn(z,{} m)} expands the elliptic function \spad{cn} as a Taylor \indented{1}{series in \spad{z}.}


kind: o
name: jacobiDn
exposed: n
type: (F,F)->F
params: pFunctionalSpecialFunction(R,F)
comment:
\spad{jacobiDn(z,{} m)} is the Jacobi elliptic \spad{dn} function,{} defined by \spad{jacobiDn(z,{} m)^2 + m*jacobiSn(z,{} m)^2 = 1} and \spad{jacobiDn(0,{} m) = 1}.


kind: o
name: jacobiDn
exposed: n
type: (UTS,Coef)->UTS
params: pEllipticFunctionsUnivariateTaylorSeries(Coef,UTS)
comment:
\spad{jacobiDn(z,{} m)} expands the elliptic function \spad{dn} as a Taylor \indented{1}{series in \spad{z}.}


kind: o
name: jacobiIdentity?
exposed: n
type: ()->Boolean
params: xFiniteRankNonAssociativeAlgebra&(S,R)
comment:
\spad{jacobiIdentity?()} tests if \spad{(a*b)*c + (b*c)*a + (c*a)*b = 0} for all \spad{a},{} \spad{b},{} \spad{c} in the algebra. For example,{} this holds for crossed products of 3-dimensional vectors.


kind: o
name: jacobiMatrix
exposed: n
type: (List(%),List(List(JB)))->SparseEchelonMatrix(JB,%)
params: cJetBundleFunctionCategory(JB)
comment:
\spad{jacobiMatrix(sys,{} jvars)} constructs the Jacobi matrix of the family \spad{sys} of functions. \spad{jvars} contains for each function the effectively occurring jet variables. The columns of the matrix are ordered.


kind: o
name: jacobiParameters
exposed: n
type: (%)->Record(an:Stream(Fraction(R)),bn:Stream(Fraction(R)))
params: cDistributionCategory(R)
abbrev: AND(has(R,IntegralDomain),not(has(R,Field)))
comment:
\spad{jacobiParameters(x)} returns the pair of streams of Jacobi parameters of the distribution \spad{x}.


kind: o
name: jacobiPathArray
exposed: n
type: (Stream(R),Stream(R))->Stream(List(R))
params: pPathArrayPackage(R)
comment:
\spad{jacobiPathArray([b0,{} b1,{} ...],{} [c1,{} c2,{} ...])} computes Flajolet\spad{'s} Motzkin path array from the sequences [1,{} 1,{} ...],{} \spad{bi},{} \spad{ci}.


kind: o
name: jacobiSn
exposed: n
type: (F,F)->F
params: pFunctionalSpecialFunction(R,F)
comment:
\spad{jacobiSn(z,{} m)} is the Jacobi elliptic \spad{sn} function,{} defined by the formula \spad{jacobiSn(ellipticF(z,{} m),{} m) = z}.


kind: o
name: jacobiSn
exposed: n
type: (UTS,Coef)->UTS
params: pEllipticFunctionsUnivariateTaylorSeries(Coef,UTS)
comment:
\spad{jacobiSn(z,{} m)} expands the elliptic function \spad{sn} as a Taylor \indented{1}{series in \spad{z}.}


kind: o
name: jacobiZeta
exposed: n
type: (F,F)->F
params: pFunctionalSpecialFunction(R,F)
comment:
\spad{jacobiZeta(z,{} m)} is the Jacobi elliptic zeta function,{} defined by \spad{D(jacobiZeta(z,{} m),{} z) = jacobiDn(z,{} m)^2 - ellipticE(m)/ellipticK(m)} and \spad{jacobiZeta(0,{} m) = 0}.


kind: o
name: janko2
exposed: x
type: (List(Integer))->PermutationGroup(Integer)
params: pPermutationGroupExamples
comment:
\spad{janko2(\spad{li})} constructs the janko group acting on the 100 integers given in the list {\em \spad{li}}. Note: duplicates in the list will be removed. Error: if {\em \spad{li}} has less or more than 100 different entries


kind: o
name: JContinuedFraction
exposed: x
params: pDistributionContinuedFractionPackage(R,z)
abbrev: AND(has(R,IntegralDomain),not(has(R,Field)))
comment: \spad{JContinuedFraction(d,{} z)} returns the Cauchy transform as a continued fraction at \spad{z}.
type:
(Distribution(R),UnivariatePolynomial(z,Fraction(R)))->ContinuedFraction(UnivariatePolynomial(z,Fraction(R)))


kind: o
name: jetVariables
exposed: n
type: (%)->List(JB)
params: cJetBundleFunctionCategory(JB)
comment:
\spad{jetVariables(f)} yields all jet variables effectively occurring in \spad{f} in an ordered list.


kind: o
name: join
exposed: n
type: (%,%)->%
params: dOrientedFacet
comment:
used by simplicialJoin. Returns join (union) of 'a' and \spad{'b'}. That is: returns a facet containing indexes in both 'a' and \spad{'b'}.


kind: o
name: join
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger)->NonNegativeInteger
params: cDcpo(S)
comment:
returns the join of 'a' and \spad{'b'} In this version of join nodes are represented as index values. Not every poset will have a join but DCPO will.


kind: o
name: joinIfCan
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger)->Union(NonNegativeInteger,failed)
params: cPoset(S)
comment:
\spad{joinIfCan(s,{} a,{} b)} returns the join of 'a' and \spad{'b'} In this version of join nodes are represented as index values. In the general case,{} not every poset will have a join in which case failed will be returned as an error indication.


kind: o
name: jordanAdmissible?
exposed: n
type: ()->Boolean
params: xFiniteRankNonAssociativeAlgebra&(S,R)
comment:
\spad{jordanAdmissible?()} tests if 2 is invertible in the coefficient domain and the multiplication defined by \spad{(1/2)(a*b+b*a)} determines a Jordan algebra,{} \spadignore{i.e.} satisfies the Jordan identity. The property of \spadtype{CommutativeStar} follows from by definition.


kind: o
name: jordanAlgebra?
exposed: n
type: ()->Boolean
params: xFiniteRankNonAssociativeAlgebra&(S,R)
comment:
\spad{jordanAlgebra?()} tests if the algebra is commutative,{} characteristic is not 2,{} and \spad{(a*b)*a^2 - a*(b*a^2) = 0} for all \spad{a},{} \spad{b},{} \spad{c} in the algebra (Jordan identity). Example: for every associative algebra \spad{(A,{} +,{} @)} we can construct a Jordan algebra \spad{(A,{} +,{} *)},{} where \spad{a*b := (a@b+b@a)/2}.


kind: o
name: karatsuba
exposed: x
type: (U,U,NonNegativeInteger,NonNegativeInteger)->U
params: pUnivariatePolynomialMultiplicationPackage(R,U)
comment:
\spad{karatsuba(a,{} b,{} l,{} k)} returns \spad{a*b} by applying Karatsuba\spad{'s} trick provided that both \spad{a} and \spad{b} have at least \spad{l} terms and \spad{k > 0} holds and by calling \spad{noKaratsuba} otherwise. The other multiplications are performed by recursive calls with the same third argument and \spad{k-1} as fourth argument.


kind: o
name: karatsubaOnce
exposed: x
type: (U,U)->U
params: pUnivariatePolynomialMultiplicationPackage(R,U)
comment:
\spad{karatsuba(a,{} b)} returns \spad{a*b} by applying Karatsuba\spad{'s} trick once. The other multiplications are performed by calling \spad{*} from \spad{U}.


kind: o
name: kelvinBei
exposed: n
type: (F,F)->F
params: pFunctionalSpecialFunction(R,F)
comment:
\spad{kelvinBei(v,{} z)} is the Kelvin bei function defined by equality. \spad{kelvinBei(v,{} z) = imag(besselJ(v,{} exp(3*\%pi*\%i/4)*z))}. for \spad{z} and \spad{v} real.


kind: o
name: kelvinBei
exposed: x
type: (%,%)->%
params: cSpecialFunctionCategory
comment:
\spad{kelvinBei(v,{} z)} is the Kelvin bei function defined by equality \spad{kelvinBei(v,{} z) = imag(besselJ(v,{} exp(3*\%pi*\%i/4)*z))} for \spad{z} and \spad{v} real.


kind: o
name: kelvinBer
exposed: n
type: (F,F)->F
params: pFunctionalSpecialFunction(R,F)
comment:
\spad{kelvinBer(v,{} z)} is the Kelvin ber function defined by equality \spad{kelvinBer(v,{} z) = real(besselJ(v,{} exp(3*\%pi*\%i/4)*z))} for \spad{z} and \spad{v} real.


kind: o
name: kelvinKei
exposed: n
type: (F,F)->F
params: pFunctionalSpecialFunction(R,F)
comment:
\spad{kelvinKei(v,{} z)} is the Kelvin kei function defined by equality \spad{kelvinKei(v,{} z) = imag(exp(-v*\%pi*\%i/2)*besselK(v,{} exp(\%pi*\%i/4)*z))} for \spad{z} and \spad{v} real.


kind: o
name: kelvinKer
exposed: n
type: (F,F)->F
params: pFunctionalSpecialFunction(R,F)
comment:
\spad{kelvinKer(v,{} z)} is the Kelvin kei function defined by equality \spad{kelvinKer(v,{} z) = real(exp(-v*\%pi*\%i/2)*besselK(v,{} exp(\%pi*\%i/4)*z))} for \spad{z} and \spad{v} real.


kind: o
name: kernel
exposed: n
type: (BasicOperator,List(S),NonNegativeInteger)->%
params: cKernelCategory(S)
comment:
\spad{kernel(op,{} [a1,{} ...,{} an],{} m)} returns the kernel \spad{op(a1,{} ...,{} an)} of nesting level \spad{m}. Error: if \spad{op} is \spad{k}-ary for some \spad{k} not equal to \spad{n}.


kind: o
name: kernels
exposed: x
type: (%)->List(K)
params: cExpressionSpace2(K)
comment:
\spad{kernels(f)} returns the list of all the top-level kernels appearing in \spad{f},{} but not the ones appearing in the arguments of the top-level kernels.


kind: o
name: kernels
exposed: x
type: (List(%))->List(K)
params: cExpressionSpace2(K)
comment:
\spad{kernels([f1,{}...,{}fn])} returns the list of all the top-level kernels appearing in \spad{f1},{} ...,{} \spad{fn} but not the ones appearing in the arguments of the top-level kernels.


kind: o
name: key
exposed: n
type: (%)->Integer
params: dGraphImage
comment:
\spad{key(\spad{gi})} returns the process ID of the given graph,{} \spad{\spad{gi}},{} of the domain \spadtype{GraphImage}.


kind: o
name: key
exposed: n
type: (%)->Integer
params: dTwoDimensionalViewport
comment:
\spad{key(v)} returns the process ID number of the given two-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{TwoDimensionalViewport}.


kind: o
name: key
exposed: x
type: (%)->Integer
params: dThreeDimensionalViewport
comment:
\spad{key(v)} returns the process ID number of the given three-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{ThreeDimensionalViewport}.


kind: o
name: kgraph
exposed: n
type: (List(S),String)->%
params: cFiniteGraph(S)
comment:
\spad{kgraph(objs,{} arrowName)} constructs a graph with vertices (from \spad{objs}) and fully connected arrows,{} that is,{} each object has an arrow to every other object except itself. arrowName is a prefix for all arrow names,{} this will be followed by a number starting at 1 and incremented for each arrow


kind: o
name: knownHandler?
exposed: n
type: (%,Integer,String)->Boolean
params: dOperatorHandlers(HANDLER)
comment:
\spad{knownHandler?(x,{} n,{} op)} checks whether a handler for operator \spad{op} is known. The number \spad{n} denotes the number of arguments that the operator can take. It is OK if both \spad{knownOperator?(m,{} op)} and \spad{knownOperator?(n,{} op)} return \spad{true} for different \spad{m} and \spad{n}.


kind: o
name: kovacic
exposed: n
type: (Fraction(UP),Fraction(UP),Fraction(UP))->Union(SparseUnivariatePolynomial(Fraction(UP)),failed)
params: pKovacic(F,UP)
comment:
\spad{kovacic(a_0,{}a_1,{}a_2)} returns either failed or \spad{P}(\spad{u}) such that \spad{\$e^{\int(-a_1/2a_2)} e^{\int u}\$} is a solution of \indented{5}{\spad{a_2 y'' + a_1 y' + a0 y = 0}} whenever \spad{u} is a solution of \spad{P u = 0}. The equation must be already irreducible over the rational functions.


kind: o
name: kovacic
exposed: n
params: pKovacic(F,UP)
type:
(Fraction(UP),Fraction(UP),Fraction(UP),(UP)->Factored(UP))->Union(SparseUnivariatePolynomial(Fraction(UP)),failed)

comment:
\spad{kovacic(a_0,{}a_1,{}a_2,{}ezfactor)} returns either failed or \spad{P}(\spad{u}) such that \spad{\$e^{\int(-a_1/2a_2)} e^{\int u}\$} is a solution of \indented{5}{\spad{\$a_2 y'' + a_1 y' + a0 y = 0\$}} whenever \spad{u} is a solution of \spad{P u = 0}. The equation must be already irreducible over the rational functions. Argument \spad{ezfactor} is a factorisation in \spad{UP},{} not necessarily into irreducibles.


kind: o
name: kroneckerDelta
exposed: x
type: ()->%
params: dCartesianTensor(minix,dim,R)
comment:
\spad{kroneckerDelta()} is the rank 2 tensor defined by \indented{3}{\spad{kroneckerDelta()(i,{} j)}} \indented{6}{\spad{= 1\space{2}if i = j}} \indented{6}{\spad{= 0 if\space{2}i \~= j}}


kind: o
name: kronecker_prod1
exposed: n
params: xMatrixCategory&(S,R,Row,Col)
type:
(S,Integer,List(List(NonNegativeInteger)),List(S),NonNegativeInteger,NonNegativeInteger,Union(R,one))->Void


kind: o
name: kronecker_prod1
exposed: x
params: cMatrixCategory(R,Row,Col)
comment: Should be local but conditional.
type:
(%,Integer,List(List(NonNegativeInteger)),List(%),NonNegativeInteger,NonNegativeInteger,Union(R,one))->Void


kind: o
name: kroneckerProduct
exposed: x
type: (List(%))->%
params: cMatrixCategory(R,Row,Col)
abbrev: has(R,SemiRng)
comment:
\spad{kroneckerProduct([a1,{} a2,{} ...,{} an])} calculates the Kronecker product of the matrices \spad{a1},{} \spad{a2},{} ...,{} an. This corresponds to tensor product of corresponding operators.


kind: o
name: kroneckerProduct
exposed: x
type: (%,%)->%
params: cMatrixCategory(R,Row,Col)
abbrev: has(R,SemiRng)
comment:
\spad{kroneckerProduct(a,{} b)} calculates the Kronecker product of the matrices a and \spad{b}. This corresponds to tensor product of corresponding operators.


kind: o
name: kroneckerSum
exposed: x
type: (List(%))->%
params: cMatrixCategory(R,Row,Col)
comment:
\spad{kroneckerSum([a1,{} a2,{} ...,{} an])} calculates the Kronecker sum of the matrices \spad{a1},{} \spad{a2},{} ...,{} an.


kind: o
name: ksec
exposed: n
type: (Kernel(F),List(Kernel(F)),Symbol)->Kernel(F)
params: pIntegrationTools(R,F)
comment:
\spad{ksec(k,{} [k1,{} ...,{} kn],{} x)} returns the second top-level \spad{ki} after \spad{k} involving \spad{x}.


kind: o
name: lagrange
exposed: n
type: (%)->%
params: dUnivariateTaylorSeries(Coef,var,cen)
comment:
\spad{lagrange(g(x))} produces the Taylor series for \spad{f(x)} \indented{1}{where \spad{f(x)} is implicitly defined as \spad{f(x) = x*g(f(x))}.}


kind: o
name: lagrange
exposed: n
type: (Stream(A))->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{lagrange(g)} produces the power series for \spad{f} where \spad{f} is implicitly defined as \spad{f(z) = z*g(f(z))}.


kind: o
name: laguerre
exposed: n
type: (Integer)->SparseUnivariatePolynomial(Integer)
params: pPolynomialNumberTheoryFunctions
comment:
\spad{laguerre(n)} returns the \spad{n}th Laguerre polynomial \spad{L[n](x)}. Note: Laguerre polynomials,{} denoted \spad{L[n](x)},{} are computed from the two term recurrence. The generating function is: \spad{exp(x*t/(t-1))/(1-t) = sum(L[n](x)*t^n/n!,{} n=0..infinity)}.


kind: o
name: laguerreL
exposed: x
type: (NonNegativeInteger,R)->R
params: pOrthogonalPolynomialFunctions(R)
comment:
\spad{laguerreL(n,{} x)} is the \spad{n}-th Laguerre polynomial,{} \spad{L[n](x)}. These are defined by \spad{exp(-t*x/(1-t))/(1-t) = sum(L[n](x)*t^n/n!,{} n = 0..)}.


kind: o
name: laguerreL
exposed: x
type: (NonNegativeInteger,NonNegativeInteger,R)->R
params: pOrthogonalPolynomialFunctions(R)
comment:
\spad{laguerreL(m,{} n,{} x)} is the associated Laguerre polynomial,{} \spad{L<m>[n](x)}. This is the \spad{m}-th derivative of \spad{L[n](x)}.


kind: o
name: lambda
exposed: n
type: (%,List(Symbol))->%
params: dInputForm
comment:
\spad{lambda(code,{} [x1,{} ...,{} xn])} returns the input form corresponding to \spad{(x1,{} ...,{} xn) +-> code} if \spad{n > 1},{} or to \spad{x1 +-> code} if \spad{n = 1}.


kind: o
name: lambert
exposed: n
type: (%)->%
params: dUnivariateTaylorSeries(Coef,var,cen)
comment:
\spad{lambert(f(x))} returns \spad{f(x) + f(x^2) + f(x^3) + ...}. \indented{1}{\spad{f(x)} should have zero constant coefficient.} \indented{1}{This function is used for computing infinite products.} \indented{1}{If \spad{f(x)} is a Taylor series with constant term 1,{} then} \indented{1}{\spad{product(n = 1..infinity,{} f(x^n)) = exp(lambert(log(f(x))))}.}


kind: o
name: lambert
exposed: n
type: (Stream(A))->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{lambert(st)} computes \spad{f(x) + f(x^2) + f(x^3) + ...} if \spad{st} is a stream representing \spad{f(x)}. This function is used for computing infinite products. If \spad{f(x)} is a power series with constant coefficient 1 then \spad{prod(f(x^n),{} n = 1..infinity) = exp(lambert(log(f(x))))}.


kind: o
name: lambertW
exposed: x
type: (%)->%
params: cSpecialFunctionCategory
comment:
\spad{lambertW(z)} = \spad{w} is the principal branch of the solution to the equation \spad{we^w = z}.


kind: o
name: lambintegrate
exposed: n
params: pTranscendentalIntegration(F,UP)
type:
(Fraction(UP),F,(F)->F,(UP)->UP,(F)->Union(Record(ratpart:F,coeff:F),failed),(F)->IntegrationResult(F))->Record(answer:IntegrationResult(Fraction(UP)),a0:IntegrationResult(F))

comment:
\spad{lambintegrate(f,{} dx,{} D1,{} D2,{} extint,{} int)} integrates \spad{f} in extension by LambertW function. \spad{dx} is derivative of the argument of LambertW,{} \spad{D1} is dervative on \spad{F},{} \spad{D2} is derivative on UP,{} \spad{extint} is extended integration function on \spad{F},{} int is integration function on \spad{F}.


kind: o
name: laplace
exposed: x
type: (F,Symbol,Symbol)->F
params: pLaplaceTransform(R,F)
comment:
\spad{laplace(f,{} t,{} s)} returns the Laplace transform of \spad{f(t)} using \spad{s} as the new variable. This is \spad{integral(exp(-s*t)*f(t),{} t = 0..\%plusInfinity)}. Returns the formal object \spad{laplace(f,{} t,{} s)} if it cannot compute the transform.


kind: o
name: laplacian
exposed: n
type: (F,FLAS)->F
params: pMultiVariableCalculusFunctions(S,F,FLAF,FLAS)
comment:
\spad{laplacian(v,{} xlist)} computes the laplacian of the scalar field \spad{v},{} \spad{v} a function of the variables listed in xlist.


kind: o
name: laplacianMatrix
exposed: n
type: (%)->Matrix(Integer)
params: cFiniteGraph(S)
comment:
\spad{laplacianMatrix(s)} returns matrix also known as Kirchhoff matrix or Admittance matrix where: entry [\spad{i},{} \spad{j}] = inDegree(\spad{vi}) if \spad{i} = \spad{j} (number of incoming links) \spad{-1} if \spad{i} not = \spad{j} and \spad{vi} is adjacent to \spad{vj} 0 otherwise Alternatively this is defined as \spad{D} - A,{} where \spad{D} is the diagonal degree matrix. It contains both adjacency information and degree information. There are other,{} similar matrices,{} that are also called Laplacian matrices of a graph.


kind: o
name: largest
exposed: n
type: (List(S))->S
params: pUserDefinedPartialOrdering(S)
abbrev: has(S,OrderedSet)
comment:
\spad{largest l} returns the largest element of \spad{l} where the partial ordering induced by setOrder is completed into a total one by the ordering on \spad{S}.


kind: o
name: largest
exposed: n
type: (List(S),(S,S)->Boolean)->S
params: pUserDefinedPartialOrdering(S)
comment:
\spad{largest(l,{} fn)} returns the largest element of \spad{l} where the partial ordering induced by setOrder is completed into a total one by \spad{fn}.


kind: o
name: last
exposed: x
type: (%)->S
params: cDoublyLinkedAggregate(S)
comment:
\spad{last(l)} returns the last element of a doubly-linked aggregate \spad{l}. Error: if \spad{l} is empty.


kind: o
name: last
exposed: x
type: (%)->S
params: cUnaryRecursiveAggregate(S)
comment:
\spad{last(u)} returns the last element of \spad{u}. Note: for lists,{} \spad{last(u) = u.(maxIndex u)}.


kind: o
name: last
exposed: x
type: (%)->Union(P,failed)
params: cTriangularSetCategory(R,E,V,P)
comment:
\spad{last(ts)} returns the polynomial of \spad{ts} with smallest main variable if \spad{ts} is not empty,{} otherwise returns \spad{failed}.


kind: o
name: last
exposed: x
type: (%,NonNegativeInteger)->%
params: cUnaryRecursiveAggregate(S)
comment:
\spad{last(u,{} n)} returns a copy of the last \spad{n} nodes of \spad{u}. Note: \spad{last(u,{} n)} is a list of \spad{n} elements.


kind: o
name: lastSubResultant
exposed: n
type: (%,%)->%
params: dNewSparseUnivariatePolynomial(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{lastSubResultant(a,{} b)} returns \spad{resultant(a,{} b)} if \spad{a} and \spad{b} has no non-trivial \spad{gcd} in \spad{R^(-1) P} otherwise the non-zero sub-resultant with smallest index.


kind: o
name: lastSubResultant
exposed: x
type: (%,%)->%
params: cRecursivePolynomialCategory(R,E,V)
abbrev: has(R,IntegralDomain)
comment:
\spad{lastSubResultant(a,{} b)} returns the last non-zero subresultant of \spad{a} and \spad{b} where \spad{a} and \spad{b} are assumed to have the same main variable \spad{v} and are viewed as univariate polynomials in \spad{v}.


kind: o
name: lastSubResultant
exposed: x
type: (P,P,%)->List(Record(val:P,tower:%))
params: cRegularTriangularSetCategory(R,E,V,P)
comment:
\spad{lastSubResultant(p1,{} p2,{} ts)} returns \spad{lpwt} such that \spad{lpwt.i.val} is a quasi-monic \spad{gcd} of \spad{p1} and \spad{p2} \spad{w}.\spad{r}.\spad{t}. \spad{lpwt.i.tower},{} for every \spad{i},{} and such that the list of the \spad{lpwt.i.tower} is a split of Kalkbrener of \spad{ts}. Moreover,{} if \spad{p1} and \spad{p2} do not have a non-trivial \spad{gcd} \spad{w}.\spad{r}.\spad{t}. \spad{lpwt.i.tower} then \spad{lpwt.i.val} is the resultant of these polynomials \spad{w}.\spad{r}.\spad{t}. \spad{lpwt.i.tower}. This assumes that \spad{p1} and \spad{p2} have the same maim variable and that this variable is greater that any variable occurring in \spad{ts}.


kind: o
name: lastSubResultantElseSplit
exposed: x
type: (P,P,%)->Union(P,List(%))
params: cRegularTriangularSetCategory(R,E,V,P)
comment:
\spad{lastSubResultantElseSplit(p1,{} p2,{} ts)} returns either \spad{g} a quasi-monic \spad{gcd} of \spad{p1} and \spad{p2} \spad{w}.\spad{r}.\spad{t}. the \spad{ts} or a split of Kalkbrener of \spad{ts}. This assumes that \spad{p1} and \spad{p2} have the same maim variable and that this variable is greater that any variable occurring in \spad{ts}.


kind: o
name: lastSubResultantEuclidean
exposed: n
type: (polR,polR)->Record(coef1:polR,coef2:polR,subResultant:polR)
params: pPseudoRemainderSequence(R,polR)
comment:
\spad{lastSubResultantEuclidean(P,{} Q)} computes the last non zero subresultant \spad{S} and carries out the equality \spad{coef1*P + coef2*Q = S}.


kind: o
name: laurent
exposed: x
type: (FE)->Any
params: pExpressionToUnivariatePowerSeries(R,FE)
comment:
\spad{laurent(f)} returns a Laurent expansion of the expression \spad{f}. Note: \spad{f} should have only one variable; the series will be expanded in powers of that variable.


kind: o
name: laurent
exposed: x
type: (%)->ULS
params: cUnivariatePuiseuxSeriesConstructorCategory(Coef,ULS)
comment:
\spad{laurent(f(x))} converts the Puiseux series \spad{f(x)} to a Laurent series if possible. Error: if this is not possible.


kind: o
name: laurent
exposed: x
type: (FE,Equation(FE))->Any
params: pExpressionToUnivariatePowerSeries(R,FE)
comment:
\spad{laurent(f,{} x = a)} expands the expression \spad{f} as a Laurent series in powers of \spad{(x - a)}.


kind: o
name: laurent
exposed: x
type: (FE,Integer)->Any
params: pExpressionToUnivariatePowerSeries(R,FE)
comment:
\spad{laurent(f,{} n)} returns a Laurent expansion of the expression \spad{f}. Note: \spad{f} should have only one variable; the series will be expanded in powers of that variable and terms will be computed up to order at least \spad{n}.


kind: o
name: laurent
exposed: x
type: (Integer,Stream(Coef))->%
params: cUnivariateLaurentSeriesCategory(Coef)
comment:
\spad{laurent(n,{} st)} returns \spad{xn * series st} where \spad{xn = monomial(1,{} n)} and \spad{series st} stands for the power series with coefficients given by the stream st.


kind: o
name: laurent
exposed: n
type: ((Integer)->FE,Equation(FE),UniversalSegment(Integer))->Any
params: pGenerateUnivariatePowerSeries2(FE)
comment:
\spad{laurent(n +-> a(n),{} x = a,{} n0..)} returns \spad{sum(n = n0..,{} a(n) * (x - a)^n)}; \spad{laurent(n +-> a(n),{} x = a,{} n0..n1)} returns \spad{sum(n = n0..n1,{} a(n) * (x - a)^n)}.


kind: o
name: laurent
exposed: x
type: (FE,Equation(FE),Integer)->Any
params: pExpressionToUnivariatePowerSeries(R,FE)
comment:
\spad{laurent(f,{} x = a,{} n)} expands the expression \spad{f} as a Laurent series in powers of \spad{(x - a)}; terms will be computed up to order at least \spad{n}.


kind: o
name: laurent
exposed: n
type: (FE,Symbol,Equation(FE),UniversalSegment(Integer))->Any
params: pGenerateUnivariatePowerSeries2(FE)
abbrev: AND(has(FE,Evalable(FE)),has(FE,RetractableTo(Integer)))
comment:
\spad{laurent(a(n),{} n,{} x=a,{} n0..)} returns \spad{sum(n = n0..,{} a(n) * (x - a)^n)}; \spad{laurent(a(n),{} n,{} x=a,{} n0..n1)} returns \spad{sum(n = n0..n1,{} a(n) * (x - a)^n)}.


kind: o
name: laurent
exposed: n
type: ((Integer)->R,Symbol,R,UniversalSegment(Integer))->Any
params: pGenerateUnivariatePowerSeries1(R)
comment:
\spad{laurent(n +-> a(n),{} x,{} a,{} n0..)} returns \spad{sum(n = n0..,{} a(n) * (x - a)^n)}; \spad{laurent(n +-> a(n),{} x,{} a,{} n0..n1)} returns \spad{sum(n = n0..n1,{} a(n) * (x - a)^n)}.


kind: o
name: laurentIfCan
exposed: x
type: (%)->Union(ULS,failed)
params: cUnivariatePuiseuxSeriesConstructorCategory(Coef,ULS)
comment:
\spad{laurentIfCan(f(x))} converts the Puiseux series \spad{f(x)} to a Laurent series if possible. If this is not possible,{} failed is returned.


kind: o
name: laurentRep
exposed: x
type: (%)->ULS
params: cUnivariatePuiseuxSeriesConstructorCategory(Coef,ULS)
comment:
\spad{laurentRep(f(x))} returns \spad{g(x)} where the Puiseux series \spad{f(x) = g(x^r)} is represented by \spad{[r,{} g(x)]}.


kind: o
name: LazardQuotient2
exposed: x
type: (%,%,%,NonNegativeInteger)->%
params: cRecursivePolynomialCategory(R,E,V)
abbrev: has(R,IntegralDomain)
comment:
\spad{LazardQuotient2(p,{} a,{} b,{} n)} returns \spad{(a^(n-1) * p) exquo b^(n-1)} assuming that this quotient does not fail.


kind: o
name: LazardQuotient
exposed: x
type: (%,%,NonNegativeInteger)->%
params: cRecursivePolynomialCategory(R,E,V)
abbrev: has(R,IntegralDomain)
comment:
\spad{LazardQuotient(a,{} b,{} n)} returns \spad{a^n exquo b^(n-1)} assuming that this quotient does not fail.


kind: o
name: lazy?
exposed: x
type: (%)->Boolean
params: cLazyStreamAggregate(S)
comment:
\spad{lazy?(s)} returns \spad{true} if the first node of the stream \spad{s} is a lazy evaluation mechanism which could produce an additional entry to \spad{s}.


kind: o
name: lazyEvaluate
exposed: x
type: (%)->%
params: cLazyStreamAggregate(S)
comment:
\spad{lazyEvaluate(s)} causes one lazy evaluation of stream \spad{s}. Caution: the first node must be a lazy evaluation mechanism (satisfies \spad{lazy?(s) = true}) as there is no error check. Note: a call to this function may or may not produce an explicit first entry


kind: o
name: lazyIntegrate
exposed: n
type: (Coef,()->Stream(Coef))->Stream(Coef)
params: pStreamExponentialSeriesOperations(Coef)
comment:
\spad{lazyIntegrate(c,{} f)} integrates with constant term \spad{c},{} this is simply the right shift


kind: o
name: lazyIrreducibleFactors
exposed: n
type: (List(P))->List(P)
params: pPolynomialSetUtilitiesPackage(R,E,V,P)
abbrev: AND(has(R,CharacteristicZero),has(R,PolynomialFactorizationExplicit))
comment:
\spad{lazyIrreducibleFactors(lp)} returns \spad{lf} such that if \spad{lp = [p1,{} ...,{} pn]} and \spad{lf = [f1,{} ...,{} fm]} then \spad{p1*p2*...*pn=0} means \spad{f1*f2*...*fm=0},{} and the \spad{\spad{fi}} are irreducible over \spad{R} and are pairwise distinct. The algorithm tries to avoid factorization into irreducible factors as far as possible and makes previously use of \spad{gcd} techniques over \spad{R}.


kind: o
name: lazyPquo
exposed: x
type: (%,%)->%
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{lazyPquo(a,{} b)} returns the polynomial \spad{q} such that \spad{lazyPseudoDivide(a,{} b)} returns \spad{[c,{} g,{} q,{} r]}.


kind: o
name: lazyPquo
exposed: x
type: (%,%,V)->%
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{lazyPquo(a,{} b,{} v)} returns the polynomial \spad{q} such that \spad{lazyPseudoDivide(a,{} b,{} v)} returns \spad{[c,{} g,{} q,{} r]}.


kind: o
name: lazyPrem
exposed: x
type: (%,%)->%
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{lazyPrem(a,{} b)} returns the polynomial \spad{r} reduced \spad{w}.\spad{r}.\spad{t}. \spad{b} and such that \spad{b} divides \spad{init(b)^e a - r} where \spad{e} is the number of steps of this pseudo-division.


kind: o
name: lazyPrem
exposed: x
type: (%,%,V)->%
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{lazyPrem(a,{} b,{} v)} returns the polynomial \spad{r} reduced \spad{w}.\spad{r}.\spad{t}. \spad{b} viewed as univariate polynomials in the variable \spad{v} such that \spad{b} divides \spad{init(b)^e a - r} where \spad{e} is the number of steps of this pseudo-division.


kind: o
name: lazyPremWithDefault
exposed: x
type: (%,%)->Record(coef:%,gap:NonNegativeInteger,remainder:%)
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{lazyPremWithDefault(a,{} b)} returns \spad{[c,{} g,{} r]} such that \spad{r = lazyPrem(a,{} b)} and \spad{(c^g)*r = prem(a,{} b)}.


kind: o
name: lazyPremWithDefault
exposed: x
type: (%,%,V)->Record(coef:%,gap:NonNegativeInteger,remainder:%)
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{lazyPremWithDefault(a,{} b,{} v)} returns \spad{[c,{} g,{} r]} such that \spad{r = lazyPrem(a,{} b,{} v)} and \spad{(c^g)*r = prem(a,{} b,{} v)}.


kind: o
name: lazyPseudoDivide
exposed: n
type: (%,%)->Record(coef:R,gap:NonNegativeInteger,quotient:%,remainder:%)
params: dNewSparseUnivariatePolynomial(R)
comment:
\spad{lazyPseudoDivide(a,{} b)} returns \spad{[c,{} g,{} q,{} r]} such that \spad{c^n * a = q*b +r} and \spad{lazyResidueClass(a,{} b)} returns \spad{[r,{} c,{} n]} where \spad{n + g = max(0,{} degree(b) - degree(a) + 1)}.


kind: o
name: lazyPseudoDivide
exposed: x
type: (%,%)->Record(coef:%,gap:NonNegativeInteger,quotient:%,remainder:%)
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{lazyPseudoDivide(a,{} b)} returns \spad{[c,{} g,{} q,{} r]} such that \spad{[c,{} g,{} r] = lazyPremWithDefault(a,{} b)} and \spad{q} is the pseudo-quotient computed in this lazy pseudo-division.


kind: o
name: lazyPseudoDivide
exposed: x
type: (%,%,V)->Record(coef:%,gap:NonNegativeInteger,quotient:%,remainder:%)
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{lazyPseudoDivide(a,{} b,{} v)} returns \spad{[c,{} g,{} q,{} r]} such that \spad{r = lazyPrem(a,{} b,{} v)},{} \spad{(c^g)*r = prem(a,{} b,{} v)} and \spad{q} is the pseudo-quotient computed in this lazy pseudo-division.


kind: o
name: lazyPseudoQuotient
exposed: n
type: (%,%)->%
params: dNewSparseUnivariatePolynomial(R)
comment:
\spad{lazyPseudoQuotient(a,{} b)} returns \spad{q} if \spad{lazyPseudoDivide(a,{} b)} returns \spad{[c,{} g,{} q,{} r]}


kind: o
name: lazyPseudoRemainder
exposed: n
type: (%,%)->%
params: dNewSparseUnivariatePolynomial(R)
comment:
\spad{lazyPseudoRemainder(a,{} b)} returns \spad{r} if \spad{lazyResidueClass(a,{} b)} returns \spad{[r,{} c,{} n]}. This lazy pseudo-remainder is computed by means of the \spadopFrom{fmecg}{NewSparseUnivariatePolynomial} operation.


kind: o
name: lazyResidueClass
exposed: n
type: (%,%)->Record(polnum:%,polden:R,power:NonNegativeInteger)
params: dNewSparseUnivariatePolynomial(R)
comment:
\spad{lazyResidueClass(a,{} b)} returns \spad{[r,{} c,{} n]} such that \spad{r} is reduced \spad{w}.\spad{r}.\spad{t}. \spad{b} and \spad{b} divides \spad{c^n * a - r} where \spad{c} is \spad{leadingCoefficient(b)} and \spad{n} is as small as possible with the previous properties.


kind: o
name: lazyResidueClass
exposed: x
type: (%,%)->Record(polnum:%,polden:%,power:NonNegativeInteger)
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{lazyResidueClass(a,{} b)} returns \spad{[p,{} q,{} n]} where \spad{p / q^n} represents the residue class of \spad{a} modulo \spad{b} and \spad{p} is reduced \spad{w}.\spad{r}.\spad{t}. \spad{b} and \spad{q} is \spad{init(b)}.


kind: o
name: lazyVariations
exposed: x
type: (List(TheField),Integer,Integer)->NonNegativeInteger
params: pRealPolynomialUtilitiesPackage(TheField,ThePols)
abbrev: has(TheField,OrderedRing)
comment:
\spad{lazyVariations(l,{} s1,{} sn)} is the number of sign variations in the list of non null numbers [s1::l]\spad{@sn},{}


kind: o
name: lcm
exposed: n
type: (PrimitiveArray(U32Vector),Integer,Integer,Integer)->U32Vector
params: pU32VectorPolynomialOperations
comment:
\spad{lcm(a,{} lo,{} \spad{hi},{} p)} computes \spad{lcm} of elements a(\spad{lo}),{} a(\spad{lo+1}),{} ...,{} a(\spad{hi}).


kind: o
name: lcmCoef
exposed: n
type: (%,%)->Record(llcm_res:%,coeff1:%,coeff2:%)
params: cLeftOreRing
comment:
\spad{lcmCoef(c1,{} c2)} computes (llcm_res,{} \spad{coeff1},{} \spad{coeff2}) such that llcm_res is least left common multiple of \spad{c1} and \spad{c2} and llcm_res = \spad{coeff1*c1} = \spad{coeff2*c2}


kind: o
name: lcx0
exposed: n
params: pPrimGCD
type:
(SparseMultivariatePolynomial(Integer,Symbol),List(Symbol))->Record(lcx0lc:SparseMultivariatePolynomial(Integer,Symbol),lcx0m:SparseMultivariatePolynomial(Integer,Symbol))

comment:
\spad{lcx0(x,{} lv)} computes leading coefficient of \spad{x} and corresponding product of variables (monomial with coefficient 1) with respect to variables in \spad{lv} Variables in \spad{lv} must be decreasing and bigger than all other variables of \spad{x}.


kind: o
name: lcz
exposed: n
params: pPrimGCD
type:
(SparseMultivariatePolynomial(Integer,Symbol),Symbol)->Record(lczlc:SparseMultivariatePolynomial(Integer,Symbol),k:Integer)

comment:
\spad{lcz(x,{} z)} computes leading coefficient and degree of \spad{x} with respect to variable \spad{z}.


kind: o
name: ldegree
exposed: n
type: (PT,Symbol)->NonNegativeInteger
params: cModularEvaluationCategory(PT,MP)
comment:
\spad{ldegree(p,{} v)} computes degree of \spad{p} with respect to \spad{v}. \spad{v} must be one of auxiliary variables and must be lexicographically first variable which appears in \spad{p}. Moreover,{} \spad{p} must be a polynomial in \spad{v} (not a rational function).


kind: o
name: ldivide
exposed: n
params: pXPolynomialFactor(vl,F)
type:
(XDistributedPolynomial(vl,F),XDistributedPolynomial(vl,F))->Record(quotient:XDistributedPolynomial(vl,F),remainder:XDistributedPolynomial(vl,F))

comment:
\spad{ldivide(a,{} b)} returns [\spad{c},{} \spad{r}] such that a = \spad{b*c} + \spad{r},{} \spad{r} is is of minimal possible degree and homogeneous part of of \spad{r} of maximal degree contains no terms divisible from left by leading term of \spad{b}.


kind: o
name: le
exposed: n
type: (%,S,S)->Boolean
params: cPreorder(S)
comment:
\spad{le(s,{} x,{} y)} returns \spad{true} if and only if \spad{x} is less than or equal to \spad{y}. Note: at first glance we would like to use '<='. But le needs 3 arguments while '<=' has only 2.


kind: o
name: leader
exposed: x
type: (%)->V
params: cDifferentialPolynomialCategory(R,S,V,E)
comment:
\spad{leader(p)} returns the derivative of the highest rank appearing in the differential polynomial \spad{p} Note: an error occurs if \spad{p} is in the ground ring.


kind: o
name: leadingCoefficient
exposed: n
type: (%)->A
params: cIndexedProductCategory(A,S)
abbrev: has(S,Comparable)
comment:
\spad{leadingCoefficient(z)} returns the coefficient of the leading (with respect to the ordering on the indexing set) monomial of \spad{z}. Error: if \spad{z} has no support.


kind: o
name: leadingCoefficient
exposed: x
type: (%,V)->%
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{leadingCoefficient(p,{} v)} returns the leading coefficient of \spad{p},{} where \spad{p} is viewed as A univariate polynomial in \spad{v}.


kind: o
name: leadingCoefficientRicDE
exposed: n
type: (L)->List(Record(deg:NonNegativeInteger,eq:UP))
params: pPrimitiveRatRicDE(F,UP,L,LQ)
comment:
\spad{leadingCoefficientRicDE(op)} returns \spad{[[m1,{} p1],{} [m2,{} p2],{} ... ,{} [mk,{} pk]]} such that the polynomial part of any rational solution of the associated Riccati equation of \spad{op y = 0} must have degree \spad{mj} for some \spad{j},{} and its leading coefficient is then a zero of \spad{pj}. In addition,{} \spad{m1>m2> ... >mk}.


kind: o
name: leadingDer
exposed: n
type: (%)->JB
params: cJetBundleFunctionCategory(JB)
comment:
\spad{leadingDer(fun)} yields the leading derivative of \spad{fun}. If \spad{fun} contains no derivatives \spad{1} is returned.


kind: o
name: leadingIdeal
exposed: x
type: (%)->%
params: dPolynomialIdeal(F,Expon,VarSet,DPoly)
comment:
\spad{leadingIdeal(I)} is the ideal generated by the leading terms of the elements of the ideal \spad{I}.


kind: o
name: leadingMonomial
exposed: n
type: (%)->%
params: cIndexedProductCategory(A,S)
abbrev: has(S,Comparable)
comment:
\spad{leadingMonomial(x)} returns the monomial supported by the first element from \spad{S}. Error: if \spad{x} has no support.


kind: o
name: leadingSupport
exposed: n
type: (%)->S
params: cIndexedProductCategory(A,S)
abbrev: has(S,Comparable)
comment:
\spad{leadingSupport(z)} returns the index of leading (with respect to the ordering on the indexing set) monomial of \spad{z}. Error: if \spad{z} has no support.


kind: o
name: leadingTerm
exposed: n
type: (%)->Record(k:S,c:A)
params: cIndexedProductCategory(A,S)
abbrev: has(S,Comparable)
comment:
\spad{leadingTerm(x)} returns the leading (with respect to the ordering on the indexing set) term of \spad{z}. Error: if \spad{z} has no support.


kind: o
name: leastAffineMultiple
exposed: n
type: (SparseUnivariatePolynomial(GF))->SparseUnivariatePolynomial(GF)
params: pFiniteFieldPolynomialPackage(GF)
comment:
\spad{leastAffineMultiple(f)} computes the least affine polynomial which is divisible by the polynomial \spad{f} over the finite field {\em GF},{} \spadignore{i.e.} a polynomial whose exponents are 0 or a power of \spad{q},{} the size of {\em GF}.


kind: o
name: leastMonomial
exposed: x
type: (%)->%
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{leastMonomial(p)} returns an error if \spad{p} is \spad{O},{} otherwise,{} if \spad{p} belongs to \spad{R} returns \spad{1},{} otherwise,{} the monomial of \spad{p} with lowest degree,{} where \spad{p} is viewed as a univariate polynomial in its main variable.


kind: o
name: leastPower
exposed: n
type: (NonNegativeInteger,NonNegativeInteger)->NonNegativeInteger
params: pIntegralBasisTools(R,UP,F)
comment:
\spad{leastPower(p,{} n)} returns \spad{e},{} where \spad{e} is the smallest integer such that \spad{p ^e >= n}


kind: o
name: left
exposed: n
type: (%)->%
params: dFreeMagma(VarSet)
comment:
\spad{left(x)} returns left subtree of \spad{x} or error if \spadopFrom{retractable?}{FreeMagma}(\spad{x}) is \spad{true}.


kind: o
name: left
exposed: n
type: (%)->%
params: dLyndonWord(VarSet)
comment:
\spad{left(x)} returns left subtree of \spad{x} or error if \spadopFrom{retractable?}{LyndonWord}(\spad{x}) is \spad{true}.


kind: o
name: leftAlternative?
exposed: n
type: ()->Boolean
params: xFiniteRankNonAssociativeAlgebra&(S,R)
comment:
\spad{leftAlternative?()} tests if \spad{2*associator(a,{} a,{} b) = 0} for all \spad{a},{} \spad{b} in the algebra. Note: we only can test this; in general we don\spad{'t} know whether \spad{2*a=0} implies \spad{a=0}.


kind: o
name: leftCharacteristicPolynomial
exposed: x
type: (%)->SparseUnivariatePolynomial(R)
params: cFiniteRankNonAssociativeAlgebra(R)
comment:
\spad{leftCharacteristicPolynomial(a)} returns the characteristic polynomial of the left regular representation of \spad{a} with respect to any basis.


kind: o
name: leftDiscriminant
exposed: n
type: ()->R
params: xFramedNonAssociativeAlgebra&(S,R)
comment:
\spad{leftDiscriminant()} returns the determinant of the \spad{n}-by-\spad{n} matrix whose element at the \spad{i}\spad{-}th row and \spad{j}\spad{-}th column is given by the left trace of the product \spad{vi*vj},{} where \spad{v1},{} ...,{} \spad{vn} are the elements of the fixed \spad{R}-module basis. Note: the same as \spad{determinant(leftTraceMatrix())}.


kind: o
name: leftDiscriminant
exposed: x
type: (Vector(%))->R
params: cFiniteRankNonAssociativeAlgebra(R)
comment:
\spad{leftDiscriminant([v1,{} ...,{} vn])} returns the determinant of the \spad{n}-by-\spad{n} matrix whose element at the \spad{i}\spad{-}th row and \spad{j}\spad{-}th column is given by the left trace of the product \spad{vi*vj}. Note: the same as \spad{determinant(leftTraceMatrix([v1,{} ...,{} vn]))}.


kind: o
name: leftDivide
exposed: x
type: (%,%)->Record(quotient:%,remainder:%)
params: cUnivariateSkewPolynomialCategory(R)
abbrev: has(R,Field)
comment:
\spad{leftDivide(a,{} b)} returns the pair \spad{[q,{} r]} such that \spad{a = b*q + r} and the degree of \spad{r} is less than the degree of \spad{b}. This process is called


kind: o
name: leftDivide
exposed: n
type: (C,C,Automorphism(R))->Record(quotient:C,remainder:C)
params: pUnivariateSkewPolynomialCategoryOps(R,C)
abbrev: has(R,Field)
comment:
\spad{leftDivide(a,{} b,{} sigma)} returns the pair \spad{[q,{} r]} such that \spad{a = b*q + r} and the degree of \spad{r} is less than the degree of \spad{b}. This process is called


kind: o
name: leftExactQuotient
exposed: x
type: (%,%)->Union(%,failed)
params: cUnivariateSkewPolynomialCategory(R)
abbrev: has(R,Field)
comment:
\spad{leftExactQuotient(a,{} b)} computes the value \spad{q},{} if it exists,{} \indented{1}{such that \spad{a = b*q}.}


kind: o
name: leftExtendedGcd
exposed: x
type: (%,%)->Record(coef1:%,coef2:%,generator:%)
params: cUnivariateSkewPolynomialCategory(R)
abbrev: has(R,Field)
comment:
\spad{leftExtendedGcd(a,{} b)} returns \spad{[c,{} d,{} g]} such that \spad{g = a * c + b * d = leftGcd(a,{} b)}.


kind: o
name: left_ext_GCD
exposed: n
params: pXPolynomialFactor(vl,F)
type:
(XDistributedPolynomial(vl,F),XDistributedPolynomial(vl,F))->Union(Record(g:XDistributedPolynomial(vl,F),c1:XDistributedPolynomial(vl,F),c2:XDistributedPolynomial(vl,F),cu:XDistributedPolynomial(vl,F),cv:XDistributedPolynomial(vl,F)),failed)

comment:
\spad{left_ext_GCD(a,{} b)} returns [\spad{g},{} \spad{u0},{} \spad{v0},{} \spad{u},{} \spad{v}] where \spad{g} is left \spad{GCD} of a and \spad{b},{} \spad{g} = \spad{a*u0} + \spad{b*v0} and au = - \spad{bv} is least common right multiple of a and \spad{b} when a and \spad{b} have least common right multiple. Otherwise left_ext_GCD(a,{} \spad{b}) returns failed.


kind: o
name: leftFactor
exposed: n
type: (%,NonNegativeInteger)->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{leftFactor(f,{}k)} returns the left factor of rank \spad{k} of a polynomial \spad{f} or 1 if it\spad{'s} not possible by linear techniques.


kind: o
name: leftFactorIfCan
exposed: x
type: (UP,UP)->Union(UP,failed)
params: pUnivariatePolynomialDecompositionPackage(R,UP)
comment:
\spad{leftFactorIfCan(f,{} h)} returns the left factor (\spad{g} in \spad{f} = \spad{g} \spad{o} \spad{h}) of the functional decomposition of the polynomial \spad{f} with given \spad{h} or \spad{failed} if \spad{g} does not exist.


kind: o
name: leftGcd
exposed: x
type: (%,%)->%
params: cUnivariateSkewPolynomialCategory(R)
abbrev: has(R,Field)
comment:
\spad{leftGcd(a,{} b)} computes the value \spad{g} of highest degree such that \indented{3}{\spad{a = g*aa}} \indented{3}{\spad{b = g*bb}} for some values \spad{aa} and \spad{bb}. The value \spad{g} is computed using left-division.


kind: o
name: leftLcm
exposed: x
type: (%,%)->%
params: cUnivariateSkewPolynomialCategory(R)
abbrev: has(R,Field)
comment:
\spad{leftLcm(a,{} b)} computes the value \spad{m} of lowest degree such that \spad{m = aa*a = bb*b} for some values \spad{aa} and \spad{bb}. The value \spad{m} is computed using right-division.


kind: o
name: leftMinimalPolynomial
exposed: x
type: (%)->SparseUnivariatePolynomial(R)
params: cFiniteRankNonAssociativeAlgebra(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{leftMinimalPolynomial(a)} returns the polynomial determined by the smallest non-trivial linear combination of left powers of \spad{a}. Note: the polynomial never has a constant term as in general the algebra has no unit.


kind: o
name: leftMinimization
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger)->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{leftMinimization(f,{} i_min,{} i_max)} tries to apply a left minimization step with respect to the pivot block with the rows/columns (\spad{i_min},{} ...,{} i_max).


kind: o
name: leftMult
exposed: n
type: (S,%)->%
params: dListMonoidOps(S,E,un)
comment:
\spad{leftMult(s,{} a)} returns \spad{s * a} where \spad{*} is the monoid operation,{} which is assumed non-commutative.


kind: o
name: leftPower
exposed: x
type: (%,NonNegativeInteger)->%
params: cMagmaWithUnit
comment:
\spad{leftPower(a,{} n)} returns the \spad{n}\spad{-}th left power of \spad{a},{} \spadignore{i.e.} \spad{leftPower(a,{} n) := a * leftPower(a,{} n-1)} and \spad{leftPower(a,{} 0) := 1}.


kind: o
name: leftPower
exposed: x
type: (%,PositiveInteger)->%
params: cMagma
comment:
\spad{leftPower(a,{} n)} returns the \spad{n}\spad{-}th left power of \spad{a},{} \spadignore{i.e.} \spad{leftPower(a,{} n) := a * leftPower(a,{} n-1)} and \spad{leftPower(a,{} 1) := a}.


kind: o
name: leftQuotient
exposed: x
type: (%,%)->%
params: cUnivariateSkewPolynomialCategory(R)
abbrev: has(R,Field)
comment:
\spad{leftQuotient(a,{} b)} computes the pair \spad{[q,{} r]} such that \spad{a = b*q + r} and the degree of \spad{r} is less than the degree of \spad{b}. The value \spad{q} is returned.


kind: o
name: leftRank
exposed: x
type: (A)->NonNegativeInteger
params: pAlgebraPackage(R,A)
comment:
\spad{leftRank(x)} determines the number of linearly independent elements in \spad{x*b1},{} ...,{} \spad{x*bn},{} where \spad{b=[b1,{} ...,{} bn]} is a basis.


kind: o
name: leftRankPolynomial
exposed: n
type: ()->SparseUnivariatePolynomial(Polynomial(R))
params: xFramedNonAssociativeAlgebra&(S,R)
comment:
\spad{leftRankPolynomial()} calculates the left minimal polynomial of the generic element in the algebra,{} defined by the same structural constants over the polynomial ring in symbolic coefficients with respect to the fixed basis.


kind: o
name: leftRecip
exposed: x
type: (%)->Union(%,failed)
params: cFiniteRankNonAssociativeAlgebra(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{leftRecip(a)} returns an element,{} which is a left inverse of \spad{a},{} or \spad{failed} if there is no unit element,{} if such an element doesn\spad{'t} exist or cannot be determined (see unitsKnown).


kind: o
name: leftRecip
exposed: x
type: (%)->Union(%,failed)
params: cMagmaWithUnit
comment:
\spad{leftRecip(a)} returns an element,{} which is a left inverse of \spad{a},{} or \spad{failed} if such an element doesn\spad{'t} exist or cannot be determined (see unitsKnown).


kind: o
name: leftRegularRepresentation
exposed: x
type: (%)->Matrix(R)
params: cFramedNonAssociativeAlgebra(R)
comment:
\spad{leftRegularRepresentation(a)} returns the matrix of the linear map defined by left multiplication by \spad{a} with respect to the fixed \spad{R}-module basis.


kind: o
name: leftRegularRepresentation
exposed: x
type: (%,Vector(%))->Matrix(R)
params: cFiniteRankNonAssociativeAlgebra(R)
comment:
\spad{leftRegularRepresentation(a,{} [v1,{} ...,{} vn])} returns the matrix \spad{m} of the linear map defined by left multiplication by \spad{a} with respect to the \spad{R}-module basis \spad{b = [v1,{} ...,{} vn]}. That is for all \spad{x} \spad{coordinates(a*x,{} b) = m*coordinates(x,{} b)}.


kind: o
name: leftRemainder
exposed: x
type: (%,%)->%
params: cUnivariateSkewPolynomialCategory(R)
abbrev: has(R,Field)
comment:
\spad{leftRemainder(a,{} b)} computes the pair \spad{[q,{} r]} such that \spad{a = b*q + r} and the degree of \spad{r} is less than the degree of \spad{b}. The value \spad{r} is returned.


kind: o
name: leftScalarTimes!
exposed: n
type: (Matrix(R),R,Matrix(R))->Matrix(R)
params: pStorageEfficientMatrixOperations(R)
comment:
\spad{leftScalarTimes!(c,{} r,{} a)} computes the scalar product \spad{r * a} and stores the result in the matrix \spad{c}. Error: if \spad{a} and \spad{c} do not have the same dimensions.


kind: o
name: leftTraceMatrix
exposed: n
type: ()->Matrix(R)
params: xFramedNonAssociativeAlgebra&(S,R)
comment:
\spad{leftTraceMatrix()} is the \spad{n}-by-\spad{n} matrix whose element at the \spad{i}\spad{-}th row and \spad{j}\spad{-}th column is given by left trace of the product \spad{vi*vj},{} where \spad{v1},{} ...,{} \spad{vn} are the elements of the fixed \spad{R}-module basis.


kind: o
name: leftTraceMatrix
exposed: x
type: (Vector(%))->Matrix(R)
params: cFiniteRankNonAssociativeAlgebra(R)
comment:
\spad{leftTraceMatrix([v1,{} ...,{} vn])} is the \spad{n}-by-\spad{n} matrix whose element at the \spad{i}\spad{-}th row and \spad{j}\spad{-}th column is given by the left trace of the product \spad{vi*vj}.


kind: o
name: leftTrim
exposed: x
type: (%,CharacterClass)->%
params: cStringAggregate
comment:
\spad{leftTrim(s,{} cc)} returns \spad{s} with all leading characters in \spad{cc} deleted. For example,{} \spad{leftTrim((abc),{} charClass ())} returns \spad{abc)}.


kind: o
name: leftTrim
exposed: x
type: (%,S)->%
params: cLinearAggregate(S)
abbrev: AND(has(%,finiteAggregate),has(S,BasicType))
comment:
\spad{leftTrim(u,{} x)} returns a copy of \spad{u} with all leading \spad{x} deleted. For example,{} \spad{leftTrim( abc ,{} char  )} returns \spad{abc }.


kind: o
name: leftUnit
exposed: x
type: ()->Union(%,failed)
params: cFiniteRankNonAssociativeAlgebra(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{leftUnit()} returns a left unit of the algebra (not necessarily unique),{} or \spad{failed} if there is none.


kind: o
name: leftUnits
exposed: n
type: ()->Union(Record(particular:%,basis:List(%)),failed)
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
comment:
\spad{leftUnits()} returns the affine space of all left units of the algebra,{} or \spad{failed} if there is none


kind: o
name: leftUnits
exposed: x
type: ()->Union(Record(particular:%,basis:List(%)),failed)
params: cFiniteRankNonAssociativeAlgebra(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{leftUnits()} returns the affine space of all left units of the algebra,{} or \spad{failed} if there is none.


kind: o
name: legendre
exposed: n
type: (Integer)->SparseUnivariatePolynomial(Fraction(Integer))
params: pPolynomialNumberTheoryFunctions
comment:
\spad{legendre(n)} returns the \spad{n}th Legendre polynomial \spad{P[n](x)}. Note: Legendre polynomials,{} denoted \spad{P[n](x)},{} are computed from the two term recurrence. The generating function is: \spad{1/sqrt(1-2*t*x+t^2) = sum(P[n](x)*t^n,{} n=0..infinity)}.


kind: o
name: legendre
exposed: x
type: (Integer,Integer)->Integer
params: pIntegerNumberTheoryFunctions
comment:
\spad{legendre(a,{} p)} returns the Legendre symbol \spad{L(a/p)}. \spad{L(a/p) = (-1)^((p-1)/2) mod p} (\spad{p} prime),{} which is 0 if \spad{a} is 0,{} 1 if \spad{a} is a quadratic residue \spad{mod p} and \spad{-1} otherwise. Note: because the primality test is expensive,{} if it is known that \spad{p} is prime then use \spad{jacobi(a,{} p)}.


kind: o
name: legendreP
exposed: x
type: (NonNegativeInteger,R)->R
params: pOrthogonalPolynomialFunctions(R)
abbrev: has(R,Algebra(Fraction(Integer)))
comment:
\spad{legendreP(n,{} x)} is the \spad{n}-th Legendre polynomial,{} \spad{P[n](x)}. These are defined by \spad{1/sqrt(1-2*x*t+t^2) = sum(P[n](x)*t^n,{} n = 0..)}.


kind: o
name: length
exposed: n
type: (UP)->F
params: pGaloisGroupFactorizationUtilities(R,UP,F)
comment:
\spad{length(p)} returns the sum of the absolute values of the coefficients of the polynomial \spad{p}.


kind: o
name: length
exposed: x
type: (%)->R
params: cVectorCategory(R)
abbrev: AND(has(R,RadicalCategory),has(R,Ring))
comment:
\spad{length(v)} computes the sqrt(dot(\spad{v},{} \spad{v})),{} \spadignore{i.e.} the euclidean length


kind: o
name: less?
exposed: n
type: (S,S,(S,S)->Boolean)->Boolean
params: pUserDefinedPartialOrdering(S)
comment:
\spad{less?(a,{} b,{} fn)} compares \spad{a} and \spad{b} in the partial ordering induced by setOrder,{} and returns \spad{fn(a,{} b)} if \spad{a} and \spad{b} are not comparable in that ordering.


kind: o
name: level
exposed: n
type: (%)->NonNegativeInteger
params: dSubSpace(n,R)
comment:
\spad{level(s)} returns a non negative integer which is the current level field of the indicated 3 dimensional subspace \spad{s}.


kind: o
name: leviCivitaSymbol
exposed: x
type: ()->%
params: dCartesianTensor(minix,dim,R)
comment:
\spad{leviCivitaSymbol()} is the rank \spad{dim} tensor defined by \spad{leviCivitaSymbol()(i1,{} ...idim) = +1/0/-1} if \spad{i1,{} ...,{} idim} is an even/is nota /is an odd permutation of \spad{minix,{} ...,{} minix+dim-1}.


kind: o
name: lexGroebner
exposed: x
type: (List(Polynomial(F)),List(Symbol))->List(Polynomial(F))
params: pPolyGroebner(F)
comment:
\spad{lexGroebner(lp,{} lv)} computes Groebner basis for the list of polynomials \spad{lp} in lexicographic order. The variables are ordered by their position in the list \spad{lv}.


kind: o
name: lexico
exposed: n
type: (%,%)->Boolean
params: dFreeMagma(VarSet)
comment:
\spad{lexico(x,{} y)} returns \spad{true} iff \spad{x} is smaller than \spad{y} \spad{w}.\spad{r}.\spad{t}. the lexicographical ordering induced by \spad{VarSet}. \spad{N}.\spad{B}. This operation does not take into account the tree structure of its arguments. Thus this is not a total ordering.


kind: o
name: lexico
exposed: n
type: (%,%)->Boolean
params: dFreeMonoid(S)
abbrev: has(S,OrderedSet)
comment:
\spad{lexico(x,{} y)} returns \spad{true} iff \spad{x} is smaller than \spad{y} \spad{w}.\spad{r}.\spad{t}. the pure lexicographical ordering induced by \spad{S}.


kind: o
name: lexico
exposed: n
type: (%,%)->Boolean
params: dLyndonWord(VarSet)
comment:
\spad{lexico(x,{} y)} returns \spad{true} iff \spad{x} is smaller than \spad{y} \spad{w}.\spad{r}.\spad{t}. the lexicographical ordering induced by \spad{VarSet}.


kind: o
name: lexSmaller?
exposed: n
type: (SparseUnivariatePolynomial(GF),SparseUnivariatePolynomial(GF))->Boolean
params: pFiniteFieldPolynomialPackage(GF)
comment:
\spad{lexSmaller?(f,{} g)} compares monic \spad{f} and \spad{g} of the same degree in the following order. Error: if \spad{f} or \spad{g} is not monic or if \spad{f} and \spad{g} have different degrees or if common degree is 0. \spad{f < g} if the number of monomials of \spad{f} is less than this number for \spad{g}. If \spad{f} and \spad{g} have the same number of monomials,{} the lists of exponents are compared lexicographically. If these lists are also equal,{} the lists of coefficients are compared according to the lexicographic ordering induced by the ordering of the elements of {\em GF} given by {\em lookup}.


kind: o
name: lexTriangular
exposed: n
params: pLexTriangularPackage(R,ls)
type:
(List(NewSparseMultivariatePolynomial(R,OrderedVariableList(ls))),Boolean)->List(RegularChain(R,ls))

comment:
\spad{lexTriangular(base,{} norm?)} decomposes the variety associated with \spad{base} into regular chains. Thus a point belongs to this variety iff it is a regular zero of a regular set in in the output. Note that \spad{base} needs to be a lexicographical Groebner basis of a zero-dimensional ideal. If \spad{norm?} is \spad{true} then the regular sets are normalized.


kind: o
name: lfextendedint
exposed: n
type: (F,Symbol,F)->Union(Record(ratpart:F,coeff:F),failed)
params: pElementaryIntegration(R,F)
comment:
\spad{lfextendedint(f,{} x,{} g)} returns functions \spad{[h,{} c]} such that \spad{dh/dx = f - cg},{} if (\spad{h},{} \spad{c}) exist,{} failed otherwise.


kind: o
name: lfunc
exposed: x
type: (Integer,Integer)->Integer
params: pHallBasis
comment:
\spad{lfunc(d,{} n)} computes the rank of the \spad{n}th factor in the lower central series of the free \spad{d}-generated free Lie algebra; This rank is \spad{d} if \spad{n} = 1 and binom(\spad{d},{} 2) if \spad{n} = 2


kind: o
name: li
exposed: x
type: (%)->%
params: cLiouvillianFunctionCategory
comment:
\spad{\spad{li}(x)} returns the logarithmic integral of \spad{x},{} \spadignore{i.e.} the integral of \spad{dx / log(x)}.


kind: o
name: lie
exposed: n
type: (%,%)->%
params: dJetVectorField(JB,D)
comment:
\spad{lie(v,{} w)} calculates the Lie derivative of \spad{w} with respect to \spad{v}. (This yields the commutator of the fields.)


kind: o
name: lieAdmissible?
exposed: n
type: ()->Boolean
params: xFiniteRankNonAssociativeAlgebra&(S,R)
comment:
\spad{lieAdmissible?()} tests if the algebra defined by the commutators is a Lie algebra,{} \spadignore{i.e.} satisfies the Jacobi identity. The property of anticommutativity follows from definition.


kind: o
name: lieAlgebra?
exposed: n
type: ()->Boolean
params: xFiniteRankNonAssociativeAlgebra&(S,R)
comment:
\spad{lieAlgebra?()} tests if the algebra is anticommutative and \spad{(a*b)*c + (b*c)*a + (c*a)*b = 0} for all \spad{a},{} \spad{b},{} \spad{c} in the algebra (Jacobi identity). Example: for every associative algebra \spad{(A,{} +,{} @)} we can construct a Lie algebra \spad{(A,{} +,{} *)},{} where \spad{a*b := a@b-b@a}.


kind: o
name: LiePolyIfCan
exposed: n
type: (XDistributedPolynomial(VarSet,R))->Union(%,failed)
params: dLiePolynomial(VarSet,R)
comment:
\spad{LiePolyIfCan(p)} returns \spad{p} in Lyndon basis if \spad{p} is a Lie polynomial,{} otherwise \spad{failed} is returned.


kind: o
name: lift
exposed: n
params: pGenusZeroIntegration(R,F,L)
comment: \spad{lift(u,{} k)} \undocumented
type:
(SparseUnivariatePolynomial(F),Kernel(F))->SparseUnivariatePolynomial(Fraction(SparseUnivariatePolynomial(F)))


kind: o
name: lift
exposed: n
params: pMultivariateSquareFree(E,OV,R,P)
comment: \spad{lift should} be local
type:
(SparseUnivariatePolynomial(P),SparseUnivariatePolynomial(R),SparseUnivariatePolynomial(R),P,List(OV),List(NonNegativeInteger),List(R),R)->Union(List(SparseUnivariatePolynomial(P)),failed)


kind: o
name: lifting
exposed: n
params: pMultivariateLifting(E,OV,R,P)
type:
(SparseUnivariatePolynomial(P),List(OV),List(SparseUnivariatePolynomial(R)),List(R),List(P),List(NonNegativeInteger),(List(SparseUnivariatePolynomial(R)))->Union((SparseUnivariatePolynomial(R))->Union(List(SparseUnivariatePolynomial(R)),failed),failed))->Union(List(SparseUnivariatePolynomial(P)),failed)

comment:
\spad{lifting(u,{} lv,{} lu,{} lr,{} lp,{} ln,{} gen_solv)} lifts univariate factorization,{} returning recovered factors or failed in case of bad reduction. \spad{u} is multivariate polynomial to factor,{} \spad{lu} is list of univariate factors,{} \spad{lv} is list of variables,{} \spad{ln} is list of degrees corresponding to variables,{} \spad{lr} is list of evaluation points,{} \spad{lp} is list of leading coefficients of factors if known,{} empty otherwise,{} gen_solv delivers solver for polynomial equations


kind: o
name: lifting
exposed: n
params: pMultivariateLifting(E,OV,R,P)
abbrev: has(R,EuclideanDomain)
type:
(SparseUnivariatePolynomial(P),List(OV),List(SparseUnivariatePolynomial(R)),List(R),List(P),List(NonNegativeInteger),R)->Union(List(SparseUnivariatePolynomial(P)),failed)

comment:
\spad{lifting(u,{} lv,{} lu,{} lr,{} lp,{} ln,{} r)} is lifting(\spad{u},{} \spad{lv},{} \spad{lu},{} \spad{lr},{} \spad{lp},{} \spad{ln},{} solv(\spad{r})) where solv(\spad{r}) is solver using reduction modulo \spad{r} and lifting. Memberes of \spad{lu} must be relatively prime modulo \spad{r}


kind: o
name: lighting
exposed: x
type: (%,Float,Float,Float)->Void
params: dThreeDimensionalViewport
comment:
\spad{lighting(v,{} x,{} y,{} z)} sets the position of the light source to the coordinates \spad{x},{} \spad{y},{} and \spad{z} and displays the graph for the given three-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{ThreeDimensionalViewport}.


kind: o
name: li_int
exposed: n
params: pDenominatorIntegration(R,F)
comment: \spad{li_int(f,{} k,{} x)} generates logarithmic integrals.
type:
(Fraction(SparseUnivariatePolynomial(F)),Kernel(F),Symbol)->Record(answer:Fraction(SparseUnivariatePolynomial(F)),logpart:Fraction(SparseUnivariatePolynomial(F)),ir:IntegrationResult(Fraction(SparseUnivariatePolynomial(F))))


kind: o
name: limit
exposed: n
type: (%,NonNegativeInteger)->Loop
params: dFunctionGraph(S)
comment:
apply 'function' represented by this graph to 'a' repeatedly until we reach a loop which is returned as a sequence of vertex indexes.


kind: o
name: limit
exposed: x
params: pPowerSeriesLimitPackage(R,FE)
comment: \spad{limit(f(x),{} x = a)} computes the real limit \spad{lim(x -> a,{} f(x))}.
type:
(FE,Equation(OrderedCompletion(FE)))->Union(OrderedCompletion(FE),Record(leftHandLimit:Union(OrderedCompletion(FE),failed),rightHandLimit:Union(OrderedCompletion(FE),failed)),failed)


kind: o
name: limit
exposed: x
params: pRationalFunctionLimitPackage(R)
type:
(Fraction(Polynomial(R)),Equation(Fraction(Polynomial(R))))->Union(OrderedCompletion(Fraction(Polynomial(R))),Record(leftHandLimit:Union(OrderedCompletion(Fraction(Polynomial(R))),failed),rightHandLimit:Union(OrderedCompletion(Fraction(Polynomial(R))),failed)),failed)

comment:
\spad{limit(f(x),{} x = a)} computes the real two-sided limit of \spad{f} as its argument \spad{x} approaches \spad{a}.


kind: o
name: limit
exposed: x
params: pRationalFunctionLimitPackage(R)
type:
(Fraction(Polynomial(R)),Equation(OrderedCompletion(Polynomial(R))))->Union(OrderedCompletion(Fraction(Polynomial(R))),Record(leftHandLimit:Union(OrderedCompletion(Fraction(Polynomial(R))),failed),rightHandLimit:Union(OrderedCompletion(Fraction(Polynomial(R))),failed)),failed)

comment:
\spad{limit(f(x),{} x = a)} computes the real two-sided limit of \spad{f} as its argument \spad{x} approaches \spad{a}.


kind: o
name: limit
exposed: x
type: (FE,Equation(FE),String)->Union(OrderedCompletion(FE),failed)
params: pPowerSeriesLimitPackage(R,FE)
comment:
\spad{limit(f(x),{}x=a,{}left)} computes the left hand real limit \spad{lim(x -> a-,{} f(x))}; \spad{limit(f(x),{}x=a,{}right)} computes the right hand real limit \spad{lim(x -> a+,{} f(x))}.


kind: o
name: limit
exposed: x
params: pRationalFunctionLimitPackage(R)
type:
(Fraction(Polynomial(R)),Equation(Fraction(Polynomial(R))),String)->Union(OrderedCompletion(Fraction(Polynomial(R))),failed)

comment:
\spad{limit(f(x),{}x,{}a,{}left)} computes the real limit of \spad{f} as its argument \spad{x} approaches \spad{a} from the left; limit(\spad{f}(\spad{x}),{}\spad{x},{}a,{}right) computes the corresponding limit as \spad{x} approaches \spad{a} from the right.


kind: o
name: limitPart
exposed: n
type: (%)->%
params: dSmallOrdinal
comment:
\spad{limitPart(o)} = \spad{l} when \spad{o} = \spad{l} + \spad{n} and \spad{l} is a limit ordinal and \spad{n} is a nonnegative integer


kind: o
name: lin_comb
exposed: n
type: (Vector(F),List(F))->F
params: pLinearCombinationUtilities(F,UP)
comment:
\spad{lin_comb(v,{} [f1,{} ...,{} fn])} computes linear combination \spad{v}(1) \spad{f1} + ... \spad{v}(\spad{n}) \spad{fn}. Vector \spad{v} and list [\spad{f1},{} ...,{} \spad{fn}] must be of equal length.


kind: o
name: lin_comb
exposed: n
type: (Vector(F),List(Vector(F)))->Vector(F)
params: pLinearCombinationUtilities(F,UP)
comment:
\spad{lin_comb(v,{} [f1,{} ...,{} fn])} computes linear combination \spad{v}(1) \spad{f1} + ... \spad{v}(\spad{n}) \spad{fn}. Vector \spad{v} and list [\spad{f1},{} ...,{} \spad{fn}] must be of equal positive length.


kind: o
name: lin_comb!
exposed: n
type: (Vector(F),Vector(F),List(Vector(F)))->Vector(F)
params: pLinearCombinationUtilities(F,UP)
comment:
\spad{lin_comb!(v,{} w,{} [f1,{} ...,{} fn])} computes linear combination \spad{w} + \spad{v}(1) \spad{f1} + ... \spad{v}(\spad{n}) \spad{fn} by modifying \spad{w} in place. Vector \spad{v} and list [\spad{f1},{} ...,{} \spad{fn}] must be of equal length.


kind: o
name: linear?
exposed: n
type: (P)->Boolean
params: pPolynomialSetUtilitiesPackage(R,E,V,P)
comment:
\spad{linear?(p)} returns \spad{true} iff \spad{p} does not lie in the base ring \spad{R} and has main degree \spad{1}.


kind: o
name: linearAssociatedExp
exposed: x
type: (%,SparseUnivariatePolynomial(F))->%
params: cFiniteAlgebraicExtensionField(F)
abbrev: has(F,Finite)
comment:
\spad{linearAssociatedExp(a,{} f)} is linear over {\em F},{} \spadignore{i.e.} for elements {\em a} from {\em \$},{} {\em c,{} d} form {\em F} and {\em f,{} g} univariate polynomials over {\em F} we have \spadfun{linearAssociatedExp}(a,{} cf+dg) equals {\em c} times \spadfun{linearAssociatedExp}(a,{} \spad{f}) plus {\em d} times \spadfun{linearAssociatedExp}(a,{} \spad{g}). Therefore \spadfun{linearAssociatedExp} is defined completely by its action on monomials from {\em F[X]}: \spadfun{linearAssociatedExp}(a,{} monomial(1,{} \spad{k})\spad{\$}SUP(\spad{F})) is defined to be \spadfun{Frobenius}(a,{} \spad{k}) which is {\em a^(q^k)},{} where {\em q=size()\$F}.


kind: o
name: linearAssociatedLog
exposed: x
type: (%)->SparseUnivariatePolynomial(F)
params: cFiniteAlgebraicExtensionField(F)
abbrev: has(F,Finite)
comment:
\spad{linearAssociatedLog(a)} returns a polynomial {\em g},{} such that \spadfun{linearAssociatedExp}(normalElement(),{} \spad{g}) equals {\em a}.


kind: o
name: linearAssociatedLog
exposed: x
type: (%,%)->Union(SparseUnivariatePolynomial(F),failed)
params: cFiniteAlgebraicExtensionField(F)
abbrev: has(F,Finite)
comment:
\spad{linearAssociatedLog(b,{} a)} returns a polynomial {\em g},{} such that the \spadfun{linearAssociatedExp}(\spad{b},{} \spad{g}) equals {\em a}. If there is no such polynomial {\em g},{} then \spadfun{linearAssociatedLog} fails.


kind: o
name: linearAssociatedOrder
exposed: x
type: (%)->SparseUnivariatePolynomial(F)
params: cFiniteAlgebraicExtensionField(F)
abbrev: has(F,Finite)
comment:
\spad{linearAssociatedOrder(a)} returns the monic polynomial {\em g} of least degree,{} such that \spadfun{linearAssociatedExp}(a,{} \spad{g}) is 0.


kind: o
name: linearDependence
exposed: n
type: (Vector(R))->Union(Vector(S),failed)
params: pLinearDependence(S,R)
comment:
\spad{linearDependence([v1,{} ...,{} vn])} returns \spad{[c1,{} ...,{} cn]} if \spad{c1*v1 + ... + cn*vn = 0} and not all the \spad{ci}\spad{'s} are 0,{} failed if the \spad{vi}\spad{'s} are linearly independent over \spad{S}.


kind: o
name: linearDependenceOverConstants
exposed: n
type: (Vector(F),List((F)->F))->Union(Vector(F),failed)
params: pConstantLinearDependence(R,F)
comment:
\spad{linearlyDependenceOverConstants([v1,{} ...,{} vn],{} ld)} returns \spad{[c1,{} ...,{} cn]} if \spad{c1*v1 + ... + cn*vn = 0} and not all the \spad{ci}\spad{'s} are 0,{} failed if the \spad{vi}\spad{'s} are linearly independent over constants.


kind: o
name: linearDependenceOverZ
exposed: x
type: (Vector(R))->Union(Vector(Integer),failed)
params: pIntegerLinearDependence(R)
comment:
\spad{linearlyDependenceOverZ([v1,{} ...,{} vn])} returns \spad{[c1,{} ...,{} cn]} if \spad{c1*v1 + ... + cn*vn = 0} and not all the \spad{ci}\spad{'s} are 0,{} failed if the \spad{vi}\spad{'s} are linearly independent over the integers.


kind: o
name: linearExtend
exposed: n
type: ((List(B))->M2,TensorPower(n,R,B,M1))->M2
params: pTensorPowerFunctions2(n,R,B,M1,M2)
comment:
\spad{linearExtend: (f,{} x)} returns the linear extension of a multilinear map defined on the basis of \spad{M2} applied to a linear combination


kind: o
name: linearExtend
exposed: x
type: ((S)->M2,M1)->M2
params: pFreeModuleFunctions2(R,S,M1,M2)
comment:
\spad{linearExtend: (f,{} x)} returns the linear extension of a map defined on the basis of \spad{M2} applied to a linear combination


kind: o
name: linearExtend
exposed: x
type: ((S)->R,%)->R
params: cFreeModuleCategory(R,S)
abbrev: has(R,CommutativeRing)
comment:
\spad{linearExtend: (f,{} x)} returns the linear extension of a map defined on the basis applied to a linear combination


kind: o
name: linearization
exposed: n
type: (%)->Matrix(%)
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{linearization(f)} returns the element \spad{f} as linearization with entries represented by admissible linear systems in minimal refined form.


kind: o
name: linearize
exposed: n
params: pSymmetryAnalysis(JB1,xi,eta)
type:
(List(JetBundleExpression(JetBundleSymAna(JB1,xi,eta))))->List(JetBundleLinearFunction(JetBundleSymAna(JB1,xi,eta),JetBundleXExpression(JetBundleSymAna(JB1,xi,eta))))

comment:
\spad{linearize(sys)} tries to retract all equations in \spad{sys} to a linear one. If that is not possible,{} an error occurs.


kind: o
name: linearlyDependent?
exposed: n
type: (Vector(R))->Boolean
params: pLinearDependence(S,R)
comment:
\spad{linearlyDependent?([v1,{} ...,{} vn])} returns \spad{true} if the \spad{vi}\spad{'s} are linearly dependent over \spad{S},{} \spad{false} otherwise.


kind: o
name: linearlyDependentOverConstants?
exposed: n
type: (Vector(F),List((F)->F))->Boolean
params: pConstantLinearDependence(R,F)
comment:
\spad{linearlyDependentOverConstants?([v1,{} ...,{} vn],{} ld)} returns \spad{true} if the \spad{vi}\spad{'s} are linearly dependent over constants,{} \spad{false} otherwise.


kind: o
name: linearlyDependentOverZ?
exposed: x
type: (Vector(R))->Boolean
params: pIntegerLinearDependence(R)
comment:
\spad{linearlyDependentOverZ?([v1,{} ...,{} vn])} returns \spad{true} if the \spad{vi}\spad{'s} are linearly dependent over the integers,{} \spad{false} otherwise.


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


kind: o
name: linearSearch
exposed: n
type: ((S)->Boolean)->Union(S,failed)
params: pSortedCache(S)
comment:
\spad{linearSearch(f)} searches the cache,{} calling \spad{f(y)} find desired \spad{y}. It returns \spad{y} from cache if \spad{f}(\spad{y}) is \spad{true} or failed if no such \spad{y} exists.


kind: o
name: lineColorDefault
exposed: x
type: (Palette)->Palette
params: pViewDefaultsPackage
comment:
\spad{lineColorDefault(p)} sets the default color of lines connecting points in a 2D viewport to the palette \spad{p}.


kind: o
name: lineIntersect
exposed: n
type: (%,PT)->PT
params: dSBoundary(PT)
comment:
\spad{lineIntersect(n,{} p)} returns the point where a line,{} from the centre of the boundary to the point \spad{p},{} intersects with the boundary. \spad{n:} \% is the boundary \spad{p:} \spad{PT} is the point at the end of the line (outside boundary)


kind: o
name: lines
exposed: n
type: (%)->List(String)
params: dOutputBox
comment:
\spad{lines(box)} returns the contents of the \spad{box} as strings (all of the same length (width(\spad{box})).


kind: o
name: linGenPos
exposed: n
params: pLinGroebnerPackage(lv,F)
comment: \spad{linGenPos }\undocumented
type:
(List(HomogeneousDistributedMultivariatePolynomial(lv,F)))->Record(gblist:List(DistributedMultivariatePolynomial(lv,F)),gvlist:List(Integer))


kind: o
name: link
exposed: n
type: (%,%)->List(PT)
params: dSBoundary(PT)
comment:
\spad{link(m,{} n)} returns a line which is the shortest distance between the two boundaries. The line is represented by its two endpoints. \spad{m:} \% is the first boundary to be linked \spad{n:} \% is the second boundary to be linked


kind: o
name: link
exposed: n
type: (%,OrientedFacet)->%
params: dFiniteSimplicialComplex(VS)
comment:
The 'link' of a simplicial complex and a vertex contains the boundary of the simplexes of \spad{s} which include simplex.


kind: o
name: lin_sol
exposed: n
type: (List(F),List(Symbol))->Union(List(F),failed)
params: pExpressionLinearSolve(R,F)
comment:
\spad{lin_sol(eql,{} vl)} solves system of equations \spad{eql} for variables in \spad{vl}. Equations must be linear in variables from \spad{vl}.


kind: o
name: linSolve
exposed: x
params: pLinearSystemPolynomialPackage(R,E,OV,P)
type:
(List(P),List(OV))->Record(particular:Union(Vector(Fraction(P)),failed),basis:List(Vector(Fraction(P))))

comment:
\spad{linSolve(lp,{} lvar)} finds the solutions of the linear system of polynomials \spad{lp} = 0 with respect to the list of symbols lvar.


kind: o
name: listBranches
exposed: x
type: (%)->List(List(Point(DoubleFloat)))
params: cPlottablePlaneCurveCategory
comment:
\spad{listBranches(c)} returns a list of lists of points,{} representing the branches of the curve \spad{c}.


kind: o
name: listConjugateBases
exposed: n
params: pChineseRemainderToolsForIntegralBases(K,R,UP)
type:
(Record(basis:Matrix(R),basisDen:R,basisInv:Matrix(R)),NonNegativeInteger,NonNegativeInteger)->List(Record(basis:Matrix(R),basisDen:R,basisInv:Matrix(R)))

comment:
\spad{listConjugateBases(bas,{} q,{} n)} returns the list \spad{[bas,{} bas^Frob,{} bas^(Frob^2),{} ...bas^(Frob^(n-1))]},{} where \spad{Frob} raises the coefficients of all polynomials appearing in the basis \spad{bas} to the \spad{q}th power.


kind: o
name: listLoops
exposed: n
type: (%)->List(List(Point(DoubleFloat)))
params: dTubePlot(Curve)
comment:
\spad{listLoops(t)} returns the list of lists of points,{} or the 'loops',{} of the given tube plot \spad{t}.


kind: o
name: listOfTerms
exposed: x
type: (%)->List(Record(k:S,c:A))
params: cIndexedDirectProductCategory(A,S)
comment:
\spad{listOfTerms(x)} returns a list \spad{lt} of terms with type \spad{Record(k: S,{} c: R)} such that \spad{x} equals \spad{construct(lt)}. If \spad{S has Comparable} than \spad{x} equals \spad{constructOrdered(lt)}.


kind: o
name: listRepresentation
exposed: x
type: (%)->Record(preimage:List(S),image:List(S))
params: dPermutation(S)
comment:
\spad{listRepresentation(p)} produces a representation {\em rep} of the permutation \spad{p} as a list of preimages and images,{} \spad{i}.\spad{e} \spad{p} maps {\em (rep.preimage).k} to {\em (rep.image).k} for all indices \spad{k}. Elements of \spad{S} not in {\em (rep.preimage).k} are fixed points,{} and these are the only fixed points of the permutation.


kind: o
name: listYoungTableaus
exposed: x
type: (List(Integer))->List(Matrix(Integer))
params: pSymmetricGroupCombinatoricFunctions
comment:
\spad{listYoungTableaus(lambda)} where {\em lambda} is a proper partition generates the list of all standard tableaus of shape {\em lambda} by means of lattice permutations. The numbers of the lattice permutation are interpreted as column labels. Hence the contents of these lattice permutations are the conjugate of {\em lambda}. Notes: the functions {\em nextLatticePermutation} and {\em makeYoungTableau} are used. The entries are from {\em 0,{} ...,{} n-1}.


kind: o
name: LLFPI_to_LPA
exposed: n
params: pModularHermitePade
comment: evaluation routine
type:
(List(List(Fraction(Polynomial(Integer)))),Integer,List(Symbol),List(Integer),Integer)->Union(List(U32Vector),failed)


kind: o
name: LLL
exposed: n
type: (Matrix(Integer))->Matrix(Integer)
params: pLLLReduction
comment:
\spad{LLL(m)} computes \spad{LLL} reduction of \spad{m} \spad{LLL}(\spad{m}) is the same as extendedLLL!(copy \spad{m},{} ncols \spad{m}).


kind: o
name: lllip
exposed: x
type: (%)->List(List(List(NonNegativeInteger)))
params: cThreeSpaceCategory(R)
comment:
\spad{lllip(s)} checks to see if the \spadtype{ThreeSpace},{} \spad{s},{} is composed of a list of components,{} which are lists of curves,{} which are lists of indices to points,{} and if so,{} returns the list of lists of lists; An error is signaled otherwise.


kind: o
name: lllp
exposed: x
type: (%)->List(List(List(Point(R))))
params: cThreeSpaceCategory(R)
comment:
\spad{lllp(s)} checks to see if the \spadtype{ThreeSpace},{} \spad{s},{} is composed of a list of components,{} which are lists of curves,{} which are lists of points,{} and if so,{} returns the list of lists of lists; An error is signaled otherwise.


kind: o
name: llprop
exposed: x
type: (%)->List(List(SubSpaceComponentProperty))
params: cThreeSpaceCategory(R)
comment:
\spad{llprop(s)} checks to see if the \spadtype{ThreeSpace},{} \spad{s},{} is composed of a list of curves which are lists of the subspace component properties of the curves,{} and if so,{} returns the list of lists; An error is signaled otherwise.


kind: o
name: localAbs
exposed: n
type: (FE)->FE
params: pFunctionSpaceToExponentialExpansion(R,FE,x,cen)
comment:
\spad{localAbs(fcn)} = \spad{abs(fcn)} or \spad{sqrt(fcn^2)} depending on whether or not FE has a function \spad{abs}. This should be a local function,{} but the compiler won\spad{'t} allow it.


kind: o
name: localIntegralBasis
exposed: n
type: (Integer)->Record(basis:Matrix(Integer),basisDen:Integer,basisInv:Matrix(Integer))
params: pNumberFieldIntegralBasis(UP,F)
comment:
\spad{integralBasis(p)} returns a record \spad{[basis,{} basisDen,{} basisInv]} containing information regarding the local integral closure of \spad{Z} at the prime \spad{p} in the quotient field of \spad{F},{} where \spad{F} is a framed algebra with \spad{Z}-module basis \spad{w1,{} w2,{} ...,{} wn}. If \spad{basis} is the matrix \spad{(aij,{} i = 1..n,{} j = 1..n)},{} then the \spad{i}th element of the integral basis is \spad{\spad{vi} = (1/basisDen) * sum(aij * wj,{} j = 1..n)},{} \spadignore{i.e.} the \spad{i}th row of \spad{basis} contains the coordinates of the \spad{i}th basis vector. Similarly,{} the \spad{i}th row of the matrix \spad{basisInv} contains the coordinates of \spad{\spad{wi}} with respect to the basis \spad{v1,{} ...,{} vn}: if \spad{basisInv} is the matrix \spad{(bij,{} i = 1..n,{} j = 1..n)},{} then \spad{\spad{wi} = sum(bij * vj,{} j = 1..n)}.


kind: o
name: localIntegralBasis
exposed: n
type: (R)->Record(basis:Matrix(R),basisDen:R,basisInv:Matrix(R))
params: pFunctionFieldIntegralBasis(R,UP,F)
comment:
\spad{integralBasis(p)} returns a record \spad{[basis,{} basisDen,{} basisInv]} containing information regarding the local integral closure of \spad{R} at the prime \spad{p} in the quotient field of \spad{F},{} where \spad{F} is a framed algebra with \spad{R}-module basis \spad{w1,{} w2,{} ...,{} wn}. If \spad{basis} is the matrix \spad{(aij,{} i = 1..n,{} j = 1..n)},{} then the \spad{i}th element of the local integral basis is \spad{\spad{vi} = (1/basisDen) * sum(aij * wj,{} j = 1..n)},{} \spadignore{i.e.} the \spad{i}th row of \spad{basis} contains the coordinates of the \spad{i}th basis vector. Similarly,{} the \spad{i}th row of the matrix \spad{basisInv} contains the coordinates of \spad{\spad{wi}} with respect to the basis \spad{v1,{} ...,{} vn}: if \spad{basisInv} is the matrix \spad{(bij,{} i = 1..n,{} j = 1..n)},{} then \spad{\spad{wi} = sum(bij * vj,{} j = 1..n)}.


kind: o
name: localIntegralBasis
exposed: n
type: (R)->Record(basis:Matrix(R),basisDen:R,basisInv:Matrix(R))
params: pPAdicWildFunctionFieldIntegralBasis(K,R,UP,F)
comment:
\spad{integralBasis(p)} returns a record \spad{[basis,{} basisDen,{} basisInv] } containing information regarding the local integral closure of \spad{R} at the prime \spad{p} in the quotient field of the framed algebra \spad{F}. \spad{F} is a framed algebra with \spad{R}-module basis \spad{w1,{} w2,{} ...,{} wn}. If 'basis' is the matrix \spad{(aij,{} i = 1..n,{} j = 1..n)},{} then the \spad{i}th element of the local integral basis is \spad{\spad{vi} = (1/basisDen) * sum(aij * wj,{} j = 1..n)},{} \spadignore{i.e.} the \spad{i}th row of 'basis' contains the coordinates of the \spad{i}th basis vector. Similarly,{} the \spad{i}th row of the matrix 'basisInv' contains the coordinates of \spad{\spad{wi}} with respect to the basis \spad{v1,{} ...,{} vn}: if 'basisInv' is the matrix \spad{(bij,{} i = 1..n,{} j = 1..n)},{} then \spad{\spad{wi} = sum(bij * vj,{} j = 1..n)}.


kind: o
name: LODO2FUN
exposed: n
type: (L)->(List(UTS))->UTS
params: pUTSodetools(F,UP,L,UTS)
comment:
\spad{LODO2FUN(op)} returns the function to pass to the series ODE solver in order to solve \spad{op y = 0}.


kind: o
name: log1
exposed: n
type: (Stream(Coef))->Stream(Coef)
params: pStreamExponentialSeriesOperations(Coef)
comment:
\spad{log1(f)} returns the logarithm of the power series represented by cons(1,{} \spad{f}),{} \spadignore{i.e.} assuming that the constant term is 1 and therefore transcendentality is not involved.


kind: o
name: log
exposed: n
type: (Factored(M))->List(Record(coef:NonNegativeInteger,logand:M))
params: pFactoredFunctions(M)
comment:
\spad{log(f)} returns \spad{[(a1,{} b1),{} ...,{} (am,{} bm)]} such that the logarithm of \spad{f} is equal to \spad{a1*log(b1) + ... + am*log(bm)}.


kind: o
name: log
exposed: x
type: (%)->%
params: cElementaryFunctionCategory
comment:
\spad{log(x)} returns the natural logarithm of \spad{x}. When evaluated into some subset of the complex numbers,{} the branch cut lies along the negative real axis,{} continuous with quadrant II. The domain does not contain the origin.


kind: o
name: logDependenceQ
exposed: n
type: (List(Fraction(Integer)),Fraction(Integer))->Union(Vector(Fraction(Integer)),failed)
params: pMultiplicativeDependence
comment:
\spad{logDependenceQ([q1,{} ...,{} qn],{} q0)} finds rational constants \spad{c1,{} ...cn} such that \spad{q1^c1*...*qn^cn=u*q0} where \spad{u} is a unit


kind: o
name: logextint
exposed: n
type: (Symbol,List(Kernel(F)),List(F))->Record(logands:List(F),basis:List(Vector(Fraction(Integer))))
params: pParametricIntegration(R,F)
comment:
\spad{logextint(x,{} lk,{} lg)} returns [[\spad{u1},{} ...,{} um],{} bas] giving basis of solution of the homogeneous systym \spad{c1*g1 + ... + cn*gn + c_{n+1}u1'/u1 + ... c_{n+m}um'/um = 0}


kind: o
name: logextint
exposed: n
params: pParametricTranscendentalIntegration(F,UP)
type:
((UP)->UP,(UP)->Factored(UP),(Matrix(F))->List(Vector(Fraction(Integer))),(List(UP))->Record(logands:List(Fraction(UP)),basis:List(Vector(Fraction(Integer)))),List(Fraction(UP)))->Record(logands:List(Fraction(UP)),basis:List(Vector(Fraction(Integer))))

comment:
\spad{logextint(der,{} ufactor,{} csolve,{} rec,{} [g1,{} ...,{} gn])} returns [[\spad{u1},{} ...,{} um],{} bas] giving basis of solution of the homogeneous systym \spad{c1*g1 + ... + cn*gn + c_{n+1}u1'/u1 + ... c_{n+m}um'/um = 0}


kind: o
name: logpart
exposed: n
params: dIntegrationResult(F)
comment: \spad{logpart(ir)} returns the logarithmic part of an integration result
type:
(%)->List(Record(scalar:Fraction(Integer),coeff:SparseUnivariatePolynomial(F),logand:SparseUnivariatePolynomial(F)))


kind: o
name: loopPoints
exposed: n
params: pTubePlotTools
type:
(Point(DoubleFloat),Point(DoubleFloat),Point(DoubleFloat),DoubleFloat,List(List(DoubleFloat)))->List(Point(DoubleFloat))

comment:
\spad{loopPoints(p,{} n,{} b,{} r,{} lls)} creates and returns a list of points which form the loop with radius \spad{r},{} around the center point indicated by the point \spad{p},{} with the principal normal vector of the space curve at point \spad{p} given by the point(vector) \spad{n},{} and the binormal vector given by the point(vector) \spad{b},{} and a list of lists,{} \spad{lls},{} which is the \spadfun{cosSinInfo} of the number of points defining the loop.


kind: o
name: loopsArrows
exposed: n
type: (%)->List(Loop)
params: cFiniteGraph(S)
comment:
\spad{loopsArrows(s)} returns a list of loops for this graph in this case the loop is represented by the indexes of the sequence of nodes passed through. to-do: it would be better to use a more efficient algorithm,{} currently the code calls spanningForestArrow and traverses the result for loops,{} it might be more efficient to use Floyds algorithm.


kind: o
name: loopsAtNode
exposed: n
type: (%,NonNegativeInteger)->List(Loop)
params: cFiniteGraph(S)
comment:
\spad{loopsAtNode(s,{} a)} returns a list of loops for this graph that pass through vertex index 'a'


kind: o
name: loopsNodes
exposed: n
type: (%)->List(Loop)
params: cFiniteGraph(S)
comment:
\spad{loopsNodes(s)} returns a list of loops for this graph in this case the loop is represented by the indexes of the sequence of nodes passed through.


kind: o
name: looseEquals
exposed: n
type: (%,%)->Boolean
params: cFiniteGraph(S)
comment:
\spad{looseEquals(x,{} y)} is \spad{true} if \spad{x} 'equals' \spad{y} this is a looser version of equality test but is not as general as isomorphism. it only requires the same number of vertices but does not require the objects themselves being equal. the arrows must be the same,{} that is it may return \spad{false} if the order of vertices is changed so this is not isomorphism test.


kind: o
name: lowerCase
exposed: x
type: ()->%
params: dCharacterClass
comment:
\spad{lowerCase()} returns the class of all characters for which \spadfunFrom{lowerCase?}{Character} is \spad{true}.


kind: o
name: lowerCase?
exposed: x
type: (%)->Boolean
params: dCharacter
comment:
\spad{lowerCase?(c)} tests if \spad{c} is an lower case letter,{} \spadignore{i.e.} one of a..\spad{z}.


kind: o
name: lowerCase
exposed: x
type: (%)->%
params: dCharacter
comment:
\spad{lowerCase(c)} converts an upper case letter to the corresponding lower case letter. If \spad{c} is not an upper case letter,{} then it is returned unchanged.


kind: o
name: lowerPolynomial
exposed: n
type: (SparseUnivariatePolynomial(P))->SparseUnivariatePolynomial(R)
params: pFactoringUtilities(E,OV,R,P)
comment:
\spad{lowerPolynomial(upoly)} converts \spad{upoly} to be a univariate polynomial over \spad{R}. An error if the coefficients contain variables.


kind: o
name: lowerSet
exposed: n
type: (%)->%
params: cPoset(S)
comment:
a subset \spad{U} with the property that,{} if \spad{x} is in \spad{U} and \spad{x} \spad{>=} \spad{y},{} then \spad{y} is in \spad{U}


kind: o
name: LowTriBddDenomInv
exposed: n
type: (M,R)->M
params: pTriangularMatrixOperations(R,Row,Col,M)
comment:
\spad{LowTriBddDenomInv(B,{} d)} returns \spad{M},{} where \spad{B} is a non-singular lower triangular matrix and \spad{d} is an element of \spad{R} such that \spad{M = d * inv(B)} has entries in \spad{R}.


kind: o
name: lp
exposed: x
type: (%)->List(Point(R))
params: cThreeSpaceCategory(R)
comment:
\spad{lp(s)} returns the list of points component which the \spadtype{ThreeSpace},{} \spad{s},{} contains; these points are used by reference,{} \spadignore{i.e.} the component holds indices referring to the points rather than the points themselves. This allows for sharing of the points.


kind: o
name: lprop
exposed: x
type: (%)->List(SubSpaceComponentProperty)
params: cThreeSpaceCategory(R)
comment:
\spad{lprop(s)} checks to see if the \spadtype{ThreeSpace},{} \spad{s},{} is composed of a list of subspace component properties,{} and if so,{} returns the list; An error is signaled otherwise.


kind: o
name: lquo
exposed: n
type: (%,%)->Union(%,failed)
params: dFreeMonoid(S)
comment:
\spad{lquo(x,{} y)} returns the exact left quotient of \spad{x} by \spad{y} \spadignore{i.e.} \spad{q} such that \spad{x = y * q},{} failed if \spad{x} is not of the form \spad{y * q}.


kind: o
name: lSpaceBasis
exposed: n
type: (%)->Vector(R)
params: dFiniteDivisor(F,UP,UPUP,R)
comment:
\spad{lSpaceBasis(d)} returns a basis for \spad{L(d) = {f | (f) >= -d}} as a module over \spad{K[x]}.


kind: o
name: lub
exposed: n
type: (%,List(NonNegativeInteger))->Union(NonNegativeInteger,failed)
params: cPoset(S)
comment:
\spad{lub(s,{} l)} is 'least upper bound' or 'supremum' of \spad{l}. In this version of lub nodes are represented as index values. Not every subset of a poset will have a lub in which case failed will be returned as an error indication.


kind: o
name: LUDecomp
exposed: n
type: (Matrix(D))->Record(LU:Matrix(D),Perm:Vector(Integer),Pivots:List(D))
params: pLUDecomposition(D)
comment:
\spad{LUDecomp(A)} computes a LU decomposition of \spad{A} using the algorithm of Crout. \spad{LU} contains both triangular matrices; \spad{Perm} is the permutation used for partial pivoting and \spad{Pivots} yields the used pivots.


kind: o
name: LUSolve
exposed: n
type: (Matrix(D),Vector(Integer),Vector(D))->Vector(D)
params: pLUDecomposition(D)
comment:
\spad{LUSolve(LU,{} Perm,{} B)} uses a previously computed \spad{LU} decomposition to solve a linear system with right hand side \spad{B}. \spad{LU} and \spad{Perm} are as given by \spad{LUDecomp}.


kind: o
name: LyndonWordsList1
exposed: n
type: (List(VarSet),PositiveInteger)->OneDimensionalArray(List(%))
params: dLyndonWord(VarSet)
comment:
\spad{LyndonWordsList1(vl,{} n)} returns an array of lists of Lyndon words over the alphabet \spad{vl},{} up to order \spad{n}.


kind: o
name: LyndonWordsList
exposed: n
type: (List(VarSet),PositiveInteger)->List(%)
params: dLyndonWord(VarSet)
comment:
\spad{LyndonWordsList(vl,{} n)} returns the list of Lyndon words over the alphabet \spad{vl},{} up to order \spad{n}.


kind: o
name: mainCoefficients
exposed: x
type: (%)->List(%)
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{mainCoefficients(p)} returns an error if \spad{p} is \spad{O},{} otherwise,{} if \spad{p} belongs to \spad{R} returns [\spad{p}],{} otherwise returns the list of the coefficients of \spad{p},{} where \spad{p} is viewed as a univariate polynomial in its main variable.


kind: o
name: mainContent
exposed: x
type: (%)->%
params: cRecursivePolynomialCategory(R,E,V)
abbrev: has(R,GcdDomain)
comment:
\spad{mainContent(p)} returns the content of \spad{p} viewed as a univariate polynomial in its main variable and with coefficients in the polynomial ring generated by its other variables over \spad{R}.


kind: o
name: mainDefiningPolynomial
exposed: x
type: (%)->Union(SparseUnivariatePolynomial(%),failed)
params: cRealClosedField
comment:
\spad{mainDefiningPolynomial(x)} is the defining polynomial for the main algebraic quantity of \spad{x}


kind: o
name: mainKernel
exposed: x
type: (%)->Union(K,failed)
params: cExpressionSpace2(K)
comment:
\spad{mainKernel(f)} returns a kernel of \spad{f} with maximum nesting level,{} or failed if \spad{f} has no kernels (\spadignore{i.e.} \spad{f} is a constant).


kind: o
name: mainMonomial
exposed: x
type: (%)->%
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{mainMonomial(p)} returns an error if \spad{p} is \spad{O},{} otherwise,{} if \spad{p} belongs to \spad{R} returns \spad{1},{} otherwise,{} \spad{mvar(p)} raised to the power \spad{mdeg(p)}.


kind: o
name: mainMonomials
exposed: x
type: (%)->List(%)
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{mainMonomials(p)} returns an error if \spad{p} is \spad{O},{} otherwise,{} if \spad{p} belongs to \spad{R} returns [1],{} otherwise returns the list of the monomials of \spad{p},{} where \spad{p} is viewed as a univariate polynomial in its main variable.


kind: o
name: mainPrimitivePart
exposed: x
type: (%)->%
params: cRecursivePolynomialCategory(R,E,V)
abbrev: has(R,GcdDomain)
comment:
\spad{mainPrimitivePart(p)} returns the primitive part of \spad{p} viewed as a univariate polynomial in its main variable and with coefficients in the polynomial ring generated by its other variables over \spad{R}.


kind: o
name: mainSquareFreePart
exposed: x
type: (%)->%
params: cRecursivePolynomialCategory(R,E,V)
abbrev: has(R,GcdDomain)
comment:
\spad{mainSquareFreePart(p)} returns the square free part of \spad{p} viewed as a univariate polynomial in its main variable and with coefficients in the polynomial ring generated by its other variables over \spad{R}.


kind: o
name: mainVariable
exposed: n
type: (F)->Union(V,failed)
params: pPolynomialCategoryQuotientFunctions(E,V,R,P,F)
comment:
\spad{mainVariable(f)} returns the highest variable appearing in the numerator or the denominator of \spad{f},{} failed if \spad{f} has no variables.


kind: o
name: mainVariable
exposed: n
type: (%)->Union(VarSet,failed)
params: cMaybeSkewPolynomialCategory(R,E,VarSet)
comment:
\spad{mainVariable(p)} returns the biggest variable which actually occurs in the polynomial \spad{p},{} or failed if no variables are present. fails precisely if polynomial satisfies ground?


kind: o
name: mainVariable?
exposed: x
type: (VarSet,%)->Boolean
params: cPolynomialSetCategory(R,E,VarSet,P)
comment:
\spad{mainVariable?(v,{} ps)} returns \spad{true} iff \spad{v} is the main variable of some polynomial in \spad{ps}.


kind: o
name: mainVariables
exposed: x
type: (%)->List(VarSet)
params: cPolynomialSetCategory(R,E,VarSet,P)
comment:
\spad{mainVariables(ps)} returns the decreasingly sorted list of the variables which are main variables of some polynomial in \spad{ps}.


kind: o
name: makeCell
exposed: n
type: (SimpleCell(TheField,SparseUnivariatePolynomial(TheField)),%)->%
params: dCell(TheField)
comment:
\spad{makeCell(c,{} sc)} creates a cell which consists of \spad{sc} in main variable and which has projection \spad{c}


kind: o
name: makeCrit
exposed: n
params: pGroebnerInternalPackage(Dom,Expon,Dpol)
comment: \spad{makeCrit }\undocumented
type:
(Record(totdeg:NonNegativeInteger,pol:Dpol),Dpol,NonNegativeInteger)->Record(lcmfij:Expon,totdeg:NonNegativeInteger,poli:Dpol,polj:Dpol)


kind: o
name: makeDisjoint
exposed: n
type: (%,%)->%
params: dFiniteSimplicialComplex(VS)
comment:
If index numbers of \spad{'b'} overlap with index numbers of 'a' then refactor \spad{'b'} so that it does not overlap.


kind: o
name: makeEq
exposed: n
type: (List(F),List(Symbol))->List(Equation(Polynomial(F)))
params: pInnerNumericFloatSolvePackage(K,F,Par)
comment:
\spad{makeEq(lsol,{} lvar)} returns a list of equations formed by corresponding members of lvar and \spad{lsol}.


kind: o
name: makeFEq
exposed: n
type: (BasicOperator,Symbol,Symbol,F,List(F),Stream(F))->F
params: pRecurrenceOperator(R,F)
comment:
\spad{evalADE(f,{} x,{} n,{} eq,{} parameters,{} values)} creates an expression that stands for the coefficient of \spad{x^n} in the Taylor expansion of \spad{f}(\spad{x}),{} where \spad{f}(\spad{x}) is given by the functional equation \spad{eq}. The argument values specifies the first few Taylor coefficients.


kind: o
name: makeFloatFunction
exposed: x
type: (S,Symbol)->(DoubleFloat)->DoubleFloat
params: pMakeFloatCompiledFunction(S)
comment:
\spad{makeFloatFunction(expr,{} x)} returns a Lisp function \spad{f}: \spadtype{DoubleFloat} \spad{->} \spadtype{DoubleFloat} defined by \spad{f(x) == expr}. Function \spad{f} is compiled and directly applicable to objects of type \spadtype{DoubleFloat}.


kind: o
name: makeFloatFunction
exposed: x
type: (S,Symbol,Symbol)->(DoubleFloat,DoubleFloat)->DoubleFloat
params: pMakeFloatCompiledFunction(S)
comment:
\spad{makeFloatFunction(expr,{} x,{} y)} returns a Lisp function \spad{f}: (\spadtype{DoubleFloat},{} \spadtype{DoubleFloat}) \spad{->} \spadtype{DoubleFloat} defined by \spad{f(x,{} y) == expr}. Function \spad{f} is compiled and directly applicable to objects of type (\spadtype{DoubleFloat},{} \spadtype{DoubleFloat}).


kind: o
name: makeGraphImage
exposed: n
type: (List(List(Point(DoubleFloat))))->%
params: dGraphImage
comment:
\spad{makeGraphImage(llp)} returns a graph of the domain \spadtype{GraphImage} which is composed of the points and lines from the list of lists of points,{} \spad{llp},{} with default point size and default point and line colours.


kind: o
name: makeGraphImage
exposed: n
type: (List(List(Point(DoubleFloat))),List(Palette),List(Palette),List(PositiveInteger))->%
params: dGraphImage
comment:
\spad{makeGraphImage(llp,{} lpal1,{} lpal2,{} lp)} returns a graph of the domain \spadtype{GraphImage} which is composed of the points and lines from the list of lists of points,{} \spad{llp},{} whose point colors are indicated by the list of palette colors,{} \spad{lpal1},{} and whose lines are colored according to the list of palette colors,{} \spad{lpal2}. The parameter \spad{lp} is a list of integers which denote the size of the data points.


kind: o
name: makeGraphImage
exposed: n
params: dGraphImage
type:
(List(List(Point(DoubleFloat))),List(Palette),List(Palette),List(PositiveInteger),List(DrawOption))->%

comment:
\spad{makeGraphImage(llp,{} lpal1,{} lpal2,{} lp,{} lopt)} returns a graph of the domain \spadtype{GraphImage} which is composed of the points and lines from the list of lists of points,{} \spad{llp},{} whose point colors are indicated by the list of palette colors,{} \spad{lpal1},{} and whose lines are colored according to the list of palette colors,{} \spad{lpal2}. The parameter \spad{lp} is a list of integers which denote the size of the data points,{} and \spad{lopt} is the list of draw command options.


kind: o
name: make_imaginary_part_function
exposed: x
type: (S,Symbol)->(DoubleFloat)->DoubleFloat
params: pMakeFloatCompiledFunction(S)
comment:
\spad{make_imaginary_part_function(expr,{} x)} returns a Lisp function \spad{f}: \spadtype{DoubleFloat} \spad{->} \spadtype{DoubleFloat} defined by \spad{f(x) == imag(expr)}. Function \spad{f} is compiled and directly applicable to objects of type \spadtype{DoubleFloat}.


kind: o
name: makeObject
exposed: x
type: ((DoubleFloat)->Point(DoubleFloat),Segment(Float))->ThreeSpace(DoubleFloat)
params: pTopLevelDrawFunctionsForCompiledFunctions
comment:
\spad{makeObject(sp,{} curve(f,{} g,{} h),{} a..b)} returns the space \spad{sp} of the domain \spadtype{ThreeSpace} with the addition of the graph of the parametric curve \spad{x = f(t),{} y = g(t),{} z = h(t)} as \spad{t} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)}.


kind: o
name: makeObject
exposed: x
type: (ParametricSpaceCurve(Ex),SegmentBinding(Float))->ThreeSpace(DoubleFloat)
params: pTopLevelDrawFunctions(Ex)
comment:
\spad{makeObject(curve(f(t),{} g(t),{} h(t)),{} t = a..b)} returns a space of the domain \spadtype{ThreeSpace} which contains the graph of the parametric curve \spad{x = f(t)},{} \spad{y = g(t)},{} \spad{z = h(t)} as \spad{t} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)}; \spad{h(t)} is the default title.


kind: o
name: makeObject
exposed: x
type: ((DoubleFloat,DoubleFloat)->DoubleFloat,Segment(Float),Segment(Float))->ThreeSpace(DoubleFloat)
params: pTopLevelDrawFunctionsForCompiledFunctions
comment:
\spad{makeObject(f,{} a..b,{} c..d)} returns a space of the domain \spadtype{ThreeSpace} which contains the graph of \spad{z = f(x,{} y)} as \spad{x} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)} and \spad{y} ranges from \spad{min(c,{} d)} to \spad{max(c,{} d)}.


kind: o
name: makeObject
exposed: x
params: pTopLevelDrawFunctionsForCompiledFunctions
type:
((DoubleFloat,DoubleFloat)->Point(DoubleFloat),Segment(Float),Segment(Float))->ThreeSpace(DoubleFloat)

comment:
\spad{makeObject(f,{} a..b,{} c..d,{} l)} returns a space of the domain \spadtype{ThreeSpace} which contains the graph of the parametric surface \spad{f(u,{} v)} as \spad{u} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)} and \spad{v} ranges from \spad{min(c,{} d)} to \spad{max(c,{} d)}.


kind: o
name: makeObject
exposed: x
type: ((DoubleFloat)->DoubleFloat,Segment(Float),List(DrawOption))->GraphImage
params: pTopLevelDrawFunctionsForCompiledFunctions
comment:
\spad{makeObject(f,{} a..b,{} l)} creates the graph of \spad{y = f(x)} as \spad{x} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)}. The options contained in the list \spad{l} of the domain \spad{DrawOption} are applied.


kind: o
name: makeObject
exposed: x
type: ((DoubleFloat)->Point(DoubleFloat),Segment(Float),List(DrawOption))->ThreeSpace(DoubleFloat)
params: pTopLevelDrawFunctionsForCompiledFunctions
comment:
\spad{makeObject(curve(f,{} g,{} h),{} a..b,{} l)} returns a space of the domain \spadtype{ThreeSpace} which contains the graph of the parametric curve \spad{x = f(t),{} y = g(t),{} z = h(t)} as \spad{t} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)}. The options contained in the list \spad{l} of the domain \spad{DrawOption} are applied.


kind: o
name: makeObject
exposed: x
type: (Ex,SegmentBinding(Float),List(DrawOption))->GraphImage
params: pTopLevelDrawFunctions(Ex)
comment:
\spad{makeObject(f(x),{} x = a..b,{} l)} creates the graph of \spad{y = f(x)} as \spad{x} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)}; the options contained in the list \spad{l} of the domain \spad{DrawOption} are applied.


kind: o
name: makeObject
exposed: x
type: (Ex,SegmentBinding(Float),SegmentBinding(Float))->ThreeSpace(DoubleFloat)
params: pTopLevelDrawFunctions(Ex)
comment:
\spad{makeObject(f(x,{} y),{} x = a..b,{} y = c..d)} returns a space of the domain \spadtype{ThreeSpace} which contains the graph of \spad{z = f(x,{} y)} as \spad{x} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)} and \spad{y} ranges from \spad{min(c,{} d)} to \spad{max(c,{} d)}; \spad{f(x,{} y)} appears as the default title.


kind: o
name: makeObject
exposed: x
type: (ParametricPlaneCurve((DoubleFloat)->DoubleFloat),Segment(Float),List(DrawOption))->GraphImage
params: pTopLevelDrawFunctionsForCompiledFunctions
comment:
\spad{makeObject(curve(f,{} g),{} a..b,{} l)} creates the graph of the parametric curve \spad{x = f(t),{} y = g(t)} as \spad{t} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)}. The options contained in the list \spad{l} of the domain \spad{DrawOption} are applied.


kind: o
name: makeObject
exposed: x
type: (ParametricPlaneCurve(Ex),SegmentBinding(Float),List(DrawOption))->GraphImage
params: pTopLevelDrawFunctions(Ex)
comment:
\spad{makeObject(curve(f(t),{} g(t)),{} t = a..b,{} l)} creates the graph of the parametric curve \spad{x = f(t),{} y = g(t)} as \spad{t} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)}; the options contained in the list \spad{l} of the domain \spad{DrawOption} are applied.


kind: o
name: makeObject
exposed: x
params: pTopLevelDrawFunctionsForCompiledFunctions
type:
(ParametricSpaceCurve((DoubleFloat)->DoubleFloat),Segment(Float),List(DrawOption))->ThreeSpace(DoubleFloat)

comment:
\spad{makeObject(curve(f,{} g,{} h),{} a..b,{} l)} returns a space of the domain \spadtype{ThreeSpace} which contains the graph of the parametric curve \spad{x = f(t),{} y = g(t),{} z = h(t)} as \spad{t} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)}; The options contained in the list \spad{l} of the domain \spad{DrawOption} are applied.


kind: o
name: makeObject
exposed: x
type: (ParametricSpaceCurve(Ex),SegmentBinding(Float),List(DrawOption))->ThreeSpace(DoubleFloat)
params: pTopLevelDrawFunctions(Ex)
comment:
\spad{makeObject(curve(f(t),{} g(t),{} h(t)),{} t = a..b,{} l)} returns a space of the domain \spadtype{ThreeSpace} which contains the graph of the parametric curve \spad{x = f(t)},{} \spad{y = g(t)},{} \spad{z = h(t)} as \spad{t} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)}; \spad{h(t)} is the default title,{} and the options contained in the list \spad{l} of the domain \spad{DrawOption} are applied.


kind: o
name: makeObject
exposed: x
params: pTopLevelDrawFunctionsForCompiledFunctions
type:
(ParametricSurface((DoubleFloat,DoubleFloat)->DoubleFloat),Segment(Float),Segment(Float))->ThreeSpace(DoubleFloat)

comment:
\spad{makeObject(surface(f,{} g,{} h),{} a..b,{} c..d,{} l)} returns a space of the domain \spadtype{ThreeSpace} which contains the graph of the parametric surface \spad{x = f(u,{} v)},{} \spad{y = g(u,{} v)},{} \spad{z = h(u,{} v)} as \spad{u} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)} and \spad{v} ranges from \spad{min(c,{} d)} to \spad{max(c,{} d)}.


kind: o
name: makeObject
exposed: x
type: (ParametricSurface(Ex),SegmentBinding(Float),SegmentBinding(Float))->ThreeSpace(DoubleFloat)
params: pTopLevelDrawFunctions(Ex)
comment:
\spad{makeObject(surface(f(u,{} v),{} g(u,{} v),{} h(u,{} v)),{} u = a..b,{} v = c..d)} returns a space of the domain \spadtype{ThreeSpace} which contains the graph of the parametric surface \spad{x = f(u,{} v)},{} \spad{y = g(u,{} v)},{} \spad{z = h(u,{} v)} as \spad{u} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)} and \spad{v} ranges from \spad{min(c,{} d)} to \spad{max(c,{} d)}; \spad{h(t)} is the default title.


kind: o
name: makeObject
exposed: x
params: pTopLevelDrawFunctionsForCompiledFunctions
type:
((DoubleFloat,DoubleFloat)->DoubleFloat,Segment(Float),Segment(Float),List(DrawOption))->ThreeSpace(DoubleFloat)

comment:
\spad{makeObject(f,{} a..b,{} c..d,{} l)} returns a space of the domain \spadtype{ThreeSpace} which contains the graph of \spad{z = f(x,{} y)} as \spad{x} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)} and \spad{y} ranges from \spad{min(c,{} d)} to \spad{max(c,{} d)},{} and the options contained in the list \spad{l} of the domain \spad{DrawOption} are applied.


kind: o
name: makeObject
exposed: x
params: pTopLevelDrawFunctionsForCompiledFunctions
type:
((DoubleFloat,DoubleFloat)->Point(DoubleFloat),Segment(Float),Segment(Float),List(DrawOption))->ThreeSpace(DoubleFloat)

comment:
\spad{makeObject(f,{} a..b,{} c..d,{} l)} returns a space of the domain \spadtype{ThreeSpace} which contains the graph of the parametric surface \spad{f(u,{} v)} as \spad{u} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)} and \spad{v} ranges from \spad{min(c,{} d)} to \spad{max(c,{} d)}; The options contained in the list \spad{l} of the domain \spad{DrawOption} are applied.


kind: o
name: makeObject
exposed: x
type: (Equation(Ex),Symbol,Symbol,List(DrawOption))->GraphImage
params: pTopLevelDrawFunctionsForAlgebraicCurves(R,Ex)
comment:
\spad{makeObject(f(x,{} y) = g(x,{} y),{} x,{} y,{} l)} creates the graph of a polynomial equation. The list \spad{l} of draw options must specify a region in the plane in which the curve is to sketched.


kind: o
name: makeObject
exposed: x
type: (Ex,SegmentBinding(Float),SegmentBinding(Float),List(DrawOption))->ThreeSpace(DoubleFloat)
params: pTopLevelDrawFunctions(Ex)
comment:
\spad{makeObject(f(x,{} y),{} x = a..b,{} y = c..d,{} l)} returns a space of the domain \spadtype{ThreeSpace} which contains the graph of \spad{z = f(x,{} y)} as \spad{x} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)} and \spad{y} ranges from \spad{min(c,{} d)} to \spad{max(c,{} d)}; \spad{f(x,{} y)} is the default title,{} and the options contained in the list \spad{l} of the domain \spad{DrawOption} are applied.


kind: o
name: makeObject
exposed: x
params: pTopLevelDrawFunctionsForCompiledFunctions
type:
(ParametricSurface((DoubleFloat,DoubleFloat)->DoubleFloat),Segment(Float),Segment(Float),List(DrawOption))->ThreeSpace(DoubleFloat)

comment:
\spad{makeObject(surface(f,{} g,{} h),{} a..b,{} c..d,{} l)} returns a space of the domain \spadtype{ThreeSpace} which contains the graph of the parametric surface \spad{x = f(u,{} v)},{} \spad{y = g(u,{} v)},{} \spad{z = h(u,{} v)} as \spad{u} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)} and \spad{v} ranges from \spad{min(c,{} d)} to \spad{max(c,{} d)}. The options contained in the list \spad{l} of the domain \spad{DrawOption} are applied.


kind: o
name: makeObject
exposed: x
params: pTopLevelDrawFunctions(Ex)
type:
(ParametricSurface(Ex),SegmentBinding(Float),SegmentBinding(Float),List(DrawOption))->ThreeSpace(DoubleFloat)

comment:
\spad{makeObject(surface(f(u,{} v),{} g(u,{} v),{} h(u,{} v)),{} u = a..b,{} v = c..d,{} l)} returns a space of the domain \spadtype{ThreeSpace} which contains the graph of the parametric surface \spad{x = f(u,{} v)},{} \spad{y = g(u,{} v)},{} \spad{z = h(u,{} v)} as \spad{u} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)} and \spad{v} ranges from \spad{min(c,{} d)} to \spad{max(c,{} d)}; \spad{h(t)} is the default title,{} and the options contained in the list \spad{l} of the domain \spad{DrawOption} are applied.


kind: o
name: make_real_part_function
exposed: x
type: (S,Symbol)->(DoubleFloat)->DoubleFloat
params: pMakeFloatCompiledFunction(S)
comment:
\spad{make_real_part_function(expr,{} x)} returns a Lisp function \spad{f}: \spadtype{DoubleFloat} \spad{->} \spadtype{DoubleFloat} defined by \spad{f(x) == real(expr)}. Function \spad{f} is compiled and directly applicable to objects of type \spadtype{DoubleFloat}.


kind: o
name: makeRec
exposed: n
type: (BasicOperator,Symbol,F,List(F),Stream(F))->F
params: pRecurrenceOperator(R,F)
comment:
\spad{makeRec(u,{} n,{} eq,{} parameters,{} values)} creates an expression that stands for \spad{u}(\spad{n}),{} where \spad{u}(\spad{n}) is given by the equation \spad{eq}. The argument \spad{parameters} has to contain all variables (or kernels) that appear eventually in the stream of values. The argument values specifies the initial values of the recurrence \spad{u}(0),{} \spad{u}(1),{} ... For the moment we don\spad{'t} allow recursions that contain \spad{u} inside of another operator.


kind: o
name: makeRecord
exposed: x
type: (S,T)->Record(part1:S,part2:T)
params: pMakeRecord(S,T)
comment:
\spad{makeRecord(a,{} b)} creates a record object with type Record(\spad{part1} : \spad{S},{} \spad{part2} : \spad{T}),{} where \spad{part1} is \spad{a} and \spad{part2} is \spad{b}.


kind: o
name: makeSeries
exposed: n
type: (Reference(OrderedCompletion(Integer)),Stream(Record(k:Integer,c:Coef)))->%
params: dInnerSparseUnivariatePowerSeries(Coef)
comment:
\spad{makeSeries(refer,{} str)} creates a power series from the reference \spad{refer} and the stream \spad{str}.


kind: o
name: makeSketch
exposed: n
type: (Polynomial(Integer),Symbol,Symbol,Segment(Fraction(Integer)),Segment(Fraction(Integer)))->%
params: dPlaneAlgebraicCurvePlot
comment:
\spad{makeSketch(p,{} x,{} y,{} a..b,{} c..d)} creates an ACPLOT of the curve \spad{p = 0} in the region {\em a <= x <= b,{} c <= y <= d}. More specifically,{} 'makeSketch' plots a non-singular algebraic curve \spad{p = 0} in an rectangular region {\em xMin <= x <= xMax},{} {\em yMin <= y <= yMax}. The user inputs \spad{makeSketch(p,{} x,{} y,{} xMin..xMax,{} yMin..yMax)}. Here \spad{p} is a polynomial in the variables \spad{x} and \spad{y} with integer coefficients (\spad{p} belongs to the domain \spad{Polynomial Integer}). The case where \spad{p} is a polynomial in only one of the variables is allowed. The variables \spad{x} and \spad{y} are input to specify the the coordinate axes. The horizontal axis is the \spad{x}-axis and the vertical axis is the \spad{y}-axis. The rational numbers xMin,{} ...,{} yMax specify the boundaries of the region in which the curve is to be plotted.


kind: o
name: makeSUP
exposed: x
type: (%)->SparseUnivariatePolynomial(R)
params: cUnivariatePolynomialCategory(R)
comment:
\spad{makeSUP(p)} converts the polynomial \spad{p} to be of type SparseUnivariatePolynomial over the same coefficients.


kind: o
name: makeTerm
exposed: n
type: (S,E)->%
params: dListMonoidOps(S,E,un)
comment:
\spad{makeTerm(s,{} e)} returns the monomial \spad{s} exponentiated by \spad{e} (\spadignore{e.g.} s^e or \spad{e} * \spad{s}).


kind: o
name: makeVariable
exposed: x
type: (%)->(NonNegativeInteger)->%
params: cDifferentialPolynomialCategory(R,S,V,E)
abbrev: has(R,DifferentialRing)
comment:
\spad{makeVariable(p)} views \spad{p} as an element of a differential ring,{} in such a way that the \spad{n}-th derivative of \spad{p} may be simply referenced as \spad{z}.\spad{n} where \spad{z} \spad{:=} makeVariable(\spad{p}). Note: In the interpreter,{} \spad{z} is given as an internal map,{} which may be ignored.


kind: o
name: makeVariable
exposed: x
type: (S)->(NonNegativeInteger)->%
params: cDifferentialPolynomialCategory(R,S,V,E)
comment:
\spad{makeVariable(s)} views \spad{s} as a differential indeterminate,{} in such a way that the \spad{n}-th derivative of \spad{s} may be simply referenced as \spad{z}.\spad{n} where \spad{z} \spad{:=} makeVariable(\spad{s}). Note: In the interpreter,{} \spad{z} is given as an internal map,{} which may be ignored.


kind: o
name: makeVariable
exposed: x
type: (S,NonNegativeInteger)->%
params: cDifferentialVariableCategory(S)
comment:
\spad{makeVariable(s,{} n)} returns the \spad{n}-th derivative of a differential indeterminate \spad{s} as an algebraic indeterminate.


kind: o
name: makeViewport2D
exposed: n
type: (%)->%
params: dTwoDimensionalViewport
comment:
\spad{makeViewport2D(v)} takes the given two-dimensional viewport,{} \spad{v},{} of the domain \spadtype{TwoDimensionalViewport} and displays a viewport window on the screen which contains the contents of \spad{v}.


kind: o
name: makeViewport2D
exposed: n
type: (GraphImage,List(DrawOption))->%
params: dTwoDimensionalViewport
comment:
\spad{makeViewport2D(\spad{gi},{} lopt)} creates and displays a viewport window of the domain \spadtype{TwoDimensionalViewport} whose graph field is assigned to be the given graph,{} \spad{\spad{gi}},{} of domain \spadtype{GraphImage},{} and whose options field is set to be the list of options,{} \spad{lopt} of domain \spadtype{DrawOption}.


kind: o
name: makeViewport3D
exposed: x
type: (%)->%
params: dThreeDimensionalViewport
comment:
\spad{makeViewport3D(v)} takes the given three-dimensional viewport,{} \spad{v},{} of the domain \spadtype{ThreeDimensionalViewport} and displays a viewport window on the screen which contains the contents of \spad{v}.


kind: o
name: makeViewport3D
exposed: x
type: (ThreeSpace(DoubleFloat),List(DrawOption))->%
params: dThreeDimensionalViewport
comment:
\spad{makeViewport3D(sp,{} lopt)} takes the given space,{} \spad{sp} which is of the domain \spadtype{ThreeSpace} and displays a viewport window on the screen which contains the contents of \spad{sp},{} and whose draw options are indicated by the list \spad{lopt},{} which is a list of options from the domain \spad{DrawOption}.


kind: o
name: makeViewport3D
exposed: x
type: (ThreeSpace(DoubleFloat),String)->%
params: dThreeDimensionalViewport
comment:
\spad{makeViewport3D(sp,{} s)} takes the given space,{} \spad{sp} which is of the domain \spadtype{ThreeSpace} and displays a viewport window on the screen which contains the contents of \spad{sp},{} and whose title is given by \spad{s}.


kind: o
name: makeYoungTableau
exposed: x
type: (List(Integer),List(Integer))->Matrix(Integer)
params: pSymmetricGroupCombinatoricFunctions
comment:
\spad{makeYoungTableau(lambda,{} gitter)} computes for a given lattice permutation {\em gitter} and for an improper partition {\em lambda} the corresponding standard tableau of shape {\em lambda}. Notes: see {\em listYoungTableaus}. The entries are from {\em 0,{} ...,{} n-1}.


kind: o
name: map
exposed: n
type: ((A)->A,%)->%
params: cIndexedProductCategory(A,S)
comment:
\spad{map(f,{} z)} returns the new element created by applying the function \spad{f} to each component of the direct product element \spad{z}.


kind: o
name: map
exposed: n
type: ((A)->B,MA)->MB
params: pTwoDimensionalArrayFunctions(A,RA,CA,MA,B,RB,CB,MB)
comment:
\spad{map(f,{} m)} applies the function \spad{f} to every element of the array \spad{m} producing a new array containing the values.


kind: o
name: map
exposed: n
type: ((Expression(CoefRing))->Expression(CoefRing),%)->%
params: dDeRhamComplex(CoefRing,listIndVar)
comment:
\spad{map(f,{} df)} replaces each coefficient \spad{x} of differential form \spad{df} by \spad{f(x)}.


kind: o
name: map
exposed: n
params: dFakePolynomial
type:
((Polynomial(Integer))->Polynomial(Integer),Record(var:Symbol,coef:SparseUnivariatePolynomial(Fraction(Polynomial(Integer)))))->%


kind: o
name: map
exposed: n
type: ((R1)->R2,A1)->A2
params: pFiniteAbelianMonoidRingFunctions2(E,R1,A1,R2,A2)
comment:
\spad{map}(\spad{f},{} a) applies the map \spad{f} to each coefficient in a. It is assumed that \spad{f} maps 0 to 0


kind: o
name: map
exposed: n
params: dFakePolynomial
type:
((Record(numer:Polynomial(Integer),denom:Polynomial(Integer)))->Union(Polynomial(Integer),failed),%)->Union(SparseUnivariatePolynomial(Polynomial(Integer)),failed)


kind: o
name: map
exposed: n
type: ((R)->S,NewSparseUnivariatePolynomial(R))->NewSparseUnivariatePolynomial(S)
params: pNewSparseUnivariatePolynomialFunctions2(R,S)
comment:
\spad{map(func,{} poly)} creates a new polynomial by applying \spad{func} to every non-zero coefficient of the polynomial poly.


kind: o
name: map
exposed: x
type: ((A)->B,DirectProduct(dim,A))->DirectProduct(dim,B)
params: pDirectProductFunctions2(dim,A,B)
comment:
\spad{map(f,{} v)} applies the function \spad{f} to every element of the vector \spad{v} producing a new vector containing the values.


kind: o
name: map
exposed: x
type: ((A)->B,Fraction(A))->Fraction(B)
params: pFractionFunctions2(A,B)
comment:
\spad{map(func,{} frac)} applies the function \spad{func} to the numerator and denominator of the fraction frac.


kind: o
name: map
exposed: x
type: ((A)->B,List(A))->List(B)
params: pListFunctions2(A,B)
comment:
\spad{map(fn,{} u)} applies \spad{fn} to each element of list \spad{u} and returns a new list with the results. For example \spad{map(square,{} [1,{} 2,{} 3]) = [1,{} 4,{} 9]}.


kind: o
name: map
exposed: x
type: ((A)->B,OneDimensionalArray(A))->OneDimensionalArray(B)
params: pOneDimensionalArrayFunctions2(A,B)
comment:
\spad{map(f,{} a)} applies function \spad{f} to each member of one-dimensional array \spad{a} resulting in a new one-dimensional array over a possibly different underlying domain.


kind: o
name: map
exposed: x
type: ((A)->B,PatternMatchResult(R,A))->PatternMatchResult(R,B)
params: pPatternMatchResultFunctions2(R,A,B)
comment:
\spad{map(f,{} [(v1,{} a1),{} ...,{} (vn,{} an)])} returns the matching result [(\spad{v1},{} \spad{f}(\spad{a1})),{} ...,{} (\spad{vn},{} \spad{f}(an))].


kind: o
name: map
exposed: x
type: ((A)->B,PrimitiveArray(A))->PrimitiveArray(B)
params: pPrimitiveArrayFunctions2(A,B)
comment:
\spad{map(f,{} a)} applies function \spad{f} to each member of primitive array \spad{a} resulting in a new primitive array over a possibly different underlying domain.


kind: o
name: map
exposed: x
type: ((A)->B,Stream(A))->Stream(B)
params: pStreamFunctions2(A,B)
comment:
\spad{map(f,{} s)} returns a stream whose elements are the function \spad{f} applied to the corresponding elements of \spad{s}. Note: \spad{map(f,{} [x0,{} x1,{} x2,{} ...]) = [f(x0),{} f(x1),{} f(x2),{} ..]}.


kind: o
name: map
exposed: x
type: ((A)->Union(B,failed),Vector(A))->Union(Vector(B),failed)
params: pVectorFunctions2(A,B)
comment:
\spad{map(f,{} v)} applies the function \spad{f} to every element of the vector \spad{v} producing a new vector containing the values or \spad{failed}.


kind: o
name: map
exposed: x
type: ((Coef1)->Coef2,UnivariateLaurentSeries(Coef1,var1,cen1))->UnivariateLaurentSeries(Coef2,var2,cen2)
params: pUnivariateLaurentSeriesFunctions2(Coef1,Coef2,var1,var2,cen1,cen2)
comment:
\spad{map(f,{} g(x))} applies the map \spad{f} to the coefficients of the Laurent series \spad{g(x)}.


kind: o
name: map
exposed: x
type: ((Coef1)->Coef2,UnivariatePuiseuxSeries(Coef1,var1,cen1))->UnivariatePuiseuxSeries(Coef2,var2,cen2)
params: pUnivariatePuiseuxSeriesFunctions2(Coef1,Coef2,var1,var2,cen1,cen2)
comment:
\spad{map(f,{} g(x))} applies the map \spad{f} to the coefficients of the Puiseux series \spad{g(x)}.


kind: o
name: map
exposed: x
type: ((Coef1)->Coef2,UTS1)->UTS2
params: pUnivariateTaylorSeriesFunctions2(Coef1,Coef2,UTS1,UTS2)
comment:
\spad{map(f,{} g(x))} applies the map \spad{f} to the coefficients of \indented{1}{the Taylor series \spad{g(x)}.}


kind: o
name: map
exposed: x
type: ((E)->F,Kernel(E))->F
params: pExpressionSpaceFunctions2(E,F)
comment:
\spad{map(f,{} k)} returns \spad{g = op(f(a1),{} ...,{} f(an))} where \spad{k = op(a1,{} ...,{} an)}.


kind: o
name: map
exposed: x
params: pIntegrationResultFunctions2(E,F)
comment: \spad{map(f,{} ufe)} \undocumented
type:
((E)->F,Union(Record(mainpart:E,limitedlogs:List(Record(coeff:E,logand:E))),failed))->Union(Record(mainpart:F,limitedlogs:List(Record(coeff:F,logand:F))),failed)


kind: o
name: map
exposed: x
type: ((R)->R,%)->%
params: cRectangularMatrixCategory(m,n,R,Row,Col)
comment:
\spad{map(f,{} a)} returns \spad{b},{} where \spad{b(i,{} j) = a(i,{} j)} for all \spad{i},{} \spad{j}.


kind: o
name: map
exposed: x
type: ((R)->R,%)->%
params: dFactored(R)
comment:
\spad{map(fn,{} u)} maps the function \userfun{\spad{fn}} across the factors of \spadvar{\spad{u}} and creates a new factored object. Note: this clears the information flags (sets them to nil) because the effect of \userfun{\spad{fn}} is clearly not known in general.


kind: o
name: map
exposed: x
type: ((R)->S,AR)->AS
params: pFramedNonAssociativeAlgebraFunctions2(AR,R,AS,S)
comment:
\spad{map(f,{} u)} maps \spad{f} onto the coordinates of \spad{u} to get an element in \spad{AS} via identification of the basis of \spad{AR} as beginning part of the basis of \spad{AS}.


kind: o
name: map
exposed: x
type: ((R)->S,Factored(R))->Factored(S)
params: pFactoredFunctions2(R,S)
comment:
\spad{map(fn,{} u)} is used to apply the function \userfun{\spad{fn}} to every factor of \spadvar{\spad{u}}. The new factored object will have all its information flags set to nil. This function is used,{} for example,{} to coerce every factor base to another type.


kind: o
name: map
exposed: x
type: ((R)->S,MonoidRing(R,M))->MonoidRing(S,M)
params: pMonoidRingFunctions2(R,S,M)
comment:
\spad{map(f,{} u)} maps \spad{f} onto the coefficients \spad{f} the element \spad{u} of the monoid ring to create an element of a monoid ring with the same monoid \spad{b}.


kind: o
name: map
exposed: x
type: ((R)->S,OnePointCompletion(R))->OnePointCompletion(S)
params: pOnePointCompletionFunctions2(R,S)
comment:
\spad{map(f,{} r)} lifts \spad{f} and applies it to \spad{r},{} assuming that \spad{f}(infinity) = infinity.


kind: o
name: map
exposed: x
type: ((R)->S,OrderedCompletion(R))->OrderedCompletion(S)
params: pOrderedCompletionFunctions2(R,S)
comment:
\spad{map(f,{} r)} lifts \spad{f} and applies it to \spad{r},{} assuming that \spad{f}(plusInfinity) = plusInfinity and that \spad{f}(minusInfinity) = minusInfinity.


kind: o
name: map
exposed: x
type: ((R)->S,Pattern(R))->Pattern(S)
params: pPatternFunctions2(R,S)
comment:
\spad{map(f,{} p)} applies \spad{f} to all the leaves of \spad{p} and returns the result as a pattern over \spad{S}.


kind: o
name: map
exposed: x
type: ((R)->S,Polynomial(R))->Polynomial(S)
params: pPolynomialFunctions2(R,S)
comment:
\spad{map(f,{} p)} produces a new polynomial as a result of applying the function \spad{f} to every coefficient of the polynomial \spad{p}.


kind: o
name: map
exposed: x
type: ((R)->S,PR)->PS
params: pUnivariatePolynomialCategoryFunctions2(R,PR,S,PS)
comment:
\spad{map(f,{} p)} takes a function \spad{f} from \spad{R} to \spad{S},{} and applies it to each (non-zero) coefficient of a polynomial \spad{p} over \spad{R},{} getting a new polynomial over \spad{S}. Note: since the map is not applied to zero elements,{} it may map zero to zero.


kind: o
name: map
exposed: x
type: ((R)->S,Segment(R))->List(S)
params: pSegmentFunctions2(R,S)
abbrev: has(R,OrderedRing)
comment:
\spad{map(f,{} s)} expands the segment \spad{s},{} applying \spad{f} to each value. For example,{} if \spad{s = l..h by k},{} then the list \spad{[f(l),{} f(l+k),{} ...,{} f(lN)]} is computed,{} where \spad{lN <= h < lN+k}.


kind: o
name: map
exposed: x
type: ((S)->R,A)->B
params: pFiniteLinearAggregateFunctions2(S,A,R,B)
comment:
\spad{map(f,{} a)} applies function \spad{f} to each member of aggregate \spad{a} resulting in a new aggregate over a possibly different underlying domain.


kind: o
name: map
exposed: x
type: ((S)->R,A)->B
params: pFiniteSetAggregateFunctions2(S,A,R,B)
comment:
\spad{map(f,{} a)} applies function \spad{f} to each member of aggregate \spad{a},{} creating a new aggregate with a possibly different underlying domain.


kind: o
name: map
exposed: x
type: ((S)->S,%)->%
params: cHomogeneousAggregate(S)
comment:
\spad{map(f,{} u)} returns a copy of \spad{u} with each element \spad{x} replaced by \spad{f}(\spad{x}). For collections,{} \spad{map(f,{} u) = [f(x) for x in u]}.


kind: o
name: map
exposed: x
type: ((S)->S,%)->L
params: cSegmentExpansionCategory(S,L)
comment:
\spad{map(f,{} l..h by k)} produces a value of type \spad{L} by applying \spad{f} to each of the successive elements of the segment,{} that is,{} \spad{[f(l),{} f(l+k),{} ...,{} f(lN)]},{} where \spad{lN <= h < lN+k}.


kind: o
name: map
exposed: x
type: ((S)->T,CartesianTensor(minix,dim,S))->CartesianTensor(minix,dim,T)
params: pCartesianTensorFunctions2(minix,dim,S,T)
comment:
\spad{map(f,{} ts)} does a componentwise conversion of the tensor \spad{ts} to a tensor with components of type \spad{T}.


kind: o
name: map
exposed: n
type: ((F)->S,Symbol,Kernel(F))->S
params: pExpressionSpaceFunctions1(F,S)
comment:
\spad{map(f,{} p,{} k)} uses the property \spad{p} of the operator of \spad{k},{} in order to lift \spad{f} and apply it to \spad{k}.


kind: o
name: map
exposed: n
type: ((Vars)->S,(R)->S,P)->S
params: pPolynomialCategoryLifting(E,Vars,R,P,S)
comment:
\spad{map(varmap,{} coefmap,{} p)} takes a \spad{varmap},{} a mapping from the variables of polynomial \spad{p} into \spad{S},{} \spad{coefmap},{} a mapping from coefficients of \spad{p} into \spad{S},{} and \spad{p},{} and produces a member of \spad{S} using the corresponding arithmetic in \spad{S}.


kind: o
name: map
exposed: x
type: ((A,B)->C,List(A),List(B))->List(C)
params: pListFunctions3(A,B,C)
comment:
\spad{map(fn,{} u1,{} u2)} applies the binary function \spad{fn} to corresponding elements of lists \spad{u1} and \spad{u2} and returns a list of the results (in the same order). Thus \spad{map(/,{} [1,{} 2,{} 3],{} [4,{} 5,{} 6]) = [1/4,{} 2/5,{} 1/2]}. The computation terminates when the end of either list is reached. That is,{} the length of the result list is equal to the minimum of the lengths of \spad{u1} and \spad{u2}.


kind: o
name: map
exposed: x
type: ((A,B)->C,Stream(A),Stream(B))->Stream(C)
params: pStreamFunctions3(A,B,C)
comment:
\spad{map(f,{} st1,{} st2)} returns the stream whose elements are the function \spad{f} applied to the corresponding elements of \spad{st1} and \spad{st2}. Note: \spad{map(f,{} [x0,{} x1,{} x2,{} ..],{} [y0,{} y1,{} y2,{} ..]) = [f(x0,{} y0),{} f(x1,{} y1),{} ..]}.


kind: o
name: map
exposed: x
type: ((Entry,Entry)->Entry,%,%)->%
params: cTableAggregate(Key,Entry)
comment:
\spad{map(fn,{} t1,{} t2)} creates a new table \spad{t} from given tables \spad{t1} and \spad{t2} with elements \spad{fn}(\spad{x},{} \spad{y}) where \spad{x} and \spad{y} are corresponding elements from \spad{t1} and \spad{t2} respectively.


kind: o
name: map
exposed: x
type: ((R,R)->R,%,%)->%
params: cRectangularMatrixCategory(m,n,R,Row,Col)
comment:
\spad{map(f,{} a,{} b)} returns \spad{c},{} where \spad{c} is such that \spad{c(i,{} j) = f(a(i,{} j),{} b(i,{} j))} for all \spad{i},{} \spad{j}.


kind: o
name: map
exposed: x
type: ((R,R)->R,%,%)->%
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{map(f,{} a,{} b)} returns \spad{c},{} where \spad{c(i,{} j) = f(a(i,{} j),{} b(i,{} j))} for all \spad{i,{} j}


kind: o
name: map
exposed: x
type: ((R)->S,OnePointCompletion(R),OnePointCompletion(S))->OnePointCompletion(S)
params: pOnePointCompletionFunctions2(R,S)
comment:
\spad{map(f,{} r,{} i)} lifts \spad{f} and applies it to \spad{r},{} assuming that \spad{f}(infinity) = \spad{i}.


kind: o
name: map
exposed: x
type: ((S,S)->S,%,%)->%
params: cLinearAggregate(S)
comment:
\spad{map(f,{} u,{} v)} returns a new aggregate \spad{w} with elements \spad{z = f(x,{} y)} for corresponding elements \spad{x} and \spad{y} from \spad{u} and \spad{v}. Note: \spad{w.i = f(u.i,{} v.i)}.


kind: o
name: map
exposed: x
type: ((R,R)->R,%,%,R)->%
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{map(f,{} a,{} b,{} r)} returns \spad{c},{} where \spad{c(i,{} j) = f(a(i,{} j),{} b(i,{} j))} when both \spad{a(i,{} j)} and \spad{b(i,{} j)} exist; else \spad{c(i,{} j) = f(r,{} b(i,{} j))} when \spad{a(i,{} j)} does not exist; else \spad{c(i,{} j) = f(a(i,{} j),{} r)} when \spad{b(i,{} j)} does not exist; otherwise \spad{c(i,{} j) = f(r,{} r)}.


kind: o
name: map
exposed: x
type: ((R)->S,OrderedCompletion(R),OrderedCompletion(S),OrderedCompletion(S))->OrderedCompletion(S)
params: pOrderedCompletionFunctions2(R,S)
comment:
\spad{map(f,{} r,{} p,{} m)} lifts \spad{f} and applies it to \spad{r},{} assuming that \spad{f}(plusInfinity) = \spad{p} and that \spad{f}(minusInfinity) = \spad{m}.


kind: o
name: map
exposed: n
type: (%,List(NonNegativeInteger),List(S),Integer,Integer)->%
params: cFiniteGraph(S)
comment:
\spad{map(s,{} m,{} newOb,{} offsetX,{} offsetY)} creates a new graph by mapping from this one \spad{newOb} should contain the new list of vertices. \spad{m} should contain a NNI value for each vertex,{} this is the new index into \spad{newOb}. It is allowed that \spad{newOb} may contain less objects than \spad{s} (for surjective mapping) or more objects than \spad{s} (for injective mapping)


kind: o
name: mapBivariate
exposed: n
type: ((K)->L,UP)->SparseUnivariatePolynomial(SparseUnivariatePolynomial(L))
params: pIntegralBasisPolynomialTools(K,R,UP,L)
comment:
\spad{mapBivariate(f,{} p(x,{} y))} applies the function \spad{f} to the coefficients of \spad{p(x,{} y)}.


kind: o
name: mapContra
exposed: n
type: (%,List(NonNegativeInteger),List(S),Integer,Integer)->%
params: cFiniteGraph(S)
comment:
\spad{mapContra(s,{} m,{} newOb,{} offsetX,{} offsetY)} is similar to map function but reverses the directions of the arrows


kind: o
name: mapDown!
exposed: x
type: (%,S,(S,S)->S)->%
params: dBalancedBinaryTree(S)
comment:
\spad{mapDown!(t,{}p,{}f)} returns \spad{t} after traversing \spad{t} in preorder (node then left then right) fashion replacing the successive interior nodes as follows. The root value \spad{x} is replaced by \spad{q} \spad{:=} \spad{f}(\spad{p},{} \spad{x}). The mapDown!(\spad{l},{} \spad{q},{} \spad{f}) and mapDown!(\spad{r},{} \spad{q},{} \spad{f}) are evaluated for the left and right subtrees \spad{l} and \spad{r} of \spad{t}.


kind: o
name: mapDown!
exposed: x
type: (%,S,(S,S,S)->List(S))->%
params: dBalancedBinaryTree(S)
comment:
\spad{mapDown!(t,{}p,{}f)} returns \spad{t} after traversing \spad{t} in preorder (node then left then right) fashion replacing the successive interior nodes as follows. Let \spad{l} and \spad{r} denote the left and right subtrees of \spad{t}. The root value \spad{x} of \spad{t} is replaced by \spad{p}. Then \spad{f}(value \spad{l},{} value \spad{r},{} \spad{p}),{} where \spad{l} and \spad{r} denote the left and right subtrees of \spad{t},{} is evaluated producing two values \spad{pl} and \spad{pr}. Then \spad{mapDown!(l,{} pl,{} f)} and \spad{mapDown!(l,{} pr,{} f)} are evaluated.


kind: o
name: mapExponents
exposed: x
type: ((E)->E,%)->%
params: cFiniteAbelianMonoidRing(R,E)
comment:
\spad{mapExponents(fn,{} u)} maps function \spad{fn} onto the exponents of the non-zero monomials of polynomial \spad{u}.


kind: o
name: mapMatrixIfCan
exposed: n
type: ((L)->Union(K,failed),Matrix(SparseUnivariatePolynomial(L)))->Union(Matrix(R),failed)
params: pIntegralBasisPolynomialTools(K,R,UP,L)
comment:
\spad{mapMatrixIfCan(f,{} mat)} applies the function \spad{f} to the coefficients of the entries of \spad{mat} if possible,{} and returns \spad{failed} otherwise.


kind: o
name: map_preserving
exposed: x
type: ((R)->S,Factored(R))->Factored(S)
params: pFactoredFunctions2(R,S)
comment:
\spad{map_preserving(fn,{} u)} is used to apply the function \userfun{\spad{fn}} to every factor of \spadvar{\spad{u}}. The new factored object will have the same flags as original.


kind: o
name: mapUnivariateIfCan
exposed: n
type: ((L)->Union(K,failed),SparseUnivariatePolynomial(L))->Union(R,failed)
params: pIntegralBasisPolynomialTools(K,R,UP,L)
comment:
\spad{mapUnivariateIfCan(f,{} p(x))} applies the function \spad{f} to the coefficients of \spad{p(x)},{} if possible,{} and returns \spad{failed} otherwise.


kind: o
name: mapUp!
exposed: x
type: (%,(S,S)->S)->S
params: dBalancedBinaryTree(S)
comment:
\spad{mapUp!(t,{}f)} traverses balanced binary tree \spad{t} in an endorder (left then right then node) fashion returning \spad{t} with the value at each successive interior node of \spad{t} replaced by \spad{f}(\spad{l},{} \spad{r}) where \spad{l} and \spad{r} are the values at the immediate left and right nodes.


kind: o
name: mapUp!
exposed: x
type: (%,%,(S,S,S,S)->S)->%
params: dBalancedBinaryTree(S)
comment:
\spad{mapUp!(t,{}t1,{}f)} traverses \spad{t} in an endorder (left then right then node) fashion returning \spad{t} with the value at each successive interior node of \spad{t} replaced by \spad{f}(\spad{l},{} \spad{r},{} \spad{l1},{} \spad{r1}) where \spad{l} and \spad{r} are the values at the immediate left and right nodes. Values \spad{l1} and \spad{r1} are values at the corresponding nodes of a balanced binary tree \spad{t1},{} of identical shape at \spad{t}.


kind: o
name: match
exposed: x
type: (List(A),List(B))->(A)->B
params: pListToMap(A,B)
comment:
\spad{match(la,{} lb)} creates a map with no default source or target values defined by lists \spad{la} and \spad{lb} of equal length. The target of a source value \spad{x} in \spad{la} is the value \spad{y} with the same index in \spad{lb}. Error: if \spad{la} and \spad{lb} are not of equal length. Note: when this map is applied,{} an error occurs when applied to a value missing from \spad{la}.


kind: o
name: match?
exposed: x
type: (%,%,Character)->Boolean
params: cStringAggregate
comment:
\spad{match?(s,{} t,{} c)} tests if \spad{s} matches \spad{t} except perhaps for multiple and consecutive occurrences of character \spad{c}. Typically \spad{c} is the blank character.


kind: o
name: match
exposed: x
type: (List(A),List(B),(A)->B)->(A)->B
params: pListToMap(A,B)
comment:
\spad{match(la,{} lb,{} f)} creates a map defined by lists \spad{la} and \spad{lb} of equal length. The target of a source value \spad{x} in \spad{la} is the value \spad{y} with the same index in \spad{lb}. Argument \spad{f} is used as the function to call when the given function argument is not in \spad{la}. The value returned is \spad{f} applied to that argument.


kind: o
name: match
exposed: x
type: (List(A),List(B),A)->B
params: pListToMap(A,B)
comment:
\spad{match(la,{} lb,{} a)} creates a map defined by lists \spad{la} and \spad{lb} of equal length,{} where \spad{a} is used as the default source value if the given one is not in \spad{la}. The target of a source value \spad{x} in \spad{la} is the value \spad{y} with the same index in \spad{lb}. Error: if \spad{la} and \spad{lb} are not of equal length.


kind: o
name: match
exposed: x
type: (List(A),List(B),B)->(A)->B
params: pListToMap(A,B)
comment:
\spad{match(la,{} lb,{} b)} creates a map defined by lists \spad{la} and \spad{lb} of equal length,{} where \spad{b} is used as the default target value if the given function argument is not in \spad{la}. The target of a source value \spad{x} in \spad{la} is the value \spad{y} with the same index in \spad{lb}. Error: if \spad{la} and \spad{lb} are not of equal length.


kind: o
name: match
exposed: x
type: (List(A),List(B),A,(A)->B)->B
params: pListToMap(A,B)
comment:
\spad{match(la,{} lb,{} a,{} f)} creates a map defined by lists \spad{la} and \spad{lb} of equal length,{} and applies this map to a. The target of a source value \spad{x} in \spad{la} is the value \spad{y} with the same index in \spad{lb}. Argument \spad{f} is a default function to call if a is not in \spad{la}. The value returned is then obtained by applying \spad{f} to argument a.


kind: o
name: match
exposed: x
type: (List(A),List(B),A,B)->B
params: pListToMap(A,B)
comment:
\spad{match(la,{} lb,{} a,{} b)} creates a map defined by lists \spad{la} and \spad{lb} of equal length,{} and applies this map to a. The target of a source value \spad{x} in \spad{la} is the value \spad{y} with the same index in \spad{lb}. Argument \spad{b} is the default target value if a is not in \spad{la}. Error: if \spad{la} and \spad{lb} are not of equal length.


kind: o
name: mathieu11
exposed: x
type: (List(Integer))->PermutationGroup(Integer)
params: pPermutationGroupExamples
comment:
\spad{mathieu11(\spad{li})} constructs the mathieu group acting on the 11 integers given in the list {\em \spad{li}}. Note: duplicates in the list will be removed. error,{} if {\em \spad{li}} has less or more than 11 different entries.


kind: o
name: mathieu12
exposed: x
type: (List(Integer))->PermutationGroup(Integer)
params: pPermutationGroupExamples
comment:
\spad{mathieu12(\spad{li})} constructs the mathieu group acting on the 12 integers given in the list {\em \spad{li}}. Note: duplicates in the list will be removed Error: if {\em \spad{li}} has less or more than 12 different entries.


kind: o
name: mathieu22
exposed: x
type: (List(Integer))->PermutationGroup(Integer)
params: pPermutationGroupExamples
comment:
\spad{mathieu22(\spad{li})} constructs the mathieu group acting on the 22 integers given in the list {\em \spad{li}}. Note: duplicates in the list will be removed. Error: if {\em \spad{li}} has less or more than 22 different entries.


kind: o
name: mathieu23
exposed: x
type: (List(Integer))->PermutationGroup(Integer)
params: pPermutationGroupExamples
comment:
\spad{mathieu23(\spad{li})} constructs the mathieu group acting on the 23 integers given in the list {\em \spad{li}}. Note: duplicates in the list will be removed. Error: if {\em \spad{li}} has less or more than 23 different entries.


kind: o
name: mathieu24
exposed: x
type: (List(Integer))->PermutationGroup(Integer)
params: pPermutationGroupExamples
comment:
\spad{mathieu24(\spad{li})} constructs the mathieu group acting on the 24 integers given in the list {\em \spad{li}}. Note: duplicates in the list will be removed. Error: if {\em \spad{li}} has less or more than 24 different entries.


kind: o
name: matrix
exposed: n
type: (List(List(%)))->%
params: dOutputForm
comment:
\spad{matrix(llf)} makes \spad{llf} (a list of lists of forms) into a form which displays as a matrix.


kind: o
name: matrix
exposed: x
type: (List(List(R)))->%
params: cMatrixCategory(R,Row,Col)
comment:
\spad{matrix(l)} converts the list of lists \spad{l} to a matrix,{} where the list of lists is viewed as a list of the rows of the matrix.


kind: o
name: matrix
exposed: n
type: (%,FreeMonoid(VAR))->Matrix(F)
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{matrix(f,{}m)} returns the coefficient matrix for the monomial \spad{m} of the ALS of \spad{f}.


kind: o
name: matrix
exposed: n
type: (String,String)->(Integer,List(OutputForm))->OutputBox
params: cFormatterCategory
comment:
\spad{matrix(left,{} right)} returns a handler that typesets a matrix with parentheses given by \spad{left} and right where rows are formatted using \spad{h}.


kind: o
name: matrix
exposed: x
type: (NonNegativeInteger,NonNegativeInteger,(Integer,Integer)->R)->%
params: cMatrixCategory(R,Row,Col)
comment:
\spad{matrix(n,{}m,{}f)} constructs an \spad{n * m} matrix with the \spad{(i,{}j)} entry equal to \spad{f(i,{}j)}.


kind: o
name: matrixGcd
exposed: n
type: (Matrix(R),R,NonNegativeInteger)->R
params: pIntegralBasisTools(R,UP,F)
comment:
\spad{matrixGcd(mat,{} sing,{} n)} is \spad{gcd(sing,{} g)} where \spad{g} is the \spad{gcd} of the entries of the \spad{n}-by-\spad{n} upper-triangular matrix \spad{mat}.


kind: o
name: max
exposed: n
type: (%)->NonNegativeInteger
params: cFiniteGraph(S)
comment:
\spad{max(s)} returns index of the vertex which can be reached from all other vertices. Gives 0 if no such node exists or if it is not unique,{} if there is a loop for instance.


kind: o
name: max
exposed: n
type: (%,%)->%
params: cSPointCategory
comment:
\spad{max(a,{} b)} returns a point whose value in each dimension is the maximum. So if a has the largest \spad{x} value and \spad{b} has the largest \spad{y} value then the result will combine these. This is useful for constructing boundary boxes around sets of points.


kind: o
name: max
exposed: n
type: (%,List(NonNegativeInteger))->NonNegativeInteger
params: cFiniteGraph(S)
comment:
\spad{max(s,{} sub)} returns index of the vertex which can be reached from a given subset of the vertices. Gives 0 if no such node exists or if it is not unique,{} if there is a loop for instance.


kind: o
name: max
exposed: x
type: ((S,S)->Boolean,%)->S
params: cHomogeneousAggregate(S)
abbrev: has(%,finiteAggregate)
comment:
\spad{max(p,{} u)} returns maximal element of \spad{u} with respect to total ordering predicate \spad{p}. Error if \spad{u} is empty.


kind: o
name: maxdeg
exposed: n
type: (%)->E
params: dXPolynomialRing(R,E)
comment:
\spad{maxdeg(p)} returns the greatest word occurring in the polynomial \spad{p} with a non-zero coefficient. An error is produced if \spad{p} is zero.


kind: o
name: maxDegree
exposed: x
type: (Union(NonNegativeInteger,arbitrary))->%
params: dGuessOption
comment:
\spad{maxDegree(d)} specifies the maximum degree of the coefficient polynomials in an algebraic differential equation or a recursion with polynomial coefficients. For rational functions with an exponential term,{} \spad{maxDegree} bounds the degree of the denominator polynomial. This option is expressed in the form \spad{maxDegree == d}.


kind: o
name: maxDerivative
exposed: x
type: (Union(NonNegativeInteger,arbitrary))->%
params: dGuessOption
comment:
\spad{maxDerivative(d)} specifies the maximum derivative in an algebraic differential equation. This option is expressed in the form \spad{maxDerivative == d}.


kind: o
name: maxIndex
exposed: x
type: (%)->Index
params: cIndexedAggregate(Index,Entry)
abbrev: has(Index,OrderedSet)
comment:
\spad{maxIndex(u)} returns the maximum index \spad{i} of aggregate \spad{u}. Note: in general,{} \spad{maxIndex(u) = reduce(max,{} indices u)}; for List,{} \spad{maxIndex(u) = \#u}.


kind: o
name: maxLevel
exposed: x
type: (Union(NonNegativeInteger,arbitrary))->%
params: dGuessOption
comment:
\spad{maxLevel(d)} specifies the maximum number of recursion levels operators guessProduct and guessSum will be applied. This option is expressed in the form spad{maxLevel \spad{==} \spad{d}}.


kind: o
name: maxMixedDegree
exposed: x
type: (NonNegativeInteger)->%
params: dGuessOption
comment:
\spad{maxMixedDegree(d)} specifies the maximum \spad{q}-degree of the coefficient polynomials in a recurrence with polynomial coefficients,{} in the case of mixed shifts. Although slightly inconsistent,{} maxMixedDegree(0) specifies that no mixed shifts are allowed. This option is expressed in the form \spad{maxMixedDegree == d}.


kind: o
name: maxPower
exposed: x
type: (Union(PositiveInteger,arbitrary))->%
params: dGuessOption
comment:
\spad{maxPower(d)} specifies the maximum degree in an algebraic differential equation. For example,{} the degree of (\spad{f}\spad{''})\spad{^3} \spad{f'} is 4. maxPower(\spad{-1}) specifies that the maximum exponent can be arbitrary. This option is expressed in the form \spad{maxPower == d}.


kind: o
name: maxrank
exposed: n
params: pParametricLinearEquations(R,Var,Expon,GR)
comment: \spad{maxrank(r)} returns the maximum rank in the list \spad{r} of regimes
type:
(List(Record(rank:NonNegativeInteger,eqns:List(Record(det:GR,rows:List(Integer),cols:List(Integer))),fgb:List(GR))))->NonNegativeInteger


kind: o
name: maxrow
exposed: n
params: pTableauxBumpers(S)
comment: \spad{maxrow(a,{} b,{} c,{} d,{} e)} is an auxiliary function for \spad{mr}
type:
(List(S),List(List(List(S))),List(List(S)),List(List(List(S))),List(List(List(S))),List(List(List(S))))->Record(f1:List(S),f2:List(List(List(S))),f3:List(List(S)),f4:List(List(List(S))))


kind: o
name: maxShift
exposed: x
type: (Union(NonNegativeInteger,arbitrary))->%
params: dGuessOption
comment:
\spad{maxShift(d)} specifies the maximum shift in a recurrence equation. This option is expressed in the form \spad{maxShift == d}.


kind: o
name: maxSubst
exposed: x
type: (Union(PositiveInteger,arbitrary))->%
params: dGuessOption
comment:
\spad{maxSubst(d)} specifies the maximum degree of the monomial substituted into the function we are looking for. That is,{} if \spad{maxSubst == d},{} we look for polynomials such that \$\spad{p}(\spad{f}(\spad{x}),{} \spad{f}(\spad{x^2}),{} ...,{} \spad{f}(\spad{x^d}))\spad{=0}\$. equation. This option is expressed in the form \spad{maxSubst == d}.


kind: o
name: mdeg
exposed: x
type: (%)->NonNegativeInteger
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{mdeg(p)} returns an error if \spad{p} is \spad{0},{} otherwise,{} if \spad{p} belongs to \spad{R} returns \spad{0},{} otherwise,{} returns the degree of \spad{p} in its main variable.


kind: o
name: meatAxe
exposed: x
type: (List(Matrix(R)))->List(List(Matrix(R)))
params: pRepresentationPackage2(R)
abbrev: AND(has(R,Field),has(R,Finite))
comment:
\spad{meatAxe(aG)} calls {\em meatAxe(aG,{} false,{} 25,{} 7)} returns a 2-list of representations as follows. All matrices of argument \spad{aG} are assumed to be square and of equal size. Then \spad{aG} generates a subalgebra,{} say \spad{A},{} of the algebra of all square matrices of dimension \spad{n}. {\em V R} is an A-module in the usual way. meatAxe(\spad{aG}) creates at most 25 random elements of the algebra,{} tests them for singularity. If singular,{} it tries at most 7 elements of its kernel to generate a proper submodule. If successful a list which contains first the list of the representations of the submodule,{} then a list of the representations of the factor module is returned. Otherwise,{} if we know that all the kernel is already scanned,{} Norton\spad{'s} irreducibility test can be used either to prove irreducibility or to find the splitting. Notes: the first 6 tries use Parker\spad{'s} fingerprints. Also,{} 7 covers the case of three-dimensional kernels over the field with 2 elements.


kind: o
name: meatAxe
exposed: x
type: (List(Matrix(R)),Boolean)->List(List(Matrix(R)))
params: pRepresentationPackage2(R)
abbrev: AND(has(R,Field),has(R,Finite))
comment:
\spad{meatAxe(aG,{} randomElements)} calls {\em meatAxe(aG,{} false,{} 6,{} 7)},{} only using Parker\spad{'s} fingerprints,{} if {\em randomElemnts} is \spad{false}. If it is \spad{true},{} it calls {\em meatAxe(aG,{} true,{} 25,{} 7)},{} only using random elements. Note: the choice of 25 was rather arbitrary. Also,{} 7 covers the case of three-dimensional kernels over the field with 2 elements.


kind: o
name: meatAxe
exposed: x
type: (List(Matrix(R)),PositiveInteger)->List(List(Matrix(R)))
params: pRepresentationPackage2(R)
abbrev: AND(has(R,Field),has(R,Finite))
comment:
\spad{meatAxe(aG,{} numberOfTries)} calls {\em meatAxe(aG,{} true,{} numberOfTries,{} 7)}. Notes: 7 covers the case of three-dimensional kernels over the field with 2 elements.


kind: o
name: meatAxe
exposed: x
type: (List(Matrix(R)),Boolean,Integer,Integer)->List(List(Matrix(R)))
params: pRepresentationPackage2(R)
abbrev: AND(has(R,Field),has(R,Finite))
comment:
\spad{meatAxe(aG,{} randomElements,{} numberOfTries,{} maxTests)} returns a 2-list of representations as follows. All matrices of argument \spad{aG} are assumed to be square and of equal size. Then \spad{aG} generates a subalgebra,{} say \spad{A},{} of the algebra of all square matrices of dimension \spad{n}. {\em V R} is an A-module in the usual way. meatAxe(\spad{aG},{} \spad{numberOfTries},{} maxTests) creates at most {\em numberOfTries} random elements of the algebra,{} tests them for singularity. If singular,{} it tries at most {\em maxTests} elements of its kernel to generate a proper submodule. If successful,{} a 2-list is returned: first,{} a list containing first the list of the representations of the submodule,{} then a list of the representations of the factor module. Otherwise,{} if we know that all the kernel is already scanned,{} Norton\spad{'s} irreducibility test can be used either to prove irreducibility or to find the splitting. If {\em randomElements} is {\em false},{} the first 6 tries use Parker\spad{'s} fingerprints.


kind: o
name: medialSet
exposed: x
type: (List(P),(P,P)->Boolean,(P,P)->P)->Union(%,failed)
params: dWuWenTsunTriangularSet(R,E,V,P)
comment:
\spad{medialSet(ps,{} redOp?,{} redOp)} returns \spad{bs} a basic set (in Wu Wen Tsun sense \spad{w}.\spad{r}.\spad{t} the reduction-test \spad{redOp?}) of some set generating the same ideal as \spad{ps} (with rank not higher than any basic set of \spad{ps}),{} if no non-zero constant polynomials appear during the computations,{} else \spad{failed} is returned. In the former case,{} \spad{bs} has to be understood as a candidate for being a characteristic set of \spad{ps}. In the original algorithm,{} \spad{bs} is simply a basic set of \spad{ps}.


kind: o
name: meet
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger)->NonNegativeInteger
params: cCoDcpo(S)
comment:
returns the meet of 'a' and \spad{'b'} In this version of meet nodes are represented as index values. Not every poset will have a meet but CoDCPO will.


kind: o
name: meetIfCan
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger)->Union(NonNegativeInteger,failed)
params: cPoset(S)
comment:
\spad{meetIfCan(s,{} a,{} b)} returns the meet of 'a' and \spad{'b'} In this version of meet nodes are represented as index values. In the general case,{} not every poset will have a meet in which case failed will be returned as an error indication.


kind: o
name: member?
exposed: x
type: (Permutation(S),%)->Boolean
params: dPermutationGroup(S)
comment:
\spad{member?(pp,{} gp)} answers the question,{} whether the permutation {\em pp} is in the group {\em gp} or not.


kind: o
name: member?
exposed: x
type: (S,%)->Boolean
params: cHomogeneousAggregate(S)
abbrev: AND(has(%,finiteAggregate),has(S,BasicType))
comment:
\spad{member?(x,{} u)} tests if \spad{x} is a member of \spad{u}. For collections,{} \spad{member?(x,{} u) = reduce(or,{} [x=y for y in u],{} false)}. However,{} \spad{member?(x,{} u)} returns as soon as it finds a member.


kind: o
name: members
exposed: x
type: (%)->List(S)
params: cHomogeneousAggregate(S)
abbrev: has(%,finiteAggregate)
comment:
\spad{members(u)} returns a list of the consecutive elements of \spad{u}. For multisets \spadfun{members} gives result with no repetition. See also \spadfun{parts}.


kind: o
name: merge
exposed: x
type: (List(%))->%
params: cThreeSpaceCategory(R)
comment:
\spad{merge([s1,{} s2,{} ...,{} sn])} will create a new \spadtype{ThreeSpace} that has the components of all the ones in the list; Groupings of components into composites are maintained.


kind: o
name: merge2
exposed: n
params: pInnerModularHermitePade
type:
(Integer,List(Integer),List(Integer),Vector(Integer),SortedExponentVector,Vector(Integer),SortedExponentVector)->Record(offsetdata:Vector(Integer),expdata:SortedExponentVector)


kind: o
name: merge
exposed: n
type: (%,%)->%
params: cFiniteGraph(S)
comment:
\spad{merge(a,{} b)} returns sum : union (not necessarily disjoint) of nodes with arrows merged in from appropriate input,{} if arrow exists from both inputs then it will be duplicated.


kind: o
name: merge
exposed: x
type: (%,%)->%
params: cLinearAggregate(S)
abbrev: AND(has(%,finiteAggregate),has(S,OrderedSet))
comment:
\spad{merge(u,{} v)} merges \spad{u} and \spad{v} in ascending order. Note: \spad{merge(u,{} v) = merge(<=,{} u,{} v)}.


kind: o
name: merge
exposed: x
type: (%,%)->%
params: cPriorityQueueAggregate(S)
comment:
\spad{merge(q1,{} q2)} returns combines priority queues \spad{q1} and \spad{q2} to return a single priority queue \spad{q}.


kind: o
name: merge!
exposed: x
type: (%,%)->%
params: cPriorityQueueAggregate(S)
comment:
\spad{merge!(q,{} q1)} destructively changes priority queue \spad{q} to include the values from priority queue \spad{q1}.


kind: o
name: merge
exposed: x
type: (%,%)->%
params: cThreeSpaceCategory(R)
comment:
\spad{merge(s1,{} s2)} will create a new \spadtype{ThreeSpace} that has the components of \spad{s1} and \spad{s2}; Groupings of components into composites are maintained.


kind: o
name: merge
exposed: x
type: ((S,S)->Boolean,%,%)->%
params: cLinearAggregate(S)
abbrev: has(%,finiteAggregate)
comment:
\spad{merge(p,{} a,{} b)} returns an aggregate \spad{c} which merges \spad{a} and \spad{b}. The result is produced by examining each element \spad{x} of \spad{a} and \spad{y} of \spad{b} successively. If \spad{p(x,{} y)} is \spad{true},{} then \spad{x} is inserted into the result; otherwise \spad{y} is inserted. If \spad{x} is chosen,{} the next element of \spad{a} is examined,{} and so on. When all the elements of one aggregate are examined,{} the remaining elements of the other are appended. For example,{} \spad{merge(<,{} [1,{} 3],{} [2,{} 7,{} 5])} returns \spad{[1,{} 2,{} 3,{} 7,{} 5]}.


kind: o
name: mergeDifference
exposed: x
type: (List(S),List(S))->List(S)
params: pMergeThing(S)
comment:
\spad{mergeDifference(l1,{} l2)} returns a list of elements in \spad{l1} not present in \spad{l2}. Assumes lists are ordered and all \spad{x} in \spad{l2} are also in \spad{l1}.


kind: o
name: merge_exponents
exposed: n
params: pInnerModularHermitePade
type:
(Integer,Vector(Integer),SortedExponentVector,Vector(Integer),SortedExponentVector)->List(List(Integer))


kind: o
name: mergeFactors
exposed: x
type: (%,%)->%
params: dFactored(R)
comment:
\spad{mergeFactors(u,{} v)} is used when the factorizations of \spadvar{\spad{u}} and \spadvar{\spad{v}} are known to be disjoint,{} \spadignore{e.g.} resulting from a content/primitive part split. Essentially,{} it creates a new factored object by multiplying the units together and appending the lists of factors.


kind: o
name: mesh?
exposed: x
type: (%)->Boolean
params: cThreeSpaceCategory(R)
comment:
\spad{mesh?(s)} returns \spad{true} if the \spadtype{ThreeSpace} \spad{s} is composed of one component,{} a mesh comprising a list of curves which are lists of points,{} or returns \spad{false} if otherwise


kind: o
name: mesh
exposed: x
type: (List(List(Point(R))))->%
params: cThreeSpaceCategory(R)
comment:
\spad{mesh([[p0],{} [p1],{} ...,{} [pn]])} creates a surface defined by a list of curves which are lists,{} \spad{p0} through \spad{pn},{} of points,{} and returns a \spadtype{ThreeSpace} whose component is the surface.


kind: o
name: mesh
exposed: x
type: (%)->List(List(Point(R)))
params: cThreeSpaceCategory(R)
comment:
\spad{mesh(s)} checks to see if the \spadtype{ThreeSpace},{} \spad{s},{} is composed of a single surface component defined by a list curves which contain lists of points,{} and if so,{} returns the list of lists of points; An error is signaled otherwise.


kind: o
name: mesh
exposed: x
type: (List(List(Point(R))),Boolean,Boolean)->%
params: cThreeSpaceCategory(R)
comment:
\spad{mesh([[p0],{} [p1],{} ...,{} [pn]],{} close1,{} close2)} creates a surface defined over a list of curves,{} \spad{p0} through \spad{pn},{} which are lists of points; the booleans \spad{close1} and \spad{close2} indicate how the surface is to be closed: \spad{close1} set to \spad{true} means that each individual list (a curve) is to be closed (that is,{} the last point of the list is to be connected to the first point); \spad{close2} set to \spad{true} means that the boundary at one end of the surface is to be connected to the boundary at the other end (the boundaries are defined as the first list of points (curve) and the last list of points (curve)); the \spadtype{ThreeSpace} containing this surface is returned.


kind: o
name: mesh
exposed: x
type: (%,List(List(List(R))),Boolean,Boolean)->%
params: cThreeSpaceCategory(R)
comment:
\spad{mesh(s,{} [ [[r10]...,{} [r1m]],{} [[r20]...,{} [r2m]],{} ...,{} [[rn0]...,{} [rnm]] ],{} close1,{} close2)} adds a surface component to the \spadtype{ThreeSpace} \spad{s},{} which is defined over a rectangular domain of size \spad{WxH} where \spad{W} is the number of lists of points from the domain \spad{PointDomain(R)} and \spad{H} is the number of elements in each of those lists; the booleans \spad{close1} and \spad{close2} indicate how the surface is to be closed: if \spad{close1} is \spad{true} this means that each individual list (a curve) is to be closed (\spadignore{i.e.} the last point of the list is to be connected to the first point); if \spad{close2} is \spad{true},{} this means that the boundary at one end of the surface is to be connected to the boundary at the other end (the boundaries are defined as the first list of points (curve) and the last list of points (curve)).


kind: o
name: mesh
exposed: x
type: (%,List(List(List(R))),List(SubSpaceComponentProperty),SubSpaceComponentProperty)->%
params: cThreeSpaceCategory(R)
comment:
\spad{mesh(s,{} [ [[r10]...,{} [r1m]],{} [[r20]...,{} [r2m]],{} ...,{} [[rn0]...,{} [rnm]] ],{} [props],{} prop)} adds a surface component to the \spadtype{ThreeSpace} \spad{s},{} which is defined over a rectangular domain of size \spad{WxH} where \spad{W} is the number of lists of points from the domain \spad{PointDomain(R)} and \spad{H} is the number of elements in each of those lists; lprops is the list of the subspace component properties for each curve list,{} and prop is the subspace component property by which the points are defined.


kind: o
name: mesh
exposed: x
type: (%,List(List(Point(R))),Boolean,Boolean)->%
params: cThreeSpaceCategory(R)
comment:
\spad{mesh(s,{} [[p0],{} [p1],{} ...,{} [pn]],{} close1,{} close2)} adds a surface component to the \spadtype{ThreeSpace},{} which is defined over a list of curves,{} in which each of these curves is a list of points. The boolean arguments \spad{close1} and \spad{close2} indicate how the surface is to be closed. Argument \spad{close1} equal \spad{true} means that each individual list (a curve) is to be closed,{} \spadignore{i.e.} the last point of the list is to be connected to the first point. Argument \spad{close2} equal \spad{true} means that the boundary at one end of the surface is to be connected to the boundary at the other end,{} \spadignore{i.e.} the boundaries are defined as the first list of points (curve) and the last list of points (curve).


kind: o
name: mesh
exposed: x
type: (%,List(List(Point(R))),List(SubSpaceComponentProperty),SubSpaceComponentProperty)->%
params: cThreeSpaceCategory(R)
comment:
\spad{mesh(s,{} [[p0],{} [p1],{} ...,{} [pn]],{} [props],{} prop)} adds a surface component,{} defined over a list curves which contains lists of points,{} to the \spadtype{ThreeSpace} \spad{s}; props is a list which contains the subspace component properties for each surface parameter,{} and prop is the subspace component property by which the points are defined.


kind: o
name: meshFun2Var
exposed: n
params: pMeshCreationRoutinesForThreeDimensions
comment: \spad{meshFun2Var(f,{} g,{} s1,{} s2,{} l)} \undocumented
type:
((DoubleFloat,DoubleFloat)->DoubleFloat,Union((DoubleFloat,DoubleFloat,DoubleFloat)->DoubleFloat,undefined),Segment(DoubleFloat),Segment(DoubleFloat),List(DrawOption))->ThreeSpace(DoubleFloat)


kind: o
name: meshPar1Var
exposed: n
params: pMeshCreationRoutinesForThreeDimensions
comment: \spad{meshPar1Var(s,{} t,{} u,{} f,{} s1,{} l)} \undocumented
type:
(Expression(Integer),Expression(Integer),Expression(Integer),(DoubleFloat)->DoubleFloat,Segment(DoubleFloat),List(DrawOption))->ThreeSpace(DoubleFloat)


kind: o
name: meshPar2Var
exposed: n
params: pMeshCreationRoutinesForThreeDimensions
comment: \spad{meshPar2Var(f,{} s1,{} s2,{} l)} \undocumented
type:
((DoubleFloat,DoubleFloat)->Point(DoubleFloat),Segment(DoubleFloat),Segment(DoubleFloat),List(DrawOption))->ThreeSpace(DoubleFloat)


kind: o
name: meshPar2Var
exposed: n
params: pMeshCreationRoutinesForThreeDimensions
comment: \spad{meshPar2Var(sp,{} f,{} s1,{} s2,{} l)} \undocumented
type:
(ThreeSpace(DoubleFloat),(DoubleFloat,DoubleFloat)->Point(DoubleFloat),Segment(DoubleFloat),Segment(DoubleFloat),List(DrawOption))->ThreeSpace(DoubleFloat)


kind: o
name: meshPar2Var
exposed: n
params: pMeshCreationRoutinesForThreeDimensions
comment: \spad{meshPar2Var(f,{} g,{} h,{} j,{} s1,{} s2,{} l)} \undocumented
type:
((DoubleFloat,DoubleFloat)->DoubleFloat,(DoubleFloat,DoubleFloat)->DoubleFloat,(DoubleFloat,DoubleFloat)->DoubleFloat,Union((DoubleFloat,DoubleFloat,DoubleFloat)->DoubleFloat,undefined),Segment(DoubleFloat),Segment(DoubleFloat),List(DrawOption))->ThreeSpace(DoubleFloat)


kind: o
name: messagePrint
exposed: n
type: (String)->Void
params: dOutputForm
comment:
\spad{messagePrint(s)} prints \spad{s} without string quotes. Note: \spad{messagePrint(s)} is equivalent to \spad{print message(s)}.


kind: o
name: mfactor
exposed: n
type: (PA,MD)->List(PA)
params: pModularFactorizationGeneral(PA,MMT,MD,PMD,MO)
comment:
\spad{mfactor(pv,{} md)} computes factorization of \spad{pv} into irreducibles over field described by \spad{md}. \spad{pv} is assumed square-free and monic,{} \spad{md} is info representing finite field.


kind: o
name: min
exposed: n
type: (%)->NonNegativeInteger
params: cFiniteGraph(S)
comment:
\spad{min(s)} returns index of the vertex which can reach to all other vertices. Gives 0 if no such node exists or if it is not unique,{} if there is a loop for instance.


kind: o
name: min
exposed: n
type: (%,%)->%
params: cSPointCategory
comment:
\spad{min(a,{} b)} returns a point whose value in each dimension is the minimum. So if a has the smallest \spad{x} value and \spad{b} has the smallest \spad{y} value then the result will combine these. This is useful for constructing boundary boxes around sets of points.


kind: o
name: min
exposed: n
type: (%,List(NonNegativeInteger))->NonNegativeInteger
params: cFiniteGraph(S)
comment:
\spad{min(s,{} sub)} returns index of the vertex which can reach to a given subset of the vertices. Gives 0 if no such node exists or if it is not unique,{} if there is a loop for instance.


kind: o
name: mindeg
exposed: n
type: (%)->E
params: dXPolynomialRing(R,E)
comment:
\spad{mindeg(p)} returns the smallest word occurring in the polynomial \spad{p} with a non-zero coefficient. An error is produced if \spad{p} is zero.


kind: o
name: minimalMatrix
exposed: n
type: (Matrix(F),NonNegativeInteger)->Matrix(F)
params: pXDistributedPolynomialFunctions(VAR,F)
comment:
\spad{minimalMatrix(A,{}r)} returns the minimal (upper-left) submatrix of A such that the rank corresponds to the given.


kind: o
name: minimalPolynomial
exposed: n
type: (Vector(GF))->SparseUnivariatePolynomial(GF)
params: pInnerNormalBasisFieldFunctions(GF)
comment:
\spad{minimalPolynomial(x)} \undocumented{} See \spadfunFrom{minimalPolynomial}{FiniteAlgebraicExtensionField}


kind: o
name: minimalPolynomial
exposed: x
type: (%,PositiveInteger)->SparseUnivariatePolynomial(%)
params: cFiniteAlgebraicExtensionField(F)
abbrev: has(F,Finite)
comment:
\spad{minimalPolynomial(x,{} n)} computes the minimal polynomial of \spad{x} over the field of extension degree \spad{n} over the ground field \spad{F}.


kind: o
name: minimalRepresentation
exposed: n
params: pXDistributedPolynomialFunctions(VAR,F)
type:
(XDistributedPolynomial(VAR,F))->Record(alpha:Matrix(F),mu:List(Matrix(F)),var:List(VAR),beta:Matrix(F))

comment:
\spad{minimalRepresentation(p)} returns a minimal representation using the generalized Ho algorithm [Fornasini,{} 1978] \spad{p} = sum_w alpha*mu(\spad{w})*beta*w [Theorem 3.3,{} Salomaa--Soittola 1978]


kind: o
name: minimize
exposed: n
type: (%)->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{minimize(f)} minimizes the underlying ALS by applying left and right block minimization steps. Minimality is only guaranteed if the remaining blocks are refined.


kind: o
name: minimumDegree
exposed: x
type: (%)->E
params: cFiniteAbelianMonoidRing(R,E)
comment:
\spad{minimumDegree(p)} gives the least exponent of a non-zero term of polynomial \spad{p}. Error: if applied to 0.


kind: o
name: minimumDegree
exposed: x
type: (%,List(VarSet))->List(NonNegativeInteger)
params: cPolynomialCategory(R,E,VarSet)
comment:
\spad{minimumDegree(p,{} lv)} gives the list of minimum degrees of the polynomial \spad{p} with respect to each of the variables in the list \spad{lv}


kind: o
name: minimumDegree
exposed: x
type: (%,VarSet)->NonNegativeInteger
params: cPolynomialCategory(R,E,VarSet)
comment:
\spad{minimumDegree(p,{} v)} gives the minimum degree of polynomial \spad{p} with respect to \spad{v},{} \spadignore{i.e.} viewed a univariate polynomial in \spad{v}


kind: o
name: minIndex
exposed: x
type: (%)->Index
params: cIndexedAggregate(Index,Entry)
abbrev: has(Index,OrderedSet)
comment:
\spad{minIndex(u)} returns the minimum index \spad{i} of aggregate \spad{u}. Note: in general,{} \spad{minIndex(a) = reduce(min,{} indices a)}; for List,{} \spad{minIndex(a) = 1}.


kind: o
name: minordet
exposed: x
type: (M)->R
params: pMatrixLinearAlgebraFunctions(R,Row,Col,M)
comment:
\spad{minordet(m)} computes the determinant of the matrix \spad{m} using minors. Error: if the matrix is not square.


kind: o
name: minPol
exposed: n
params: pLinGroebnerPackage(lv,F)
comment: \spad{minPol }\undocumented
type:
(List(HomogeneousDistributedMultivariatePolynomial(lv,F)),OrderedVariableList(lv))->HomogeneousDistributedMultivariatePolynomial(lv,F)


kind: o
name: minPol
exposed: n
params: pLinGroebnerPackage(lv,F)
comment: \spad{minPol }\undocumented
type:
(List(HomogeneousDistributedMultivariatePolynomial(lv,F)),List(HomogeneousDistributedMultivariatePolynomial(lv,F)),OrderedVariableList(lv))->HomogeneousDistributedMultivariatePolynomial(lv,F)


kind: o
name: minset
exposed: n
type: (List(List(GR)))->List(List(GR))
params: pParametricLinearEquations(R,Var,Expon,GR)
comment:
\spad{minset(sl)} returns the sublist of \spad{sl} consisting of the minimal lists (with respect to inclusion) in the list \spad{sl} of lists


kind: o
name: minus!
exposed: n
type: (Matrix(R),Matrix(R))->Matrix(R)
params: pStorageEfficientMatrixOperations(R)
comment:
\spad{minus!(c,{} a)} computes \spad{-a} and stores the result in the matrix \spad{c}. Error: if a and \spad{c} do not have the same dimensions.


kind: o
name: minus
exposed: n
params: pFloatingPointOperations
comment: \spad{minus(x,{} y)} computes \spad{x - y} with no rounding.
type:
(Record(mantissa:Integer,exponent:Integer),Record(mantissa:Integer,exponent:Integer))->Record(mantissa:Integer,exponent:Integer)


kind: o
name: minus!
exposed: n
type: (Matrix(R),Matrix(R),Matrix(R))->Matrix(R)
params: pStorageEfficientMatrixOperations(R)
comment:
\spad{!minus!(c,{} a,{} b)} computes the matrix difference \spad{a - b} and stores the result in the matrix \spad{c}. Error: if \spad{a},{} \spad{b},{} and \spad{c} do not have the same dimensions.


kind: o
name: minus
exposed: n
params: pFloatElementaryFunctions
type:
(Record(mantissa:Integer,exponent:Integer),Record(mantissa:Integer,exponent:Integer),PositiveInteger)->Record(mantissa:Integer,exponent:Integer)

comment:
\spad{minus(x,{} y,{} b)} computes approximation to \spad{x - y} accurate to at least \spad{b} bits.


kind: o
name: m_inverse
exposed: n
params: dModularAlgebraicGcdTools3
type:
(Polynomial(Integer),List(Polynomial(Integer)),List(Symbol),Integer)->Union(Polynomial(Integer),failed)

comment:
\spad{m_inverse(x,{} lm,{} lv,{} p)} computes inverse of \spad{x} in algebraic extension defined by \spad{lm}.


kind: o
name: mirror
exposed: n
type: (%)->%
params: dFreeMagma(VarSet)
comment:
\spad{mirror(x)} returns the reversed word of \spad{x}. That is \spad{x} itself if \spadopFrom{retractable?}{FreeMagma}(\spad{x}) is \spad{true} and \spad{mirror(z) * mirror(y)} if \spad{x} is \spad{y*z}.


kind: o
name: mkAnswer
exposed: n
params: dIntegrationResult(F)
type:
(F,List(Record(scalar:Fraction(Integer),coeff:SparseUnivariatePolynomial(F),logand:SparseUnivariatePolynomial(F))),List(Record(integrand:F,intvar:F)))->%

comment:
\spad{mkAnswer(r,{} l,{} ne)} creates an integration result from a rational part \spad{r},{} a logarithmic part \spad{l},{} and a non-elementary part ne.


kind: o
name: mkIntegral
exposed: n
type: (UPUP)->Record(coef:Fraction(UP),poly:UPUP)
params: pChangeOfVariable(F,UP,UPUP)
comment:
\spad{mkIntegral(p(x,{} y))} returns \spad{[c(x),{} q(x,{} z)]} such that \spad{z = c * y} is integral. The algebraic relation between \spad{x} and \spad{y} is \spad{p(x,{} y) = 0}. The algebraic relation between \spad{x} and \spad{z} is \spad{q(x,{} z) = 0}.


kind: o
name: mkPrim
exposed: n
type: (F,Symbol)->F
params: pIntegrationTools(R,F)
abbrev: AND(has(R,GcdDomain),has(F,ElementaryFunctionCategory))
comment:
\spad{mkPrim(f,{} x)} makes the logs in \spad{f} which are linear in \spad{x} primitive with respect to \spad{x}.


kind: o
name: modifyPoint
exposed: n
type: (%,List(NonNegativeInteger),NonNegativeInteger)->%
params: dSubSpace(n,R)
comment:
\spad{modifyPoint(s,{} \spad{li},{} i)} replaces an existing point in the 3 dimensional subspace,{} \spad{s},{} with the 4 dimensional point indicated by the index location,{} \spad{i}. The list of non negative integers,{} \spad{li},{} dictates the path to follow,{} or,{} to look at it another way,{} points to the component in which the existing point is to be modified. An error message occurs if \spad{s} is empty,{} otherwise the subspace \spad{s} is returned with the point modification.


kind: o
name: modifyPoint
exposed: n
type: (%,List(NonNegativeInteger),Point(R))->%
params: dSubSpace(n,R)
comment:
\spad{modifyPoint(s,{} \spad{li},{} p)} replaces an existing point in the 3 dimensional subspace,{} \spad{s},{} with the 4 dimensional point,{} \spad{p}. The list of non negative integers,{} \spad{li},{} dictates the path to follow,{} or,{} to look at it another way,{} points to the component in which the existing point is to be modified. An error message occurs if \spad{s} is empty,{} otherwise the subspace \spad{s} is returned with the point modification.


kind: o
name: modifyPoint
exposed: n
type: (%,NonNegativeInteger,Point(R))->%
params: dSubSpace(n,R)
comment:
\spad{modifyPoint(s,{} ind,{} p)} modifies the point referenced by the index location,{} \spad{ind},{} by replacing it with the point,{} \spad{p} in the 3 dimensional subspace,{} \spad{s}. An error message occurs if \spad{s} is empty,{} otherwise the subspace \spad{s} is returned with the point modification.


kind: o
name: modifyPointData
exposed: x
type: (%,NonNegativeInteger,Point(DoubleFloat))->Void
params: dThreeDimensionalViewport
comment:
\spad{modifyPointData(v,{} ind,{} pt)} takes the viewport,{} \spad{v},{} which is of the domain \spadtype{ThreeDimensionalViewport},{} and places the data point,{} \spad{pt} into the list of points database of \spad{v} at the index location given by \spad{ind}.


kind: o
name: modifyPointData
exposed: x
type: (%,NonNegativeInteger,Point(R))->%
params: cThreeSpaceCategory(R)
comment:
\spad{modifyPointData(s,{} i,{} p)} changes the point at the indexed location \spad{i} in the \spadtype{ThreeSpace},{} \spad{s},{} to that of point \spad{p}. This is useful for making changes to a point which has been transformed.


kind: o
name: modpeval
exposed: n
type: (Polynomial(Integer),List(Symbol),List(Integer),Integer)->Integer
params: pPolynomialEvaluationUtilities
comment:
\spad{modpeval(pol,{} lv,{} lpt,{} p)} evaluates polynomial \spad{pol} in variables form \spad{lv} at point from \spad{lpt} modulo a prime \spad{p}


kind: o
name: modpreduction
exposed: n
params: pPolynomialEvaluationUtilities
comment: \spad{modpreduction(r,{} p)} reduces a rational function \spad{r} modulo prime \spad{p}.
type:
(Fraction(Polynomial(Integer)),Integer)->Union(Record(numer:Polynomial(Integer),denom:Polynomial(Integer)),failed)


kind: o
name: modular_compose
exposed: n
type: (PA,MMT,PA,NonNegativeInteger,PMD)->PA
params: cModularFactorizationOperations(PA,MMT,MD,PMD)
comment:
\spad{modular_compose(pol,{} pm,{} p1,{} l1,{} rd)} computes composion of \spad{pol} with \spad{p0} modulo reduction data \spad{rd}. \spad{pm} and \spad{p1} are as from call to \spad{power_matrix(p0,{} l1,{} rd)}.


kind: o
name: modularFactor
exposed: n
type: (UP,Set(NonNegativeInteger))->Record(prime:Integer,factors:List(UP))
params: pGaloisGroupFactorizer(UP)
comment:
\spad{modularFactor(f,{} d)} chooses a good prime and returns the factorization of \spad{f} modulo this prime in a form that may be used by \spadfunFrom{completeHensel}{GeneralHenselPackage}. If prime is zero it means that \spad{f} has been proved to be irreducible over the integers or that \spad{f} is a unit (\spadignore{i.e.} 1 or \spad{-1}). \spad{f} shall be primitive (\spadignore{i.e.} content(\spad{p})\spad{=1}) and square free (\spadignore{i.e.} without repeated factors). \spad{d} is set of possible degrees of factors.


kind: o
name: modularGcdPrimitive
exposed: n
type: (List(BP))->BP
params: pInnerModularGcd(R,BP,pMod,nextMod)
comment:
\spad{modularGcdPrimitive(listf)} computes the \spad{gcd} of the list of primitive polynomials \spad{listf} by modular methods.


kind: o
name: modularInvariantJ
exposed: x
type: (Complex(Float))->Complex(Float)
params: pFloatEllipticFunctions
comment:
\spad{modularInvariantJ(tau)} computes modular invariant \spad{j},{} that is \spad{1728*g2^3/(g2^3 - 27*g3^2)} where \spad{g2},{} \spad{g3} are invariants corresponding to half periods \spad{w1},{} \spad{w2} such that \spad{tau = w1/w2}.


kind: o
name: moduleSum
exposed: n
params: pIntegralBasisTools(R,UP,F)
type:
(Record(basis:Matrix(R),basisDen:R,basisInv:Matrix(R)),Record(basis:Matrix(R),basisDen:R,basisInv:Matrix(R)))->Record(basis:Matrix(R),basisDen:R,basisInv:Matrix(R))

comment:
\spad{moduleSum(m1,{} m2)} returns the sum of two modules in the framed algebra \spad{F}. Each module \spad{\spad{mi}} is represented as follows: \spad{F} is a framed algebra with \spad{R}-module basis \spad{w1,{} w2,{} ...,{} wn} and \spad{\spad{mi}} is a record \spad{[basis,{} basisDen,{} basisInv]}. If \spad{basis} is the matrix \spad{(aij,{} i = 1..n,{} j = 1..n)},{} then a basis \spad{v1,{} ...,{} vn} for \spad{\spad{mi}} is given by \spad{\spad{vi} = (1/basisDen) * sum(aij * wj,{} j = 1..n)},{} \spadignore{i.e.} the \spad{i}th row of 'basis' contains the coordinates of the \spad{i}th basis vector. Similarly,{} the \spad{i}th row of the matrix \spad{basisInv} contains the coordinates of \spad{\spad{wi}} with respect to the basis \spad{v1,{} ...,{} vn}: if \spad{basisInv} is the matrix \spad{(bij,{} i = 1..n,{} j = 1..n)},{} then \spad{\spad{wi} = sum(bij * vj,{} j = 1..n)}.


kind: o
name: moebius
exposed: n
type: (%)->IncidenceAlgebra(Integer,S)
params: cPoset(S)
comment:
\spad{moebius incidence} matrix for this poset This function is based on code by Franz Lehner. Notes by Martin Baker on the webpage here: \url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/moebius/}


kind: o
name: moebiusBand
exposed: n
type: ()->FiniteCubicalComplex(Integer)
params: pCubicalComplexFactory
comment:
Generate a cubical complex of the surface of a Moebius band. A one sided surface with a single external boundary line.


kind: o
name: moebiusBand
exposed: n
type: ()->FiniteSimplicialComplex(VS)
params: pSimplicialComplexFactory(VS)
comment:
Generate a minimal triangulation of the surface of a Moebius band. A one sided surface with a single external boundary line.


kind: o
name: moebiusMu
exposed: x
type: (Integer)->Integer
params: pIntegerNumberTheoryFunctions
comment:
\spad{moebiusMu(n)} returns the Moebius function \spad{mu(n)}. \spad{mu(n)} is either \spad{-1},{} 0 or 1 as follows: \spad{mu(n) = 0} if \spad{n} is divisible by a square > 1,{} \spad{mu(n) = (-1)^k} if \spad{n} is square-free and has \spad{k} distinct prime divisors.


kind: o
name: moment2booleanCumulant
exposed: n
type: (Sequence(R))->Sequence(R)
params: pMomentPackage(R)
comment:
\spad{moment2booleanCumulant(mm)} computes the sequence of boolean cumulants from the sequence of moments \spad{mm}


kind: o
name: moment2cumulant
exposed: n
type: (Sequence(R))->Sequence(R)
params: pMomentPackage(R)
comment:
\spad{moment2cumulant(mm)} computes the sequence of classical cumulants from the sequence of moments \spad{mm}


kind: o
name: moment2freeCumulant
exposed: n
type: (Sequence(R))->Sequence(R)
params: pMomentPackage(R)
comment:
\spad{moment2freeCumulant(mm)} computes the sequence of free cumulants from the sequence of moments \spad{mm}


kind: o
name: moment2monotoneCumulant
exposed: n
type: (Sequence(R))->Sequence(R)
params: pMomentPackage(R)
abbrev: has(R,Algebra(Fraction(Integer)))
comment:
\spad{moment2monotoneCumulant(x)} returns the sequence of monotone cumulants of the moment sequence \spad{x}


kind: o
name: moment2nthJacobi
exposed: n
type: (List(R))->Record(an:List(R),bn:List(R))
params: pMomentPackage(R)
abbrev: has(R,Field)
comment:
\spad{moment2nthJacobi(mm)} computes the list of Jacobi parameters from the list of moments \spad{mm} as far as possible.


kind: o
name: moment2Stransform
exposed: n
type: (Sequence(R))->Record(puiseux:Fraction(Integer),laurent:Fraction(Integer),coef:Sequence(R))
params: pMomentPackage(R)
abbrev: has(R,Algebra(Fraction(Integer)))
comment:
\spad{moment2Stransform(x)} returns the Puiseux and Laurent order and coefficients of the \spad{S} transform of \spad{x}


kind: o
name: monic?
exposed: x
type: (%)->Boolean
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{monic?(p)} returns \spad{false} if \spad{p} belongs to \spad{R},{} otherwise returns \spad{true} iff \spad{p} is monic as a univariate polynomial in its main variable.


kind: o
name: monicCompleteDecompose
exposed: x
type: (UP)->List(UP)
params: pUnivariatePolynomialDecompositionPackage(R,UP)
comment:
\spad{monicCompleteDecompose(f)} returns a list of factors of \spad{f} for the functional decomposition of monic polynomial \spad{f}. [\spad{f1},{} ...,{} \spad{fn}] means \spad{f} = \spad{f1} \spad{o} ... \spad{o} \spad{fn}.


kind: o
name: monicDecomposeIfCan
exposed: x
type: (UP)->Union(Record(left:UP,right:UP),failed)
params: pUnivariatePolynomialDecompositionPackage(R,UP)
comment:
\spad{monicDecomposeIfCan(f)} returns a functional decomposition of the monic polynomial \spad{f} or failed if it has not found any.


kind: o
name: monicDivide
exposed: x
type: (%,%)->Record(quotient:%,remainder:%)
params: cUnivariatePolynomialCategory(R)
abbrev: has(R,Ring)
comment:
\spad{monicDivide(p,{} q)} divide the polynomial \spad{p} by the monic polynomial \spad{q},{} returning the pair \spad{[quotient,{} remainder]}. Error: if \spad{q} isn\spad{'t} monic.


kind: o
name: monicDivide
exposed: x
type: (%,%,VarSet)->Record(quotient:%,remainder:%)
params: cPolynomialCategory(R,E,VarSet)
abbrev: has(R,Ring)
comment:
\spad{monicDivide(a,{} b,{} v)} divides the polynomial a by the polynomial \spad{b},{} with each viewed as a univariate polynomial in \spad{v} returning both the quotient and remainder. Error: if \spad{b} is not monic with respect to \spad{v}.


kind: o
name: monicLeftDivide
exposed: x
type: (%,%)->Record(quotient:%,remainder:%)
params: cUnivariateSkewPolynomialCategory(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{monicLeftDivide(a,{} b)} returns the pair \spad{[q,{} r]} such that \spad{a = b*q + r} and the degree of \spad{r} is less than the degree of \spad{b}. \spad{b} must be monic. This process is called


kind: o
name: monicLeftDivide
exposed: n
type: (C,C,Automorphism(R))->Record(quotient:C,remainder:C)
params: pUnivariateSkewPolynomialCategoryOps(R,C)
abbrev: has(R,IntegralDomain)
comment:
\spad{monicLeftDivide(a,{} b,{} sigma)} returns the pair \spad{[q,{} r]} such that \spad{a = b*q + r} and the degree of \spad{r} is less than the degree of \spad{b}. \spad{b} must be monic. This process is called


kind: o
name: monicModulo
exposed: n
type: (%,%)->%
params: dNewSparseUnivariatePolynomial(R)
comment:
\spad{monicModulo(a,{} b)} returns \spad{r} such that \spad{r} is reduced \spad{w}.\spad{r}.\spad{t}. \spad{b} and \spad{b} divides \spad{a - r} where \spad{b} is monic.


kind: o
name: monicModulo
exposed: x
type: (%,%)->%
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{monicModulo(a,{} b)} computes \spad{a mod b},{} if \spad{b} is monic as univariate polynomial in its main variable.


kind: o
name: monicRightDivide
exposed: x
type: (%,%)->Record(quotient:%,remainder:%)
params: cUnivariateSkewPolynomialCategory(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{monicRightDivide(a,{} b)} returns the pair \spad{[q,{} r]} such that \spad{a = q*b + r} and the degree of \spad{r} is less than the degree of \spad{b}. \spad{b} must be monic. This process is called


kind: o
name: monicRightDivide
exposed: n
type: (C,C,Automorphism(R))->Record(quotient:C,remainder:C)
params: pUnivariateSkewPolynomialCategoryOps(R,C)
abbrev: has(R,IntegralDomain)
comment:
\spad{monicRightDivide(a,{} b,{} sigma)} returns the pair \spad{[q,{} r]} such that \spad{a = q*b + r} and the degree of \spad{r} is less than the degree of \spad{b}. \spad{b} must be monic. This process is called


kind: o
name: monicRightFactorIfCan
exposed: x
type: (UP,NonNegativeInteger)->Union(UP,failed)
params: pUnivariatePolynomialDecompositionPackage(R,UP)
comment:
\spad{monicRightFactorIfCan(f,{} d)} returns a candidate to be the monic right factor (\spad{h} in \spad{f} = \spad{g} \spad{o} \spad{h}) of degree \spad{d} of a functional decomposition of the polynomial \spad{f} or \spad{failed} if no such candidate.


kind: o
name: monologextint
exposed: n
params: pParametricTranscendentalIntegration(F,UP)
comment: \spad{monologextint(lup,{} csolve,{} rec)} is a helper for logextint
type:
(List(UP),(Matrix(F))->List(Vector(Fraction(Integer))),(List(F))->Record(logands:List(F),basis:List(Vector(Fraction(Integer)))))->Record(logands:List(Fraction(UP)),basis:List(Vector(Fraction(Integer))))


kind: o
name: monomial?
exposed: n
type: (%)->Boolean
params: cIndexedProductCategory(A,S)
comment:
\spad{monomial?(x)} returns \spad{true} if \spad{x} is a single monomial,{} that is support of \spad{x} consists of a single element.


kind: o
name: monomial
exposed: n
type: (A,S)->%
params: cIndexedProductCategory(A,S)
comment:
\spad{monomial(a,{} s)} constructs a direct product element with the \spad{s} component set to \spad{a}


kind: o
name: monomial
exposed: x
type: (K,List(PositiveInteger))->%
params: dCliffordAlgebra(n,K,bLin)
comment:
\spad{monomial(c,{} [i1,{} i2,{} ...,{} iN])} produces the value given by \spad{c*e(i1)*e(i2)*...*e(iN)}.


kind: o
name: monomial
exposed: n
type: (%,VarSet,NonNegativeInteger)->%
params: cMaybeSkewPolynomialCategory(R,E,VarSet)
comment:
\spad{monomial(a,{} x,{} n)} creates the monomial \spad{a*x^n} where \spad{a} is a polynomial,{} \spad{x} is a variable and \spad{n} is a nonnegative integer.


kind: o
name: monomial
exposed: x
type: (%,List(Var),List(NonNegativeInteger))->%
params: cMultivariateTaylorSeriesCategory(Coef,Var)
comment:
\spad{monomial(a,{} [x1,{} x2,{} ...,{} xk],{} [n1,{} n2,{} ...,{} nk])} returns \spad{a * x1^n1 * ... * xk^nk}.


kind: o
name: monomialIntegrate
exposed: n
params: pTranscendentalIntegration(F,UP)
type:
(Fraction(UP),(UP)->UP)->Record(ir:IntegrationResult(Fraction(UP)),specpart:Fraction(UP),polypart:UP)

comment:
\spad{monomialIntegrate(f,{} ')} returns \spad{[ir,{} s,{} p]} such that \spad{f = ir' + s + p} and all the squarefree factors of the denominator of \spad{s} are special \spad{w}.\spad{r}.\spad{t} the derivation '.


kind: o
name: monomialIntPoly
exposed: n
type: (UP,(UP)->UP)->Record(answer:UP,polypart:UP)
params: pTranscendentalIntegration(F,UP)
comment:
\spad{monomialIntPoly(p,{} ')} returns [\spad{q},{} \spad{r}] such that \spad{p = q' + r} and \spad{degree(r) < degree(t')}. Error if \spad{degree(t') < 2}.


kind: o
name: monomials
exposed: n
type: (%)->List(%)
params: cMaybeSkewPolynomialCategory(R,E,VarSet)
comment:
\spad{monomials(p)} returns the list of non-zero monomials of polynomial \spad{p},{} \spadignore{i.e.} \spad{monomials(sum(a_(i) X^(i))) = [a_(1) X^(1),{} ...,{} a_(n) X^(n)]}.


kind: o
name: monotoneConvolution
exposed: n
type: (%,%)->%
params: cDistributionCategory(R)
comment:
\spad{monotoneConvolution(x,{} y)} returns the monotone convolution of the distributions \spad{x} and \spad{y}


kind: o
name: monotoneCumulant2moment
exposed: n
type: (Sequence(R))->Sequence(R)
params: pMomentPackage(R)
comment:
\spad{monotoneCumulant2moment(hh)} computes the sequence of moments from the sequence of monotone cumulants \spad{hh}


kind: o
name: monotoneCumulant2momentPoly
exposed: n
type: (Sequence(R))->Sequence(SparseUnivariatePolynomial(R))
params: pMomentPackage(R)
comment:
\spad{monotoneCumulant2momentPoly(hh)} computes the sequence of moment polynomials \$\spad{m_n}(\spad{t})\$ from the sequence of monotone cumulants \spad{hh}


kind: o
name: monotoneCumulants
exposed: n
type: (%)->Sequence(R)
params: cDistributionCategory(R)
abbrev: has(R,Algebra(Fraction(Integer)))
comment:
\spad{monotoneCumulants(x)} returns the sequence of monotone cumulants of the distribution \spad{x}.


kind: o
name: more?
exposed: n
type: (S,S)->Boolean
params: pUserDefinedPartialOrdering(S)
abbrev: has(S,OrderedSet)
comment:
\spad{more?(a,{} b)} compares \spad{a} and \spad{b} in the partial ordering induced by setOrder,{} and uses the ordering on \spad{S} if \spad{a} and \spad{b} are not comparable in the partial ordering.


kind: o
name: moreAlgebraic?
exposed: x
type: (TS,TS)->Boolean
params: pQuasiComponentPackage(R,E,V,P,TS)
comment:
\spad{moreAlgebraic?(ts,{} us)} returns \spad{false} iff \spad{ts} and \spad{us} are both empty,{} or \spad{ts} has less elements than \spad{us},{} or some variable is algebraic \spad{w}.\spad{r}.\spad{t}. \spad{us} and is not \spad{w}.\spad{r}.\spad{t}. \spad{ts}.


kind: o
name: morphism
exposed: n
type: ((R)->R,(R)->R)->%
params: dAutomorphism(R)
comment:
\spad{morphism(f,{} g)} returns the invertible morphism given by \spad{f},{} where \spad{g} is the inverse of \spad{f}..


kind: o
name: motzkinPathArray
exposed: n
type: (Stream(R),Stream(R),Stream(R))->Stream(List(R))
params: pPathArrayPackage(R)
comment:
\spad{motzkinPathArray([a0,{} a1,{} ...],{} [b0,{} b1,{} ...],{} [c1,{} c2,{} ...])} computes Flajolet\spad{'s} Motzkin path array from the sequences \spad{ai},{} \spad{bi},{} \spad{ci}.


kind: o
name: move
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger)->Void
params: dTwoDimensionalViewport
comment:
\spad{move(v,{} x,{} y)} displays the two-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{TwoDimensionalViewport},{} with the upper left-hand corner of the viewport window at the screen coordinate position \spad{x},{} \spad{y}.


kind: o
name: move
exposed: x
type: (%,NonNegativeInteger,NonNegativeInteger)->Void
params: dThreeDimensionalViewport
comment:
\spad{move(v,{} x,{} y)} displays the three-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{ThreeDimensionalViewport},{} with the upper left-hand corner of the viewport window at the screen coordinate position \spad{x},{} \spad{y}.


kind: o
name: mpsode
exposed: n
type: (List(Coef),List((List(UTS))->UTS))->List(UTS)
params: pUnivariateTaylorSeriesODESolver(Coef,UTS)
comment:
\spad{mpsode(r,{} f)} solves the system of differential equations \spad{dy[i]/dx =f[i] [x,{} y[1],{} y[2],{} ...,{} y[n]]},{} \spad{y[i](a) = r[i]} for \spad{i} in 1..\spad{n}.


kind: o
name: mr
exposed: n
params: pTableauxBumpers(S)
type:
(List(List(List(S))))->Record(f1:List(S),f2:List(List(List(S))),f3:List(List(S)),f4:List(List(List(S))))

comment:
\spad{mr(t)} is an auxiliary function which finds the position of the maximum element of a tableau \spad{t} which is in the lowest row,{} producing a record of results


kind: o
name: mrv_cmp
exposed: n
params: pMrvLimitPackage
comment: \spad{mrv_cmp compare} kernels.
type:
(Kernel(Expression(Integer)),Kernel(Expression(Integer)),Symbol,Record(tan_syms:List(Symbol),atan_syms:List(Symbol),tan_kers:List(Kernel(Expression(Integer))),atan_kers:List(Kernel(Expression(Integer)))))->Union(Record(sign:Integer,coeff:Expression(Integer)),failed)


kind: o
name: mrv_limit
exposed: n
params: pMrvLimitPackage
type:
(Expression(Integer),Equation(OrderedCompletion(Expression(Integer))))->Union(OrderedCompletion(Expression(Integer)),Record(leftHandLimit:Union(OrderedCompletion(Expression(Integer)),failed),rightHandLimit:Union(OrderedCompletion(Expression(Integer)),failed)),failed)

comment:
\spad{mrv_limit(f,{} x=a)} computes limit(\spad{f}(\spad{x}),{} x=a) for a finite or infinite limit point a.


kind: o
name: mrv_limit
exposed: n
params: pMrvLimitPackage
type:
(Expression(Integer),Equation(Expression(Integer)),String)->Union(OrderedCompletion(Expression(Integer)),failed)

comment:
\spad{mrv_limit(f,{} x = a,{} str)} computes limit(\spad{f}(\spad{x}),{} x=a) for a strictly finite limit point a. This function computes one-sided limits from the left or right.


kind: o
name: mrv_limit
exposed: n
params: pMrvLimitPackage
comment: \spad{mrv_limit(f,{} x,{} a)} is like mrv_limit(\spad{f},{} \spad{x} = a).
type:
(Expression(Integer),Symbol,OrderedCompletion(Expression(Integer)))->Union(OrderedCompletion(Expression(Integer)),Record(leftHandLimit:Union(OrderedCompletion(Expression(Integer)),failed),rightHandLimit:Union(OrderedCompletion(Expression(Integer)),failed)),failed)


kind: o
name: mrv_limit
exposed: n
params: pMrvLimitPackage
comment: \spad{mrv_limit(f,{} x,{} s)} computes limit.
type:
(Expression(Integer),Symbol,Record(tan_syms:List(Symbol),atan_syms:List(Symbol),tan_kers:List(Kernel(Expression(Integer))),atan_kers:List(Kernel(Expression(Integer)))))->Union(OrderedCompletion(Expression(Integer)),failed)


kind: o
name: mrv_limit
exposed: n
params: pMrvLimitPackage
comment: \spad{mrv_limit(f,{} x,{} a,{} str)} is like mrv_limit(\spad{f},{} \spad{x} = a,{} \spad{str}).
type:
(Expression(Integer),Symbol,Expression(Integer),String)->Union(OrderedCompletion(Expression(Integer)),failed)


kind: o
name: mrv_normalize
exposed: n
params: pMrvLimitPackage
type:
(Expression(Integer),Symbol,Record(tan_syms:List(Symbol),atan_syms:List(Symbol),tan_kers:List(Kernel(Expression(Integer))),atan_kers:List(Kernel(Expression(Integer)))))->Expression(Integer)

comment:
\spad{mrv_normalize(f,{} x,{} s)} transform \spad{f} to the form acceptable by core variant of mrv_limit.


kind: o
name: mrv_rewrite0
exposed: n
params: pMrvLimitPackage
comment: \spad{mrv_rewrite0 rewrites} comparable kernels in terms of a single one.
type:
(Expression(Integer),List(Kernel(Expression(Integer))),List(Expression(Integer)),Expression(Integer))->Expression(Integer)


kind: o
name: mrv_rewrite
exposed: n
params: pMrvLimitPackage
comment: \spad{mrv_rewrite rewrites} comparable kernels and computes leading term of series expansion.
type:
(Expression(Integer),List(Kernel(Expression(Integer))),List(Expression(Integer)),Symbol,Record(tan_syms:List(Symbol),atan_syms:List(Symbol),tan_kers:List(Kernel(Expression(Integer))),atan_kers:List(Kernel(Expression(Integer)))))->Union(Record(degree:OrderedExpression,coeff:Expression(Integer)),failed)


kind: o
name: mrv_set
exposed: n
params: pMrvLimitPackage
comment: \spad{mrv_set compute} \spad{MRV} set.
type:
(Expression(Integer),Symbol,Record(tan_syms:List(Symbol),atan_syms:List(Symbol),tan_kers:List(Kernel(Expression(Integer))),atan_kers:List(Kernel(Expression(Integer)))))->Union(Record(lk:List(Kernel(Expression(Integer))),lc:List(Expression(Integer))),failed)


kind: o
name: mrv_sign
exposed: n
params: pMrvLimitPackage
comment: \spad{mrv_sign(f,{} x,{} s)} computes sign of \spad{f} near \spad{x}.
type:
(Expression(Integer),Symbol,Record(tan_syms:List(Symbol),atan_syms:List(Symbol),tan_kers:List(Kernel(Expression(Integer))),atan_kers:List(Kernel(Expression(Integer)))))->Union(Integer,failed)


kind: o
name: mul_by_binomial
exposed: n
type: (U32Vector,Integer,Integer)->Void
params: pU32VectorPolynomialOperations
comment:
\spad{mul_by_binomial(v,{} pt,{} p)} treats \spad{v} a polynomial and multiplies in place this polynomial by binomial (\spad{x} + \spad{pt}). Highest coefficient of product is ignored.


kind: o
name: mul_by_binomial
exposed: n
type: (U32Vector,Integer,Integer,Integer)->Void
params: pU32VectorPolynomialOperations
comment:
\spad{mul_by_binomial(v,{} deg,{} pt,{} p)} treats \spad{v} as coefficients of polynomial of degree \spad{deg} - 1 and multiplies in place this polynomial by binomial (\spad{x} + \spad{pt}). Highest coefficient of product is ignored.


kind: o
name: mul_by_scalar
exposed: n
type: (U32Vector,Integer,Integer,Integer)->Void
params: pU32VectorPolynomialOperations
comment:
\spad{mul_by_scalar(v,{} deg,{} c,{} p)} treats \spad{v} as coefficients of polynomial of degree \spad{deg} and multiplies in place this polynomial by scalar \spad{c}


kind: o
name: multiEuclidean
exposed: x
type: (List(%),%)->Union(List(%),failed)
params: cEuclideanDomain
comment:
\spad{multiEuclidean([f1,{} ...,{} fn],{} z)} returns a list of coefficients \spad{[a1,{} ...,{} an]} such that \spad{ z / prod \spad{fi} = sum aj/fj}. If no such list of coefficients exists,{} failed is returned.


kind: o
name: multifunctionGraph
exposed: n
params: dMultifunctionGraph(S)
type:
(List(Record(value:S,posX:NonNegativeInteger,posY:NonNegativeInteger,next:List(NonNegativeInteger),map:List(List(NonNegativeInteger)))))->%

comment:
\spad{multifunctionGraph(l)} constructs a graph with given list \spad{l} of objects. More objects and arrows can be added later if required.


kind: o
name: multifunctionGraph
exposed: n
type: (List(S))->%
params: dMultifunctionGraph(S)
comment:
\spad{multifunctionGraph(l)} constructs a graph with given list \spad{l} of object names. Use this version of the constructor if you don\spad{'t} intend to create diagrams and therefore don\spad{'t} care about \spad{x},{} \spad{y} coordinates. More objects and arrows can be added later if required.


kind: o
name: multifunctionGraph
exposed: n
params: dMultifunctionGraph(S)
type:
(List(Record(value:S,posX:NonNegativeInteger,posY:NonNegativeInteger)),List(Record(name:String,arrType:NonNegativeInteger,fromOb:NonNegativeInteger,toOb:NonNegativeInteger,xOffset:Integer,yOffset:Integer,map:List(NonNegativeInteger))))->%

comment:
\spad{multifunctionGraph(lo,{} la)} constructs a graph with given list of objects la and list of arrows la. More objects and arrows can be added later if required.


kind: o
name: multifunctionGraph
exposed: n
type: (List(S),List(List(NonNegativeInteger)))->%
params: dMultifunctionGraph(S)
comment:
\spad{multifunctionGraph(lo,{} am)} constructs a graph given list of objects \spad{lo} and adjacency matrix am.


kind: o
name: multinomial
exposed: x
type: (I,List(I))->I
params: pIntegerCombinatoricFunctions(I)
comment:
\spad{multinomial(n,{} [m1,{} m2,{} ...,{} mk])} returns the multinomial coefficient \spad{n!/(m1! m2! ... mk!)}.


kind: o
name: multiple?
exposed: n
type: (%)->Boolean
params: dPattern(R)
comment:
\spad{multiple?(p)} tests if \spad{p} is a single matching variable allowing list matching or multiple term matching in a sum or product.


kind: o
name: multiple
exposed: x
type: (F)->F
params: pFunctionSpaceAssertions(R,F)
comment:
\spad{multiple(x)} tells the pattern matcher that \spad{x} should preferably match a multi-term quantity in a sum or product. For matching on lists,{} multiple(\spad{x}) tells the pattern matcher that \spad{x} should match a list instead of an element of a list. Error: if \spad{x} is not a symbol.


kind: o
name: multiple
exposed: x
type: (Symbol)->Expression(Integer)
params: pPatternMatchAssertions
comment:
\spad{multiple(x)} tells the pattern matcher that \spad{x} should preferably match a multi-term quantity in a sum or product. For matching on lists,{} multiple(\spad{x}) tells the pattern matcher that \spad{x} should match a list instead of an element of a list.


kind: o
name: multiplicative?
exposed: n
type: (%,PositiveInteger)->Boolean
params: dDirichletRing(Coef)
comment:
\spad{multiplicative?(a,{} n)} returns \spad{true} if the first \spad{n} coefficients of a are multiplicative


kind: o
name: multiplyALS
exposed: n
type: (%,%)->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{multiplyALS(f,{}g)} computes \spad{f*g} in terms of the admissible linear systems for \spad{f} and \spad{g} (without minimization).


kind: o
name: multiplyCoefficients
exposed: n
type: ((Integer)->Coef,%)->%
params: dInnerSparseUnivariatePowerSeries(Coef)
comment:
\spad{multiplyCoefficients(fn,{} f)} returns the series \spad{sum(fn(n) * an * x^n,{} n = n0..)},{} where \spad{f} is the series \spad{sum(an * x^n,{} n = n0..)}.


kind: o
name: multiplyCoefficients
exposed: x
type: ((Integer)->Coef,%)->%
params: cUnivariateLaurentSeriesCategory(Coef)
comment:
\spad{multiplyCoefficients(f,{} sum(n = n0..infinity,{} a[n] * x^n)) = sum(n = 0..infinity,{} f(n) * a[n] * x^n)}. This function is used when Puiseux series are represented by a Laurent series and an exponent.


kind: o
name: multiplyCoefficients
exposed: x
type: ((Integer)->Coef,%)->%
params: cUnivariateTaylorSeriesCategory(Coef)
comment:
\spad{multiplyCoefficients(f,{} sum(n = 0..infinity,{} a[n] * x^n))} returns \spad{sum(n = 0..infinity,{} f(n) * a[n] * x^n)}. This function is used when Laurent series are represented by a Taylor series and an order.


kind: o
name: multiplyColumn!
exposed: n
type: (%,NonNegativeInteger,F)->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{multiplyColumn!(f,{} i,{} alpha)} multiplies column(\spad{i}) by alpha in the ALS of \spad{f}.


kind: o
name: multiplyExponents
exposed: x
type: (%,Fraction(Integer))->%
params: cUnivariatePuiseuxSeriesCategory(Coef)
comment:
\spad{multiplyExponents(f,{} r)} multiplies all exponents of the power series \spad{f} by the positive rational number \spad{r}.


kind: o
name: multiplyExponents
exposed: x
type: (%,NonNegativeInteger)->%
params: cUnivariatePolynomialCategory(R)
comment:
\spad{multiplyExponents(p,{} n)} returns a new polynomial resulting from multiplying all exponents of the polynomial \spad{p} by the non negative integer \spad{n}.


kind: o
name: multiplyExponents
exposed: x
type: (%,PositiveInteger)->%
params: cUnivariatePowerSeriesCategory(Coef,Expon)
comment:
\spad{multiplyExponents(f,{} n)} multiplies all exponents of the power series \spad{f} by the positive integer \spad{n}.


kind: o
name: multisect
exposed: n
type: (Integer,Integer,%)->%
params: dUnivariateTaylorSeries(Coef,var,cen)
comment:
\spad{multisect(a,{} b,{} f(x))} selects the coefficients of \indented{1}{\spad{x^((a+b)*n+a)},{} and changes this monomial to \spad{x^n}.}


kind: o
name: multisect
exposed: n
type: (Integer,Integer,Stream(A))->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{multisect(a,{} b,{} st)} selects the coefficients of \spad{x^((a+b)*n+a)},{} and changes them to \spad{x^n}.


kind: o
name: multi_SPDE
exposed: n
params: pRDEaux(F)
comment: \spad{multi_SPDE(a,{} b,{} lc,{} d,{} der)}
type:
(SparseUnivariatePolynomial(F),SparseUnivariatePolynomial(F),List(SparseUnivariatePolynomial(F)),Integer,(SparseUnivariatePolynomial(F))->SparseUnivariatePolynomial(F))->Union(List(Record(ans:SparseUnivariatePolynomial(F),remainder:SparseUnivariatePolynomial(F))),Record(ans:List(SparseUnivariatePolynomial(F)),acoeff:SparseUnivariatePolynomial(F),eegen:SparseUnivariatePolynomial(F),bpar:SparseUnivariatePolynomial(F),lcpar:List(SparseUnivariatePolynomial(F)),dpar:Integer))


kind: o
name: multivariate
exposed: x
type: (SparseUnivariatePolynomial(R),VarSet)->%
params: cPolynomialCategory(R,E,VarSet)
comment:
\spad{multivariate(sup,{} v)} converts an anonymous univariable polynomial \spad{sup} to a polynomial in the variable \spad{v}.


kind: o
name: musserTrials
exposed: n
type: (PositiveInteger)->PositiveInteger
params: pGaloisGroupFactorizer(UP)
comment:
\spad{musserTrials(n)} sets to \spad{n} the number of primes to be tried in \spadfun{modularFactor} and returns the previous value.


kind: o
name: mvar
exposed: x
type: (%)->VarSet
params: cPolynomialSetCategory(R,E,VarSet,P)
comment:
\spad{mvar(ps)} returns the main variable of the non constant polynomial with the greatest main variable,{} if any,{} else an error is returned.


kind: o
name: mvar
exposed: x
type: (%)->V
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{mvar(p)} returns an error if \spad{p} belongs to \spad{R},{} otherwise returns its main variable \spad{w}. \spad{r}. \spad{t}. to the total ordering on the elements in \spad{V}.


kind: o
name: naiveBeckermannLabahn0
exposed: n
params: pNaiveBeckermannLabahnModular
comment: main solver routine
type:
(Vector(U32Vector),Vector(U32Vector),Vector(Integer),NonNegativeInteger,Integer,(Integer)->Integer,(U32Vector,Integer,Integer)->Void,(U32Vector,Integer,Integer)->Void)->Void


kind: o
name: naiveBeckermannLabahn1
exposed: n
params: pNaiveBeckermannLabahnModular
type:
(Vector(SparseUnivariatePolynomial(Integer)),Vector(Integer),NonNegativeInteger,Integer,(Integer)->Integer,(U32Vector,Integer,Integer)->Void,(U32Vector,Integer,Integer)->Void)->List(Any)


kind: o
name: naiveBeckermannLabahn1
exposed: n
params: pNaiveBeckermannLabahnModular
type:
(Vector(U32Vector),Vector(Integer),NonNegativeInteger,Integer,(Integer)->Integer,(U32Vector,Integer,Integer)->Void,(U32Vector,Integer,Integer)->Void)->List(Any)


kind: o
name: naiveBeckermannLabahn
exposed: n
type: (Vector(SparseUnivariatePolynomial(Integer)),Vector(Integer),NonNegativeInteger,Integer)->List(Any)
params: pNaiveBeckermannLabahnModular
comment:
\spad{naiveBeckermannLabahn(f,{} degs,{} sigma,{} p)} solves modulo \$\spad{p}\$ Hermite-Pade interpolation problem of order \$\spad{sigma}\$. \$\spad{degs}\$ specifies degree bounds for solution. The first element of result contains \spad{sigma}-basis. The second gives defects of elements of \spad{sigma}-basis. The third one contains residuals \spad{--} we stop updating solution if this would violate degree bounds,{} so residual is zero for elements of \spad{sigma}-basis which are within bounds,{} but non-zero otherwise.


kind: o
name: naiveBeckermannLabahnMultipoint
exposed: n
type: (Vector(SparseUnivariatePolynomial(Integer)),Vector(Integer),U32Vector,Integer)->List(Any)
params: pNaiveBeckermannLabahnModular
comment:
\spad{naiveBeckermannLabahnMultipoint(f,{} degs,{} sigma,{} p)} solves modulo \$\spad{p}\$ multipoint Hermite-Pade interpolation problem of order \$\spad{sigma}\$. \$\spad{degs}\$ specifies degree bounds for solution. The first element of result contains \spad{sigma}-basis. The second gives defects of elements of \spad{sigma}-basis. The third one contains residuals \spad{--} we stop updating solution if this would violate degree bounds,{} so residual is zero for elements of \spad{sigma}-basis which are within bounds,{} but non-zero otherwise.


kind: o
name: nary
exposed: n
type: (String,Integer,(Integer,List(OutputForm))->OutputBox)->(Integer,List(OutputForm))->OutputBox
params: cFormatterCategory
comment:
\spad{nary(s,{} p,{} hh)} returns a handler \spad{h} such that \spad{h(prec,{} args)} formats each argument according to \spad{hh}. All resulting boxes will be horizontally concatenated with \spad{box s} inbetween. Outer parentheses are added if \spad{p < prec}.


kind: o
name: naryPlus
exposed: n
params: cFormatterCategory
type:
(String,String,Integer,(Integer,List(OutputForm))->OutputBox)->(Integer,List(OutputForm))->OutputBox

comment:
\spad{nary(plus,{} minus,{} p,{} hh)} returns a handler \spad{h} such that \spad{h(prec,{} args)} formats each argument according to \spad{hh}. All resulting boxes will be horizontally concatenated with \spad{box minus} or \spad{box plus} inbetween depending on whether the respective argument starts with a unary \spad{minus} or not. Outer parentheses are added if \spad{p < prec}. This is a special handler that treats the case that a sum is represented as a nary expression that contains unary subexpressions that are unary \spad{minus} expressions. This handler transforms something like (+ a (- \spad{b})) into a - \spad{b}.


kind: o
name: ncDetSys
exposed: n
type: (List(JetBundleExpression(JB1)))->List(JetBundleExpression(JetBundleSymAna(JB1,xi,eta)))
params: pSymmetryAnalysis(JB1,xi,eta)
comment:
\spad{ncDetSys(sys)} computes the determining system for generators of conditional symmetries of \spad{sys}. It makes the same assumptions as \spad{detSys}.


kind: o
name: ncDetSys
exposed: n
params: pSymmetryAnalysis(JB1,xi,eta)
type:
(List(JetBundleExpression(JB1)),JetVectorField(JB1,JetBundleExpression(JB1)))->List(JetBundleExpression(JB1))

comment:
\spad{ncDetSys(sys,{} vf)} computes the determining system for generators of conditional symmetries of \spad{sys} with a given ansatz for the vector fields.


kind: o
name: ncDetSys
exposed: n
params: pSymmetryAnalysis(JB1,xi,eta)
type:
(List(JetBundleExpression(JB1)),List(JB1),JetVectorField(JB1,JetBundleExpression(JB1)))->List(JetBundleExpression(JB1))

comment:
\spad{ncDetSys(sys,{} sjb,{} vf)} computes the determining system for generators of conditional symmetries of \spad{sys}. The meaning of the further arguments is the same as in \spad{detSys}.


kind: o
name: negative?
exposed: x
type: (%)->Boolean
params: cIntervalCategory(R)
comment:
\spad{negative?(u)} returns \spad{true} if every element of \spad{u} is negative,{} \spad{false} otherwise.


kind: o
name: new
exposed: n
type: ()->%
params: dFormatter(F)
comment:
\spad{new()} create a new,{} empty object with defaultPrologue(\spad{"}) and defaultEpilogue(\spad{"}). Use \spadfun{setPrologue!},{} \spadfun{setFormat!} and \spadfun{setEpilogue!} to set the various components of this object.


kind: o
name: new
exposed: n
type: ()->%
params: dTexFormat
comment:
\spad{new()} create a new,{} empty object. Use \spadfun{setPrologue!},{} \spadfun{setTex!} and \spadfun{setEpilogue!} to set the various components of this object.


kind: o
name: new
exposed: n
type: (LinearMultivariateMatrixPencil(F),List(FreeMonoid(VAR)))->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{new(lp,{} lst)} creates an element by the linear multivariate matrix pencil \spad{lp} and the list of monomials \spad{lst}.


kind: o
name: new
exposed: n
type: (List(C),Integer)->%
params: dSparseEchelonMatrix(C,D)
comment:
\spad{new(inds,{} nrows)} generates a new matrix with \spad{nrows} rows and columns enumerated by the indices \spad{inds}. The matrix is empty,{} \spadignore{i.e.} the zero matrix.


kind: o
name: new
exposed: x
type: (String,String,String)->%
params: cFileNameCategory
comment:
\spad{new(d,{} pref,{} e)} constructs the name of a new writable file with \spad{d} as its directory,{} \spad{pref} as a prefix of its name and \spad{e} as its extension. When \spad{d} or \spad{t} is the empty string,{} a default is used. An error occurs if a new file cannot be written in the given directory.


kind: o
name: newReduc
exposed: n
type: (Integer)->Void
params: pFunctionSpaceReduce(R,F)
comment:
\spad{newReduc(n)} empties reduction state. \spad{n} is size of random integers to use during next reduction.


kind: o
name: newton
exposed: n
type: (List(F))->SparseUnivariatePolynomial(F)
params: pNewtonInterpolation(F)
comment:
\spad{newton}(\spad{l}) returns the interpolating polynomial for the values \spad{l},{} where the \spad{x}-coordinates are assumed to be [1,{} 2,{} 3,{} ...,{} \spad{n}] and the coefficients of the interpolating polynomial are known to be in the domain \spad{F}. \spad{I}.\spad{e}.,{} it is a very streamlined version for a special case of interpolation.


kind: o
name: next
exposed: x
type: (%)->%
params: cDoublyLinkedAggregate(S)
comment:
\spad{next(l)} returns the doubly-linked aggregate beginning with its next element. Error: if \spad{l} has no next element. Note: \spad{next(l) = rest(l)} and \spad{previous(next(l)) = l}.


kind: o
name: nextColeman
exposed: x
type: (List(Integer),List(Integer),Matrix(Integer))->Matrix(Integer)
params: pSymmetricGroupCombinatoricFunctions
comment:
\spad{nextColeman(alpha,{} beta,{} C)} generates the next Coleman matrix of column sums {\em alpha} and row sums {\em beta} according to the lexicographical order from bottom-to-top. The first Coleman matrix is achieved by {\em C=new(1,{} 1,{} 0)}. Also,{} {\em new(1,{} 1,{} 0)} indicates that \spad{C} is the last Coleman matrix.


kind: o
name: nextIrreduciblePoly
exposed: n
type: (SparseUnivariatePolynomial(GF))->Union(SparseUnivariatePolynomial(GF),failed)
params: pFiniteFieldPolynomialPackage(GF)
comment:
\spad{nextIrreduciblePoly(f)} yields the next monic irreducible polynomial over a finite field {\em GF} of the same degree as \spad{f} in the following order,{} or failed if there are no greater ones. Error: if \spad{f} has degree 0. Note: the input polynomial \spad{f} is made monic. \spad{lexSmaller?} is used as ordering predicate.


kind: o
name: nextLatticePermutation
exposed: x
type: (List(Integer),List(Integer),Boolean)->List(Integer)
params: pSymmetricGroupCombinatoricFunctions
comment:
\spad{nextLatticePermutation(lambda,{} lattP,{} constructNotFirst)} generates the lattice permutation according to the proper partition {\em lambda} succeeding the lattice permutation {\em lattP} in lexicographical order as long as {\em constructNotFirst} is \spad{true}. If {\em constructNotFirst} is \spad{false},{} the first lattice permutation is returned. The result {\em []} indicates that {\em lattP} has no successor.


kind: o
name: nextNormalPoly
exposed: n
type: (SparseUnivariatePolynomial(GF))->Union(SparseUnivariatePolynomial(GF),failed)
params: pFiniteFieldPolynomialPackage(GF)
comment:
\spad{nextNormalPoly(f)} yields the next normal polynomial over a finite field {\em GF} of the same degree as \spad{f} in the following order,{} or failed if there are no greater ones. Error: if \spad{f} has degree 0. Note: the input polynomial \spad{f} is made monic. \spad{nlexSmaller?} is used as ordering predicate.


kind: o
name: nextNormalPrimitivePoly
exposed: n
type: (SparseUnivariatePolynomial(GF))->Union(SparseUnivariatePolynomial(GF),failed)
params: pFiniteFieldPolynomialPackage(GF)
comment:
\spad{nextNormalPrimitivePoly(f)} yields the next normal primitive polynomial over a finite field {\em GF} of the same degree as \spad{f} in the following order,{} or failed if there are no greater ones. Error: if \spad{f} has degree 0. Note: the input polynomial \spad{f} is made monic. \spad{cnlexSmaller?} is used as ordering predicate. This operation is equivalent to nextPrimitiveNormalPoly(\spad{f}).


kind: o
name: nextPartition
exposed: x
type: (List(Integer),Vector(Integer),Integer)->Vector(Integer)
params: pSymmetricGroupCombinatoricFunctions
comment:
\spad{nextPartition(gamma,{} part,{} number)} generates the partition of {\em number} which follows {\em part} according to the right-to-left lexicographical order. The partition has the property that its components do not exceed the corresponding components of {\em gamma}. the first partition is achieved by {\em part=[]}. Also,{} {\em []} indicates that {\em part} is the last partition.


kind: o
name: nextPartition
exposed: x
type: (Vector(Integer),Vector(Integer),Integer)->Vector(Integer)
params: pSymmetricGroupCombinatoricFunctions
comment:
\spad{nextPartition(gamma,{} part,{} number)} generates the partition of {\em number} which follows {\em part} according to the right-to-left lexicographical order. The partition has the property that its components do not exceed the corresponding components of {\em gamma}. The first partition is achieved by {\em part=[]}. Also,{} {\em []} indicates that {\em part} is the last partition.


kind: o
name: nextPrimitiveNormalPoly
exposed: n
type: (SparseUnivariatePolynomial(GF))->Union(SparseUnivariatePolynomial(GF),failed)
params: pFiniteFieldPolynomialPackage(GF)
comment:
\spad{nextPrimitiveNormalPoly(f)} yields the next primitive normal polynomial over a finite field {\em GF} of the same degree as \spad{f} in the following order,{} or failed if there are no greater ones. Error: if \spad{f} has degree 0. Note: the input polynomial \spad{f} is made monic. \spad{cnlexSmaller?} is used as ordering predicate. This operation is equivalent to nextNormalPrimitivePoly(\spad{f}).


kind: o
name: nextPrimitivePoly
exposed: n
type: (SparseUnivariatePolynomial(GF))->Union(SparseUnivariatePolynomial(GF),failed)
params: pFiniteFieldPolynomialPackage(GF)
comment:
\spad{nextPrimitivePoly(f)} yields the next primitive polynomial over a finite field {\em GF} of the same degree as \spad{f} in the following order,{} or failed if there are no greater ones. Error: if \spad{f} has degree 0. Note: the input polynomial \spad{f} is made monic. \spad{clexSmaller?} is used as ordering predicate.


kind: o
name: next_sousResultant2
exposed: n
type: (polR,polR,polR,R)->polR
params: pPseudoRemainderSequence(R,polR)
comment:
\spad{next_sousResultant2(P,{} Q,{} Z,{} s)} returns the subresultant \spad{S_{e-1}} where \spad{P ~ S_d,{} Q = S_{d-1},{} Z = S_e,{} s = lc(S_d)}


kind: o
name: next_subResultant2
exposed: x
type: (%,%,%,%)->%
params: cRecursivePolynomialCategory(R,E,V)
abbrev: has(R,IntegralDomain)
comment:
\spad{next_subResultant2(p,{} q,{} z,{} s)} is the multivariate version of the operation \spadopFrom{\spad{next_sousResultant2}}{PseudoRemainderSequence} from the \spadtype{PseudoRemainderSequence} constructor.


kind: o
name: nextSubsetGray
exposed: n
type: (Vector(Vector(Integer)),PositiveInteger)->Vector(Vector(Integer))
params: pGrayCode
comment:
\spad{nextSubsetGray(ww,{} n)} returns a vector {\em vv} whose components have the following meanings: \begin{items} \item {\em vv.1}: a vector of length \spad{n} whose entries are 0 or 1. This \indented{3}{can be interpreted as a code for a subset of the set 1,{} ...,{} \spad{n};} \indented{3}{{\em vv.1} differs from {\em ww.1} by exactly one entry;} \item {\em vv.2.1} is the number of the entry of {\em vv.1} which \indented{3}{will be changed next time;} \item {\em vv.2.1 = n+1} means that {\em vv.1} is the last subset; \indented{3}{trying to compute nextSubsetGray(\spad{vv}) if {\em vv.2.1 = n+1}} \indented{3}{will produce an error!} \end{items} The other components of {\em vv.2} are needed to compute nextSubsetGray efficiently. Note: this is an implementation of [Williamson,{} Topic II,{} 3.54,{} \spad{p}. 112] for the special case {\em r1 = r2 = ... = rn = 2}; Note: nextSubsetGray produces a side-effect,{} \spadignore{i.e.} {\em nextSubsetGray(vv)} and {\em vv := nextSubsetGray(vv)} will have the same effect.


kind: o
name: nilFactor
exposed: x
type: (R,NonNegativeInteger)->%
params: dFactored(R)
comment:
\spad{nilFactor(base,{} exponent)} creates a factored object with a single factor with no information about the kind of \spad{base} (flag = nil).


kind: o
name: nlde
exposed: n
type: (Stream(Stream(A)))->Stream(A)
params: pStreamTaylorSeriesOperations(A)
abbrev: has(A,Algebra(Fraction(Integer)))
comment:
\spad{nlde(u)} solves a first order non-linear differential equation described by \spad{u} of the form \spad{[[b<0,{} 0>,{} b<0,{} 1>,{} ...],{} [b<1,{} 0>,{} b<1,{} 1>,{} .],{} ...]}. the differential equation has the form \spad{y' = sum(i=0 to infinity,{} j=0 to infinity,{} b<i,{} j>*(x^i)*(y^j))}.


kind: o
name: nlexSmaller?
exposed: n
type: (SparseUnivariatePolynomial(GF),SparseUnivariatePolynomial(GF))->Boolean
params: pFiniteFieldPolynomialPackage(GF)
comment:
\spad{nlexSmaller?(f,{} g)} compares monic \spad{f} and \spad{g} of the same degree \spad{n} in the following order. Error: if \spad{f} or \spad{g} is not monic or if \spad{f} and \spad{g} have different degrees or if common degree is 0. \spad{f < g} if the coefficient of the term of degree {\em n-1} of \spad{f} is zero and than that for \spad{g} is nonzero. Also,{} \spad{f < g} if both coefficients are nonzero and {\em lookup} of the coefficient of \spad{f} is less than that for \spad{g}. In case those coefficients are equal,{} then \spad{lexSmaller?} is used as ordering predicate.


kind: o
name: node?
exposed: x
type: (%,%)->Boolean
params: cRecursiveAggregate(S)
abbrev: has(S,BasicType)
comment:
\spad{node?(u,{} v)} tests if node \spad{u} is contained in node \spad{v} (either as a child,{} a child of a child,{} etc.).


kind: o
name: node
exposed: x
type: (%,S,%)->%
params: cBinaryTreeCategory(S)
comment:
\spad{node(l,{} v,{} r)} creates a binary tree with value \spad{v},{} left subtree \spad{l},{} and right subtree \spad{r}.


kind: o
name: nodeFromArrow
exposed: n
type: (%,NonNegativeInteger)->List(NonNegativeInteger)
params: cFiniteGraph(S)
comment:
\spad{nodeFromArrow(s,{} a)} returns index of all nodes with a direct arrow leading in to arrow 'a' in graph \spad{'s'}


kind: o
name: nodeFromNode
exposed: n
type: (%,NonNegativeInteger)->List(NonNegativeInteger)
params: cFiniteGraph(S)
comment:
\spad{nodeFromNode(s,{} a)} gives list of all nodes with a direct arrow leading in to node 'a' in graph \spad{'s'}


kind: o
name: nodeToArrow
exposed: n
type: (%,NonNegativeInteger)->List(NonNegativeInteger)
params: cFiniteGraph(S)
comment:
\spad{nodeToArrow(s,{} a)} returns index of all nodes with a direct arrow leading out of arrow 'a' in graph \spad{'s'}


kind: o
name: nodeToNode
exposed: n
type: (%,NonNegativeInteger)->List(NonNegativeInteger)
params: cFiniteGraph(S)
comment:
\spad{nodeToNode(s,{} a)} gives list of all nodes with a direct arrow leading out of node 'a' in graph \spad{'s'}


kind: o
name: noLinearFactor?
exposed: n
type: (UP)->Boolean
params: pBrillhartTests(UP)
comment:
\spad{noLinearFactor?(p)} returns \spad{true} if \spad{p} can be shown to have no linear factor by a theorem of Lehmer,{} \spad{false} else. \spad{I} insist on the fact that \spad{false} does not mean that \spad{p} has a linear factor.


kind: o
name: nonSingularModel
exposed: n
type: (Symbol)->List(Polynomial(F))
params: xFunctionFieldCategory&(S,F,UP,UPUP)
comment:
\spad{nonSingularModel(u)} returns the equations in \spad{u1},{} ...,{} un of an affine non-singular model for the curve.


kind: o
name: norm
exposed: n
type: (UP)->R
params: pComplexRootFindingPackage(R,UP)
comment:
\spad{norm(p)} determines sum of absolute values of coefficients Note: this function depends on \spadfunFrom{abs}{Complex}.


kind: o
name: norm
exposed: x
type: (PolE)->PolR
params: pNormInMonogenicAlgebra(R,PolR,E,PolE)
comment:
\spad{norm q} returns the norm of \spad{q},{} \spadignore{i.e.} the product of all the conjugates of \spad{q}.


kind: o
name: norm
exposed: x
type: (%)->R
params: cFiniteRankAlgebra(R,UP)
comment:
\spad{norm(a)} returns the determinant of the regular representation of \spad{a} with respect to any basis.


kind: o
name: norm
exposed: x
type: (%)->R
params: cOctonionCategory(R)
comment:
\spad{norm(o)} returns the norm of an octonion,{} equal to the sum of the squares of its coefficients.


kind: o
name: norm
exposed: x
type: (%,Kernel(%))->%
params: dAlgebraicNumber
comment:
\spad{norm(f,{} k)} computes the norm of the algebraic number \spad{f} with respect to the extension generated by kernel \spad{k}


kind: o
name: norm
exposed: x
type: (%,List(Kernel(%)))->%
params: dAlgebraicNumber
comment:
\spad{norm(f,{} l)} computes the norm of the algebraic number \spad{f} with respect to the extension generated by kernels \spad{l}


kind: o
name: norm
exposed: x
type: (%,PositiveInteger)->%
params: cFiniteAlgebraicExtensionField(F)
abbrev: has(F,Finite)
comment:
\spad{norm(a,{} d)} computes the norm of \spad{a} with respect to the intermediate field of extension degree \spad{d} over the ground field \spad{F}. Error: if \spad{d} does not divide the extension degree \spad{n} of \spad{\%}. Note: norm(a,{} \spad{d}) = reduce(*,{} [a^(\spad{q^}(d*i)) for \spad{i} in 0..\spad{n/d}]) where \spad{q} is size of \spad{F}.


kind: o
name: norm
exposed: x
type: (SparseUnivariatePolynomial(%),Kernel(%))->SparseUnivariatePolynomial(%)
params: dAlgebraicNumber
comment:
\spad{norm(p,{} k)} computes the norm of the polynomial \spad{p} with respect to the extension generated by kernel \spad{k}


kind: o
name: norm
exposed: x
type: (SparseUnivariatePolynomial(%),List(Kernel(%)))->SparseUnivariatePolynomial(%)
params: dAlgebraicNumber
comment:
\spad{norm(p,{} l)} computes the norm of the polynomial \spad{p} with respect to the extension generated by kernels \spad{l}


kind: o
name: normal?
exposed: n
type: (SparseUnivariatePolynomial(GF))->Boolean
params: pFiniteFieldPolynomialPackage(GF)
comment:
\spad{normal?(f)} tests whether the polynomial \spad{f} over a finite field is normal,{} \spadignore{i.e.} its roots are linearly independent over the field.


kind: o
name: normal?
exposed: x
type: (%)->Boolean
params: cFiniteAlgebraicExtensionField(F)
abbrev: has(F,Finite)
comment:
\spad{normal?(a)} tests whether the element \spad{a} is normal over the ground field \spad{F},{} \spadignore{i.e.} \spad{a^(q^i),{} 0 <= i <= extensionDegree()-1} is an \spad{F}-basis,{} where \spad{q = size()\$F}. Implementation according to Lidl/Niederreiter: Theorem 2.39.


kind: o
name: normalDenom
exposed: n
type: (Fraction(UP),(UP)->UP)->UP
params: pMonomialExtensionTools(F,UP)
comment:
\spad{normalDenom(f,{} D)} returns the product of all the normal factors of \spad{denom(f)}. \spad{D} is the derivation to use.


kind: o
name: normalElement
exposed: x
type: ()->%
params: cFiniteAlgebraicExtensionField(F)
abbrev: has(F,Finite)
comment:
\spad{normalElement()} returns a element,{} normal over the ground field \spad{F},{} \spadignore{i.e.} \spad{a^(q^i),{} 0 <= i < extensionDegree()} is an \spad{F}-basis,{} where \spad{q = size()\$F}. At the first call,{} the element is computed by \spadfunFrom{createNormalElement}{FiniteAlgebraicExtensionField} then cached in a global variable. On subsequent calls,{} the element is retrieved by referencing the global variable.


kind: o
name: normalElement
exposed: n
type: (PositiveInteger)->Vector(GF)
params: pInnerNormalBasisFieldFunctions(GF)
comment:
\spad{normalElement(n)} \undocumented{} See \spadfunFrom{normalElement}{FiniteAlgebraicExtensionField}


kind: o
name: normalForm
exposed: x
type: (Dpol,List(Dpol))->Dpol
params: pGroebnerPackage(Dom,Expon,Dpol)
abbrev: has(Dom,Field)
comment:
\spad{normalForm(poly,{} gb)} reduces the polynomial \spad{poly} modulo the precomputed groebner basis \spad{gb} giving a canonical representative of the residue class.


kind: o
name: normalForm
exposed: n
type: (Matrix(K),Automorphism(K),(K)->K)->Record(R:Matrix(K),A:Matrix(K),Ainv:Matrix(K))
params: pPseudoLinearNormalForm(K)
comment:
\spad{normalForm(M,{} sig,{} der)} returns \spad{[R,{} A,{} A^{-1}]} such that the pseudo-linear operator whose matrix in the basis \spad{y} is \spad{M} had matrix \spad{R} in the basis \spad{z = A y}. \spad{der} is a \spad{sig}-derivation.


kind: o
name: normalise
exposed: x
type: (Matrix(Expression(Integer)))->Matrix(Expression(Integer))
params: pRadicalEigenPackage
comment:
\spad{normalise(v)} returns the column vector \spad{v} divided by its euclidean norm; when possible,{} the vector \spad{v} is expressed in terms of radicals.


kind: o
name: normalize!
exposed: n
type: (%)->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{normalize!(f)} rescales the rows such that the first nonzero entry of the coefficient matrix in the diagonal is one. The right hand side is normalized by normalizeRHS! and the non-zero entry is in the last row of the corresponding block.


kind: o
name: normalize
exposed: x
type: (F)->F
params: pElementaryFunctionStructurePackage(R,F)
comment:
\spad{normalize(f)} rewrites \spad{f} using the least possible number of real algebraically independent kernels.


kind: o
name: normalize
exposed: x
type: (List(F),List(Symbol))->List(F)
params: pElementaryFunctionStructurePackage(R,F)
comment:
\spad{normalize([f1,{} ...,{} fn],{} lx)} rewrites \spad{f1,{} ...,{} fn} using the least possible number of real algebraically independent kernels. Additionally,{} it tries to ensure that any expression in resulting kernels which syntactically depends on a variable \spad{x} from \spad{lx} has nonzero derivative with respect to \spad{x}.


kind: o
name: normalized?
exposed: x
type: (%)->Boolean
params: cTriangularSetCategory(R,E,V,P)
comment:
\spad{normalized?(ts)} returns \spad{true} iff for every \spad{p} in \spad{ts} we have \spad{normalized?(p,{} us)} where \spad{us} is \spad{collectUnder(ts,{} mvar(p))}.


kind: o
name: normalized?
exposed: x
type: (%,%)->Boolean
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{normalized?(a,{} b)} returns \spad{true} iff \spad{a} and its iterated initials have degree zero \spad{w}.\spad{r}.\spad{t}. the main variable of \spad{b}


kind: o
name: normalized?
exposed: x
type: (%,List(%))->Boolean
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{normalized?(q,{} lp)} returns \spad{true} iff \spad{normalized?(q,{} p)} holds for every \spad{p} in \spad{lp}.


kind: o
name: normalized?
exposed: x
type: (P,%)->Boolean
params: cTriangularSetCategory(R,E,V,P)
comment:
\spad{normalized?(p,{} ts)} returns \spad{true} iff \spad{p} and all its iterated initials have degree zero \spad{w}.\spad{r}.\spad{t}. the main variables of the polynomials of \spad{ts}


kind: o
name: normalizedAssociate
exposed: x
type: (P,TS)->P
params: pNormalizationPackage(R,E,V,P,TS)
comment:
\spad{normalizedAssociate(p,{} ts)} returns a normalized polynomial \spad{n} \spad{w}.\spad{r}.\spad{t}. \spad{ts} such that \spad{n} and \spad{p} are associates \spad{w}.\spad{r}.\spad{t} \spad{ts} and assuming that \spad{p} is invertible \spad{w}.\spad{r}.\spad{t} \spad{ts}.


kind: o
name: normalizedDivide
exposed: n
type: (R,R)->Record(quotient:R,remainder:R)
params: pModularHermitianRowReduction(R)
comment:
\spad{normalizedDivide(n,{} d)} returns a normalized quotient and remainder such that consistently unique representatives for the residue class are chosen,{} \spadignore{e.g.} positive remainders


kind: o
name: normalizeDIAG!
exposed: n
type: (%)->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{normalizeDIAG!(f)} rescales the rows such that the first nonzero entry of the coefficient matrix in the diagonal is one.


kind: o
name: normalizeIfCan
exposed: n
type: (ST)->ST
params: pLazardSetSolvingPackage(R,E,V,P,TS,ST)
comment:
\spad{normalizeIfCan(ts)} returns \spad{ts} in an normalized shape if \spad{ts} is zero-dimensional.


kind: o
name: normalizePLS!
exposed: n
type: (%)->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{normalizePLS!(f)} scales and rearranges rows and columns of the system matrix such that the constant part of the system matrix is the identity matrix (possibly of smaller size).


kind: o
name: normalizeRHS!
exposed: n
type: (%)->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{normalizeRHS!(f)} eliminates non-zero entries in the right hand side of ALS with respect of the non-zero entry with the highest index.


kind: o
name: nothing
exposed: n
type: ()->(Integer,List(OutputForm))->OutputBox
params: cFormatterCategory
comment:
\spad{nothing()} returns a handler \spad{h} such that \spad{h(prec,{} args)} returns an empty box. This corresponds to NOTHING in \spad{OutputForm}.


kind: o
name: npcoef
exposed: n
params: pNPCoef(BP,E,OV,R,P)
type:
(SparseUnivariatePolynomial(P),List(BP),List(P))->Record(deter:List(SparseUnivariatePolynomial(P)),dterm:List(List(Record(expt:NonNegativeInteger,pcoef:P))),nfacts:List(BP),nlead:List(P))

comment:
\spad{npcoef(p,{} lmf,{} lcf)} tries to determine some coefficients of factors of \spad{p} assuming that \spad{lcf} gives \spad{true} leading coefficients of the factors and that sparsity pattern of modular factors \spad{lmf} is the same as sparsity pattern of \spad{true} factors. If \spad{res} is the result,{} then \spad{res.deter} gives fully determined factors,{} \spad{res.dterm} gives determined terms of partially determinaed factors,{} \spad{res.nfacts} and \spad{res.nlead} give modular factors and leading coefficients corresponding to undetermined factors.


kind: o
name: nsqfree
exposed: n
params: pMultivariateSquareFree(E,OV,R,P)
comment: \spad{nsqfree should} be local
type:
(SparseUnivariatePolynomial(P),List(OV),List(List(R)))->Record(unitPart:P,suPart:List(Record(factor:SparseUnivariatePolynomial(P),exponent:NonNegativeInteger)))


kind: o
name: nthRoot
exposed: n
type: (Factored(M),NonNegativeInteger)->Record(exponent:NonNegativeInteger,coef:M,radicand:List(M))
params: pFactoredFunctions(M)
comment:
\spad{nthRoot(f,{} n)} returns \spad{(p,{} r,{} [r1,{} ...,{} rm])} such that the \spad{n}th-root of \spad{f} is equal to \spad{r * \spad{p}th-root(r1 * ... * rm)},{} where \spad{r1},{} ...,{} \spad{rm} are distinct factors of \spad{f},{} each of which has an exponent smaller than \spad{p} in \spad{f}.


kind: o
name: nthRoot
exposed: n
params: cFormatterCategory
type:
(Integer,(Integer,List(OutputForm))->OutputBox,(Integer,List(OutputForm))->OutputBox)->(Integer,List(OutputForm))->OutputBox

comment:
Format square roots and \spad{n}th roots. \spad{nthRoot(p,{} h1,{} h2)} returns a handler \spad{h} such that \spad{h(prec,{} args)} formats the first argument according to \spad{h1}. If there is no second argument,{} then the \spad{n}th root is a square root and formatted accordingly. Otherwise the second argument is formatted by \spad{h2}. Outer parentheses are added if \spad{p < prec}.


kind: o
name: nthRootIfCan
exposed: x
type: (K,NonNegativeInteger)->Union(K,failed)
params: cPartialTranscendentalFunctions(K)
comment:
\spad{nthRootIfCan(z,{} n)} returns the \spad{n}th root of \spad{z} if possible,{} and failed otherwise.


kind: o
name: nullBoundary
exposed: n
type: ()->%
params: dSBoundary(PT)
comment:
\spad{nullBoundary()} constructs a null boundary,{} for example,{} when the boundary of a material node is requested.


kind: o
name: nullity
exposed: n
type: (M)->NonNegativeInteger
params: pInnerMatrixLinearAlgebraFunctions(R,Row,Col,M)
comment:
\spad{nullity(m)} returns the mullity of the matrix \spad{m}. This is the dimension of the null space of the matrix \spad{m}.


kind: o
name: nullity
exposed: x
type: (%)->NonNegativeInteger
params: cMatrixCategory(R,Row,Col)
abbrev: has(R,IntegralDomain)
comment:
\spad{nullity(m)} returns the nullity of the matrix \spad{m}. This is the dimension of the null space of the matrix \spad{m}.


kind: o
name: nullSpace
exposed: n
type: (Matrix(R))->%
params: dVectorSpaceBasis(R)
comment:
\spad{nullSpace M} builds a basis of the kernel of the linear transformation defined by the matrix \spad{M}. This function calls the function \spad{nullSpace} from the \spad{Matrix} domain. Only the signature changes.


kind: o
name: nullSpaceOverConstants
exposed: n
type: (Matrix(F),List((F)->F))->List(Vector(F))
params: pConstantLinearDependence(R,F)
comment:
\spad{nullSpaceOverConstants(A,{} ld)} returns basis of the homogeneous system \spad{A*vc = 0} where \spad{vc} is a vector of constants.


kind: o
name: numberOfComponents
exposed: x
type: (%)->NonNegativeInteger
params: cThreeSpaceCategory(R)
comment:
\spad{numberOfComponents(s)} returns the number of distinct object components in the indicated \spadtype{ThreeSpace},{} \spad{s},{} such as points,{} curves,{} polygons,{} and constructs.


kind: o
name: numberOfComposites
exposed: x
type: (%)->NonNegativeInteger
params: cThreeSpaceCategory(R)
comment:
\spad{numberOfComposites(s)} returns the number of supercomponents,{} or composites,{} in the \spadtype{ThreeSpace},{} \spad{s}; Composites are arbitrary groupings of otherwise distinct and unrelated components; A \spadtype{ThreeSpace} need not have any composites defined at all and,{} outside of the requirement that no component can belong to more than one composite at a time,{} the definition and interpretation of composites are unrestricted.


kind: o
name: numberOfComputedEntries
exposed: x
type: (%)->NonNegativeInteger
params: cLazyStreamAggregate(S)
comment:
\spad{numberOfComputedEntries(st)} returns the number of explicitly computed entries of stream \spad{st} which exist immediately prior to the time this function is called.


kind: o
name: numberOfDivisors
exposed: x
type: (Integer)->Integer
params: pIntegerNumberTheoryFunctions
comment:
\spad{numberOfDivisors(n)} returns the number of integers between 1 and \spad{n} (inclusive) which divide \spad{n}. The number of divisors of \spad{n} is often denoted by \spad{tau(n)}.


kind: o
name: numberOfFactors
exposed: n
type: (List(Record(factor:UP,degree:Integer)))->NonNegativeInteger
params: pGaloisGroupFactorizer(UP)
comment:
\spad{numberOfFactors(ddfactorization)} returns the number of factors of the polynomial \spad{f} modulo \spad{p} where \spad{ddfactorization} is the distinct degree factorization of \spad{f} computed by modular factorization package for some prime \spad{p}.


kind: o
name: numberOfFractionalTerms
exposed: x
type: (%)->Integer
params: dPartialFraction(R)
comment:
\spad{numberOfFractionalTerms(p)} computes the number of fractional terms in \spad{p}. This returns 0 if there is no fractional part.


kind: o
name: numberOfImproperPartitions
exposed: x
type: (Integer,Integer)->Integer
params: pSymmetricGroupCombinatoricFunctions
comment:
\spad{numberOfImproperPartitions(n,{} m)} computes the number of partitions of the nonnegative integer \spad{n} in \spad{m} nonnegative parts with regarding the order (improper partitions). Example: {\em numberOfImproperPartitions (3,{} 3)} is 10,{} since {\em [0,{} 0,{} 3],{} [0,{} 1,{} 2],{} [0,{} 2,{} 1],{} [0,{} 3,{} 0],{} [1,{} 0,{} 2],{} [1,{} 1,{} 1],{} [1,{} 2,{} 0],{} [2,{} 0,{} 1],{} [2,{} 1,{} 0],{} [3,{} 0,{} 0]} are the possibilities. Note: this operation has a recursive implementation.


kind: o
name: numberOfIrreduciblePoly
exposed: n
type: (PositiveInteger)->PositiveInteger
params: pFiniteFieldPolynomialPackage(GF)
comment:
\spad{numberOfIrreduciblePoly(n)}\$FFPOLY(\spad{GF}) yields the number of monic irreducible univariate polynomials of degree \spad{n} over the finite field {\em GF}.


kind: o
name: numberOfNormalPoly
exposed: n
type: (PositiveInteger)->PositiveInteger
params: pFiniteFieldPolynomialPackage(GF)
comment:
\spad{numberOfNormalPoly(n)}\$FFPOLY(\spad{GF}) yields the number of normal polynomials of degree \spad{n} over the finite field {\em GF}.


kind: o
name: numberOfPrimes
exposed: n
type: (OutputForm)->Integer
params: cFormatterCategory
comment:
\spad{numberOfPrimes(e)} counts the number of commas in \spad{e} and returns it. If \spad{s} does not only contain commas,{} but has a parenthesis at the beginning and the end of the string,{} then the part between the parentheses is interpreted as a roman numeral and translated into an integer. For any other format the function returns \spad{-1}.


kind: o
name: numberOfPrimitivePoly
exposed: n
type: (PositiveInteger)->PositiveInteger
params: pFiniteFieldPolynomialPackage(GF)
comment:
\spad{numberOfPrimitivePoly(n)}\$FFPOLY(\spad{GF}) yields the number of primitive polynomials of degree \spad{n} over the finite field {\em GF}.


kind: o
name: numer
exposed: x
type: (%)->SparseMultivariatePolynomial(Integer,Kernel(%))
params: dAlgebraicNumber
comment:
\spad{numer(f)} returns the numerator of \spad{f} viewed as a polynomial in the kernels over \spad{Z}.


kind: o
name: numer
exposed: x
type: (%)->SparseMultivariatePolynomial(R,K)
params: cFunctionSpace2(R,K)
abbrev: has(R,Ring)
comment:
\spad{numer(f)} returns the numerator of \spad{f} viewed as a polynomial in the kernels over \spad{R} if \spad{R} is an integral domain. If not,{} then numer(\spad{f}) = \spad{f} viewed as a polynomial in the kernels over \spad{R}.


kind: o
name: numerators
exposed: x
type: (%)->Stream(R)
params: dContinuedFraction(R)
comment:
\spad{numerators(x)} returns the stream of numerators of the approximants of the continued fraction \spadvar{\spad{x}}. If the continued fraction is finite,{} then the stream will be finite.


kind: o
name: numericIfCan
exposed: x
type: (Expression(S))->Union(Float,failed)
params: pNumeric(S)
abbrev: AND(has(S,IntegralDomain),has(S,OrderedSet))
comment:
\spad{numericIfCan(x)} returns a real approximation of \spad{x},{} or failed if \spad{x} is not a constant.


kind: o
name: numericIfCan
exposed: x
type: (Expression(S),PositiveInteger)->Union(Float,failed)
params: pNumeric(S)
abbrev: AND(has(S,IntegralDomain),has(S,OrderedSet))
comment:
\spad{numericIfCan(x,{} n)} returns a real approximation of \spad{x} up to \spad{n} decimal places,{} or failed if \spad{x} is not a constant.


kind: o
name: obj
exposed: x
type: (%)->None
params: dAny
comment:
\spad{obj(a)} essentially returns the original object that was converted to \spadtype{Any} except that the type is forced to be \spadtype{None}.


kind: o
name: objectOf
exposed: x
type: (%)->OutputForm
params: dAny
comment:
\spad{objectOf(a)} returns a printable form of the original object that was converted to \spadtype{Any}.


kind: o
name: objects
exposed: x
params: cThreeSpaceCategory(R)
type:
(%)->Record(points:NonNegativeInteger,curves:NonNegativeInteger,polygons:NonNegativeInteger,constructs:NonNegativeInteger)

comment:
\spad{objects(s)} returns the \spadtype{ThreeSpace},{} \spad{s},{} in the form of a 3D object record containing information on the number of points,{} curves,{} polygons and constructs comprising the \spadtype{ThreeSpace}..


kind: o
name: oblateSpheroidal
exposed: x
type: (R)->(Point(R))->Point(R)
params: pCoordinateSystems(R)
comment:
\spad{oblateSpheroidal(a)} transforms from oblate spheroidal coordinates to Cartesian coordinates: \spad{oblateSpheroidal(a)} is a function which will map the point \spad{(\spad{xi},{} eta,{} phi)} to \spad{x = a*sinh(\spad{xi})*sin(eta)*cos(phi)},{} \spad{y = a*sinh(\spad{xi})*sin(eta)*sin(phi)},{} \spad{z = a*cosh(\spad{xi})*cos(eta)}.


kind: o
name: octon
exposed: x
type: (Quaternion(R),Quaternion(R))->%
params: dOctonion(R)
comment:
\spad{octon(qe,{} qE)} constructs an octonion from two quaternions using the relation {\em O = Q + QE}.


kind: o
name: octon
exposed: x
type: (R,R,R,R,R,R,R,R)->%
params: cOctonionCategory(R)
comment:
\spad{octon(re,{} \spad{ri},{} rj,{} rk,{} rE,{} rI,{} rJ,{} rK)} constructs an octonion from scalars.


kind: o
name: odd?
exposed: x
type: (%)->Boolean
params: dPermutation(S)
comment:
\spad{odd?(p)} returns \spad{true} if and only if \spad{p} is an odd permutation \spadignore{i.e.} {\em sign(p)} is {\em -1}.


kind: o
name: oddInfiniteProduct
exposed: x
type: (UTS)->UTS
params: pInfiniteLambertProduct(Coef,UTS)
comment:
\spad{oddInfiniteProduct(f(x))} computes \spad{product(n=1,{} 3,{} 5...,{} f(x^n))}. The series \spad{f(x)} should have constant coefficient 1.


kind: o
name: oddlambert
exposed: n
type: (%)->%
params: dUnivariateTaylorSeries(Coef,var,cen)
comment:
\spad{oddlambert(f(x))} returns \spad{f(x) + f(x^3) + f(x^5) + ...}. \indented{1}{\spad{f(x)} should have a zero constant coefficient.} \indented{1}{This function is used for computing infinite products.} \indented{1}{If \spad{f(x)} is a Taylor series with constant term 1,{} then} \indented{1}{\spad{product(n=1..infinity,{} f(x^(2*n-1)))=exp(oddlambert(log(f(x))))}.}


kind: o
name: oddlambert
exposed: n
type: (Stream(A))->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{oddlambert(st)} computes \spad{f(x) + f(x^3) + f(x^5) + ...} if \spad{st} is a stream representing \spad{f(x)}. This function is used for computing infinite products. If \spad{f}(\spad{x}) is a power series with constant coefficient 1 then \spad{prod(f(x^(2*n-1)),{} n=1..infinity) = exp(oddlambert(log(f(x))))}.


kind: o
name: odd_partitions
exposed: x
type: (Integer)->Stream(List(Integer))
params: pPartitionsAndPermutations
comment:
\spad{odd_partitions(n)} is the stream of all partitions \indented{1}{of \spad{n} into odd numbers.}


kind: o
name: odd_partitions
exposed: x
type: (Integer,Integer,Integer)->Stream(List(Integer))
params: pPartitionsAndPermutations
comment:
\spad{odd_partitions(p,{} l,{} n)} is the stream of partitions \indented{1}{of \spad{n} into odd numbers whose number of parts is no greater than \spad{p}} \indented{1}{and whose largest part is no greater than \spad{l}.}


kind: o
name: ode2
exposed: n
type: ((UTS,UTS)->UTS,Coef,Coef)->UTS
params: pUnivariateTaylorSeriesODESolver(Coef,UTS)
comment:
\spad{ode2(f,{} c0,{} c1)} is the solution to \spad{y'' = f(y,{} y')} such that \spad{y(a) = c0} and \spad{y'(a) = c1}.


kind: o
name: ode
exposed: n
type: ((List(UTS))->UTS,List(Coef))->UTS
params: pUnivariateTaylorSeriesODESolver(Coef,UTS)
comment:
\spad{ode(f,{} cl)} is the solution to \spad{y<n>=f(y,{} y',{} ..,{} y<n-1>)} such that \spad{y<i>(a) = cl.(i+1)} for \spad{i} in 0..(\spad{n} - 1).


kind: o
name: OMencodingUnknown
exposed: x
type: ()->%
params: dOpenMathEncoding
comment:
\spad{OMencodingUnknown()} is the constant for unknown encoding types. If this is used on an input device,{} the encoding will be autodetected. It is invalid to use it on an output device.


kind: o
name: OMopenFile
exposed: x
type: (String,String,OpenMathEncoding)->%
params: dOpenMathDevice
comment:
\spad{OMopenFile(f,{} mode,{} enc)} opens file \spad{f} for reading or writing OpenMath objects (depending on \spad{mode} which can be \spad{r},{} \spad{w} or a for read,{} write and append respectively),{} in the encoding \spad{enc}.


kind: o
name: OMopenString
exposed: x
type: (String,OpenMathEncoding)->%
params: dOpenMathDevice
comment:
\spad{OMopenString(s,{} mode)} opens the string \spad{s} for reading or writing OpenMath objects in encoding \spad{enc}.


kind: o
name: OMputSymbol
exposed: x
type: (%,String,String)->Void
params: dOpenMathDevice
comment:
\spad{OMputSymbol(dev,{} cd,{} s)} writes the symbol \spad{s} from \spad{CD} \spad{cd} to \spad{dev}.


kind: o
name: OMreceive
exposed: x
type: (OpenMathConnection)->Any
params: pOpenMathServerPackage
comment:
\spad{OMreceive(c)} reads an OpenMath object from connection \spad{c} and returns the appropriate FriCAS object.


kind: o
name: OMserve
exposed: x
type: (SingleInteger,SingleInteger)->Void
params: pOpenMathServerPackage
comment:
\spad{OMserve(portnum,{} timeout)} puts FriCAS into server mode on port number \spad{portnum}. The parameter \spad{timeout} specifies the timeout period for the connection.


kind: o
name: OMsetEncoding
exposed: x
type: (%,OpenMathEncoding)->Void
params: dOpenMathDevice
comment:
\spad{OMsetEncoding(dev,{} enc)} sets the encoding used for reading or writing OpenMath objects to or from \spad{dev} to \spad{enc}.


kind: o
name: OMsupportsCD?
exposed: x
type: (String)->Boolean
params: pOpenMathPackage
comment:
\spad{OMsupportsCD?(cd)} returns \spad{true} if FriCAS supports \spad{cd},{} \spad{false} otherwise.


kind: o
name: OMsupportsSymbol?
exposed: x
type: (String,String)->Boolean
params: pOpenMathPackage
comment:
\spad{OMsupportsSymbol?(s,{} cd)} returns \spad{true} if FriCAS supports symbol \spad{s} from \spad{CD} \spad{cd},{} \spad{false} otherwise.


kind: o
name: OMunhandledSymbol
exposed: x
type: (String,String)->Exit
params: pOpenMathPackage
comment:
\spad{OMunhandledSymbol(s,{} cd)} raises an error if FriCAS reads a symbol which it is unable to handle. Note that this is different from an unexpected symbol.


kind: o
name: OMwrite
exposed: x
type: (%)->String
params: cOpenMath
comment:
\spad{OMwrite(u)} returns the OpenMath \spad{XML} encoding of \spad{u} as a complete OpenMath object.


kind: o
name: OMwrite
exposed: x
type: (%,Boolean)->String
params: cOpenMath
comment:
\spad{OMwrite(u,{} true)} returns the OpenMath \spad{XML} encoding of \spad{u} as a complete OpenMath object; OMwrite(\spad{u},{} \spad{false}) returns the OpenMath \spad{XML} encoding of \spad{u} as an OpenMath fragment.


kind: o
name: OMwrite
exposed: x
type: (OpenMathDevice,%)->Void
params: cOpenMath
comment:
\spad{OMwrite(dev,{} u)} writes the OpenMath form of \spad{u} to the OpenMath device \spad{dev} as a complete OpenMath object.


kind: o
name: OMwrite
exposed: x
type: (OpenMathDevice,%,Boolean)->Void
params: cOpenMath
comment:
\spad{OMwrite(dev,{} u,{} true)} writes the OpenMath form of \spad{u} to the OpenMath device \spad{dev} as a complete OpenMath object; OMwrite(\spad{dev},{} \spad{u},{} \spad{false}) writes the object as an OpenMath fragment.


kind: o
name: one
exposed: x
type: (Boolean)->%
params: dGuessOption
comment:
\spad{one(d)} specifies whether we are happy with one solution. This option is expressed in the form \spad{one == d}.


kind: o
name: open
exposed: x
type: (Name,String)->%
params: cFileCategory(Name,S)
comment:
\spad{open(s,{} mode)} returns a file \spad{s} open for operation in the indicated mode: input or output.


kind: o
name: operation
exposed: n
params: dFortranCode
comment: \spad{operation(f)} returns the name of the operation represented by \spad{f}.
type:
(%)->Union(Null:null,Assignment:assignment,Conditional:conditional,Return:return,Block:block,Comment:comment,Call:call,For:for,While:while,Repeat:repeat,Goto:goto,Continue:continue,ArrayAssignment:arrayAssignment,Save:save,Stop:stop,Common:common,Print:print)


kind: o
name: operator
exposed: n
type: (BasicOperator)->BasicOperator
params: pAlgebraicFunction(R,F)
comment:
\spad{operator(op)} returns a copy of \spad{op} with the domain-dependent properties appropriate for \spad{F}. Error: if \spad{op} is not an algebraic operator,{} that is,{} an \spad{n}th root or implicit algebraic operator.


kind: o
name: operator
exposed: n
type: (BasicOperator)->BasicOperator
params: pCombinatorialFunction(R,F)
comment:
\spad{operator(op)} returns a copy of \spad{op} with the domain-dependent properties appropriate for \spad{F}; error if \spad{op} is not a combinatorial operator.


kind: o
name: operator
exposed: n
type: (BasicOperator)->BasicOperator
params: pFunctionalSpecialFunction(R,F)
comment:
\spad{operator(op)} returns a copy of \spad{op} with the domain-dependent properties appropriate for \spad{F}; error if \spad{op} is not a special function operator.


kind: o
name: operator
exposed: n
type: (BasicOperator)->BasicOperator
params: xExpressionSpace2&(S,K)
comment:
\spad{operator(op)} returns a copy of \spad{op} with the domain-dependent properties appropriate for \%.


kind: o
name: operator
exposed: n
type: (OutputForm)->OutputForm
params: pOutputFormTools
comment:
\spad{operator(f)} gives operator (head) of form \spad{f}. Valid only when atom?(\spad{f}) is \spad{false}


kind: o
name: operator
exposed: n
type: (Symbol)->BasicOperator
params: pCommonOperators
comment:
\spad{operator(s)} returns an operator with name \spad{s},{} with the appropriate semantics if \spad{s} is known. If \spad{s} is not known,{} the result has no semantics.


kind: o
name: operatorHandlers
exposed: n
type: ()->OperatorHandlers((Integer,List(OutputForm))->OutputBox)
params: cFormatterCategory
comment:
\spad{operatorHandlers()} returns an internal data structure that is used for the selection of respective handlers.


kind: o
name: operators
exposed: x
type: (%)->List(BasicOperator)
params: cExpressionSpace2(K)
comment:
\spad{operators(f)} returns all the basic operators appearing in \spad{f},{} no matter what their levels are.


kind: o
name: opposite
exposed: n
type: (%)->%
params: cPoset(S)
comment:
\spad{opposite(s)} constructs the opposite in the category theory sense of reversing all the arrows.


kind: o
name: option
exposed: n
type: (List(DrawOption),Symbol)->Union(S,failed)
params: pDrawOptionFunctions1(S)
comment:
\spad{option(l,{} s)} determines whether the indicated drawing option,{} \spad{s},{} is contained in the list of drawing options,{} \spad{l},{} which is defined by the draw command.


kind: o
name: option?
exposed: x
type: (List(%),Symbol)->Boolean
params: dDrawOption
comment:
\spad{option?()} is not to be used at the top level; option? internally returns \spad{true} for drawing options which are indicated in a draw command,{} or \spad{false} for those which are not.


kind: o
name: option
exposed: x
type: (List(%),Symbol)->Union(Any,failed)
params: dDrawOption
comment:
\spad{option()} is not to be used at the top level; option determines internally which drawing options are indicated in a draw command.


kind: o
name: optional
exposed: x
type: (F)->F
params: pFunctionSpaceAssertions(R,F)
comment:
\spad{optional(x)} tells the pattern matcher that \spad{x} can match an identity (0 in a sum,{} 1 in a product or exponentiation). Error: if \spad{x} is not a symbol.


kind: o
name: optional
exposed: x
type: (Symbol)->Expression(Integer)
params: pPatternMatchAssertions
comment:
\spad{optional(x)} tells the pattern matcher that \spad{x} can match an identity (0 in a sum,{} 1 in a product or exponentiation).


kind: o
name: options
exposed: n
type: (%)->List(DrawOption)
params: dTwoDimensionalViewport
comment:
\spad{options(v)} takes the given two-dimensional viewport,{} \spad{v},{} of the domain \spadtype{TwoDimensionalViewport} and returns a list containing the draw options from the domain \spadtype{DrawOption} for \spad{v}.


kind: o
name: options
exposed: x
type: (%)->List(DrawOption)
params: dThreeDimensionalViewport
comment:
\spad{options(v)} takes the viewport,{} \spad{v},{} which is of the domain \spadtype{ThreeDimensionalViewport} and returns a list of all the draw options from the domain \spad{DrawOption} which are being used by \spad{v}.


kind: o
name: options
exposed: n
type: (%,List(DrawOption))->%
params: dTwoDimensionalViewport
comment:
\spad{options(v,{} lopt)} takes the given two-dimensional viewport,{} \spad{v},{} of the domain \spadtype{TwoDimensionalViewport} and returns \spad{v} with it\spad{'s} draw options modified to be those which are indicated in the given list,{} \spad{lopt} of domain \spadtype{DrawOption}.


kind: o
name: options
exposed: x
type: (%,List(DrawOption))->%
params: dThreeDimensionalViewport
comment:
\spad{options(v,{} lopt)} takes the viewport,{} \spad{v},{} which is of the domain \spadtype{ThreeDimensionalViewport} and sets the draw options being used by \spad{v} to those indicated in the list,{} \spad{lopt},{} which is a list of options from the domain \spad{DrawOption}.


kind: o
name: optpair
exposed: n
type: (List(%))->Union(List(%),failed)
params: dPattern(R)
comment:
\spad{optpair(l)} returns \spad{l} has the form \spad{[a,{} b]} and a is optional,{} and failed otherwise.


kind: o
name: opType
exposed: n
type: (%)->Symbol
params: dILogic
comment:
if this is a compound op then opType returns the type of that op: IMPLY::Symbol =implies AND::Symbol=/\ OR::Symbol=\spad{\/} NOT::Symbol=~ OTHER::Symbol=not compound op


kind: o
name: Or
exposed: x
type: (%,%)->%
params: dSingleInteger
comment:
\spad{Or(n,{} m)} returns the bit-by-bit logical {\em or} of the single integers \spad{n} and \spad{m}.


kind: o
name: orbit
exposed: x
type: (%,List(S))->Set(List(S))
params: dPermutationGroup(S)
comment:
\spad{orbit(gp,{} ls)} returns the orbit of the ordered list {\em ls} under the group {\em gp}. Note: return type is \spad{L} \spad{L} \spad{S} temporarily because FSET \spad{L} \spad{S} has an error.


kind: o
name: orbit
exposed: x
type: (%,S)->Set(S)
params: cPermutationCategory(S)
comment:
\spad{orbit(p,{} el)} returns the orbit of {\em el} under the permutation \spad{p},{} \spadignore{i.e.} the set which is given by applications of the powers of \spad{p} to {\em el}.


kind: o
name: orbit
exposed: x
type: (%,S)->Set(S)
params: dPermutationGroup(S)
comment:
\spad{orbit(gp,{} el)} returns the orbit of the element {\em el} under the group {\em gp},{} \spadignore{i.e.} the set of all points gained by applying each group element to {\em el}.


kind: o
name: orbits
exposed: x
type: (%)->Set(Set(S))
params: dPermutationGroup(S)
comment:
\spad{orbits(gp)} returns the orbits of the group {\em gp},{} \spadignore{i.e.} it partitions the (finite) of all moved points.


kind: o
name: ord
exposed: x
type: (%)->Integer
params: dCharacter
comment:
\spad{ord(c)} provides an integral code corresponding to the character \spad{c}. It is always \spad{true} that \spad{char ord c = c}.


kind: o
name: order
exposed: n
type: (FiniteDivisor(F,UP,UPUP,R))->Union(NonNegativeInteger,failed)
params: pPointsOfFiniteOrder(R0,F,UP,UPUP,R)
comment:
\spad{order(fd)} returns order of divisor \spad{fd} or \spad{failed} if \spad{fd} is not of finite order.


kind: o
name: order
exposed: n
type: (%)->NonNegativeInteger
params: dInnerTaylorSeries(Coef)
comment:
\spad{order(x)} returns the order of a power series \spad{x},{} \indented{1}{\spadignore{i.e.} the degree of the first non-zero term of the series.}


kind: o
name: order
exposed: x
type: (%)->Expon
params: cUnivariatePowerSeriesCategory(Coef,Expon)
comment:
\spad{order(f)} is the degree of the lowest order non-zero term in \spad{f}. This will result in an infinite loop if \spad{f} has no non-zero terms.


kind: o
name: order
exposed: x
type: (%)->Integer
params: cFloatingPointSystem
comment:
\spad{order x} is the order of magnitude of \spad{x}. Note: \spad{base ^ order x <= |x| < base ^ (1 + order x)}.


kind: o
name: order
exposed: x
type: (%)->NonNegativeInteger
params: cDifferentialPolynomialCategory(R,S,V,E)
comment:
\spad{order(p)} returns the order of the differential polynomial \spad{p},{} which is the maximum number of differentiations of a differential indeterminate,{} among all those appearing in \spad{p}.


kind: o
name: order
exposed: x
type: (%)->NonNegativeInteger
params: cDifferentialVariableCategory(S)
comment:
\spad{order(v)} returns \spad{n} if \spad{v} is the \spad{n}-th derivative of any differential indeterminate.


kind: o
name: order
exposed: x
type: (%)->OnePointCompletion(PositiveInteger)
params: cFieldOfPrimeCharacteristic
comment:
\spad{order(a)} computes the order of an element in the multiplicative group of the field. Error: if \spad{a} is 0.


kind: o
name: order
exposed: x
type: (%)->PositiveInteger
params: cFiniteFieldCategory
comment:
\spad{order(b)} computes the order of an element \spad{b} in the multiplicative group of the field. Error: if \spad{b} equals 0.


kind: o
name: order
exposed: x
type: (%,Expon)->Expon
params: cUnivariatePowerSeriesCategory(Coef,Expon)
comment:
\spad{order(f,{} n) = min(m,{} n)},{} where \spad{m} is the degree of the lowest order non-zero term in \spad{f}.


kind: o
name: order
exposed: x
type: (%,%)->NonNegativeInteger
params: cUnivariatePolynomialCategory(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{order(p,{} q)} returns the largest \spad{n} such that \spad{q^n} divides polynomial \spad{p} \spadignore{i.e.} the order of \spad{p(x)} at \spad{q(x)=0}.


kind: o
name: order
exposed: x
type: (%,S)->NonNegativeInteger
params: cDifferentialPolynomialCategory(R,S,V,E)
comment:
\spad{order(p,{} s)} returns the order of the differential polynomial \spad{p} in differential indeterminate \spad{s}.


kind: o
name: order
exposed: x
type: (%,Var)->NonNegativeInteger
params: cMultivariateTaylorSeriesCategory(Coef,Var)
comment:
\spad{order(f,{} x)} returns the order of \spad{f} viewed as a series in \spad{x} may result in an infinite loop if \spad{f} has no non-zero terms.


kind: o
name: orderDim
exposed: n
type: (List(%),SparseEchelonMatrix(JB,%),NonNegativeInteger)->NonNegativeInteger
params: cJetBundleFunctionCategory(JB)
comment:
\spad{orderDim(sys,{} jm,{} q)} computes the dimension of the manifold described by the system \spad{sys} with Jacobi matrix \spad{jm} in the jet bundle of order \spad{q} over the jet bundle of order \spad{q-1}.


kind: o
name: ordinalPower
exposed: n
type: (%,%)->%
params: dSmallOrdinal
comment:
\spad{ordinalPower(o1,{} o2)} returns \spad{o1} to power \spad{o2},{} where power is inductively defined using successive ordinal multiplication from the left


kind: o
name: orientedFacet
exposed: n
type: (Integer,List(NonNegativeInteger))->%
params: dOrientedFacet
comment:
Constructor for oriented facet oriented facet is always stored in vertex order orientation is calculated by the number of edges that have to be flipped to put it in order.


kind: o
name: orientedFacetIfCan
exposed: n
type: (List(%))->Union(%,failed)
params: dOrientedFacet
comment:
Constructor for oriented face from its boundary. This is like filling-in the boundary,{} in that sense it is the inverse of 'boundary'. May fail,{} for instance in 'implied' loops,{} where both ends of an edge are the same point. Also similar cases for higher order facets.


kind: o
name: orientedFacetSigned
exposed: n
type: (List(Integer))->%
params: dOrientedFacet
comment:
Constructor for oriented face which removes duplicates If the face is positive then we expect the sequence to be: + - + - ...


kind: o
name: orthogonalConvolution
exposed: n
type: (%,%)->%
params: cDistributionCategory(R)
comment:
\spad{orthogonalConvolution(x,{} y)} returns the orthogonal convolution of the distributions \spad{x} and \spad{y}


kind: o
name: orthonormalBasis
exposed: x
type: (Matrix(Fraction(Polynomial(Integer))))->List(Matrix(Expression(Integer)))
params: pRadicalEigenPackage
comment:
\spad{orthonormalBasis(m)} returns the orthogonal matrix \spad{b} such that \spad{b*m*(inverse b)} is diagonal. Error: if \spad{m} is not a symmetric matrix.


kind: o
name: outerProduct
exposed: x
type: (%,%)->Matrix(R)
params: cVectorCategory(R)
abbrev: has(R,Ring)
comment:
\spad{outerProduct(u,{} v)} constructs the matrix whose (\spad{i},{} \spad{j})\spad{'}th element is \spad{u}(\spad{i})\spad{*v}(\spad{j}).


kind: o
name: outlineRender
exposed: x
type: (%,String)->Void
params: dThreeDimensionalViewport
comment:
\spad{outlineRender(v,{} s)} displays the polygon outline showing either triangularized surface or a quadrilateral surface outline depending on the whether the \spadfun{diagonals} function has been set,{} for the given three-dimensional viewport \spad{v} which is of domain \spadtype{ThreeDimensionalViewport},{} if \spad{s} is on,{} or does not display the polygon outline if \spad{s} is off.


kind: o
name: outputAsFortran
exposed: x
type: (List(OutputForm))->Void
params: pSpecialOutputPackage
comment:
\spad{outputAsFortran(l)} sends (for each expression in the list \spad{l}) output in FORTRAN format to the destination defined by \spadsys{)set output fortran}.


kind: o
name: outputAsFortran
exposed: x
type: (String,OutputForm)->Void
params: pSpecialOutputPackage
comment:
\spad{outputAsFortran(v,{} o)} sends output \spad{v} = \spad{o} in FORTRAN format to the destination defined by \spadsys{)set output fortran}.


kind: o
name: outputAsMathML
exposed: x
type: (List(OutputForm))->Void
params: pSpecialOutputPackage
comment:
\spad{outputAsMathML(l)} sends (for each expression in the list \spad{l}) output in MathML format to the destination as defined by \spadsys{)set output mathml}.


kind: o
name: outputAsMathML
exposed: x
type: (OutputForm)->Void
params: pSpecialOutputPackage
comment:
\spad{outputAsMathML(o)} sends output \spad{o} in MathML format to the destination as defined by \spadsys{)set output mathml}.


kind: o
name: outputAsTex
exposed: x
type: (List(OutputForm))->Void
params: pSpecialOutputPackage
comment:
\spad{outputAsTex(l)} sends (for each expression in the list \spad{l}) output in Tex format to the destination as defined by \spadsys{)set output tex}.


kind: o
name: outputAsTex
exposed: x
type: (OutputForm)->Void
params: pSpecialOutputPackage
comment:
\spad{outputAsTex(o)} sends output \spad{o} in Tex format to the destination defined by \spadsys{)set output tex}.


kind: o
name: outputFixed
exposed: x
type: ()->Void
params: dFloat
comment:
\spad{outputFixed()} sets the output mode to fixed point notation; the output will contain a decimal point.


kind: o
name: outputFixed
exposed: x
type: (NonNegativeInteger)->Void
params: dFloat
comment:
\spad{outputFixed(n)} sets the output mode to fixed point notation,{} with \spad{n} digits displayed after the decimal point.


kind: o
name: outputFloating
exposed: x
type: ()->Void
params: dFloat
comment:
\spad{outputFloating()} sets the output mode to floating (scientific) notation,{} \spadignore{i.e.} \spad{mantissa * 10 exponent} is displayed as \spad{0.mantissa E exponent}.


kind: o
name: outputFloating
exposed: x
type: (NonNegativeInteger)->Void
params: dFloat
comment:
\spad{outputFloating(n)} sets the output mode to floating (scientific) notation with \spad{n} significant digits displayed after the decimal point.


kind: o
name: outputForm
exposed: n
type: (%,OutputForm)->OutputForm
params: dSparseUnivariatePolynomial(R)
comment:
\spad{outputForm(p,{} var)} converts the SparseUnivariatePolynomial \spad{p} to an output form (see \spadtype{OutputForm}) printed as a polynomial in the output form \spad{var}.


kind: o
name: outputForm
exposed: n
type: (%,OutputForm)->OutputForm
params: dSparseUnivariateSkewPolynomial(R,sigma,delta)
comment:
\spad{outputForm(p,{} x)} returns the output form of \spad{p} using \spad{x} for the otherwise anonymous variable.


kind: o
name: outputForm
exposed: n
type: (%,(OutputForm,OutputForm)->OutputForm,(OutputForm,OutputForm)->OutputForm,Integer)->OutputForm
params: dListMonoidOps(S,E,un)
comment:
\spad{outputForm(l,{} fop,{} fexp,{} unit)} converts the monoid element represented by \spad{l} to an \spadtype{OutputForm}. Argument unit is the output form for the \spadignore{unit} of the monoid (\spadignore{e.g.} 0 or 1),{} \spad{fop(a,{} b)} is the output form for the monoid operation applied to \spad{a} and \spad{b} (\spadignore{e.g.} \spad{a + b},{} \spad{a * b},{} \spad{ab}),{} and \spad{fexp(a,{} n)} is the output form for the exponentiation operation applied to \spad{a} and \spad{n} (\spadignore{e.g.} \spad{n a},{} \spad{n * a},{} \spad{a ^ n},{} \spad{a\^n}).


kind: o
name: outputGeneral
exposed: x
type: ()->Void
params: dFloat
comment:
\spad{outputGeneral()} sets the output mode (default mode) to general notation; numbers will be displayed in either fixed or floating (scientific) notation depending on the magnitude.


kind: o
name: outputGeneral
exposed: x
type: (NonNegativeInteger)->Void
params: dFloat
comment:
\spad{outputGeneral(n)} sets the output mode to general notation with \spad{n} significant digits displayed.


kind: o
name: outputSpacing
exposed: x
type: (NonNegativeInteger)->NonNegativeInteger
params: dFloat
comment:
\spad{outputSpacing(n)} inserts an underscore after \spad{n} (default 10) digits on output; outputSpacing(0) means no underscores are inserted. Returns old setting.


kind: o
name: outputVRML
exposed: n
type: (%,TextFile)->Void
params: dXmlAttribute
comment:
\spad{outputVRML(rp,{} f1)} writes the attribute as \spad{VRML2}. \spad{VRML2} is not \spad{xml} but it has the same semantics and node names as \spad{X3D} but a different syntax so it makes sense to create an \spad{XML} structure and then format the output differently.


kind: o
name: outputVRML
exposed: n
type: (%,TextFile)->Void
params: dXmlElement
comment:
\spad{outputVRML(rp,{} f1)} writes the element as \spad{VRML2}. \spad{VRML2} is not \spad{xml} but it has the same semantics and node names as \spad{X3D} but a different syntax so it makes sense to create an \spad{XML} structure and then format the output differently.


kind: o
name: overbar
exposed: n
type: (Integer,(Integer,List(OutputForm))->OutputBox)->(Integer,List(OutputForm))->OutputBox
params: cFormatterCategory
comment:
\spad{overbar(p,{} hh)} returns a handler \spad{h} such that \spad{h(prec,{} args)} formats arguments via \spad{hh(p,{} args)} and then draws a bar over the resulting box. Outer parentheses are added if \spad{p < prec}.


kind: o
name: overlap
exposed: n
type: (%,%)->Record(lm:%,mm:%,rm:%)
params: dFreeMonoid(S)
comment:
\spad{overlap(x,{} y)} returns \spad{[l,{} m,{} r]} such that \spad{x = l * m},{} \spad{y = m * r} and \spad{l} and \spad{r} have no overlap,{} \spadignore{i.e.} \spad{overlap(l,{} r) = [l,{} 1,{} r]}.


kind: o
name: overset?
exposed: n
type: (List(GR),List(List(GR)))->Boolean
params: pParametricLinearEquations(R,Var,Expon,GR)
comment:
\spad{overset?(s,{} sl)} returns \spad{true} if \spad{s} properly a sublist of a member of \spad{sl}; otherwise it returns \spad{false}


kind: o
name: P
exposed: n
type: (List(NonNegativeInteger))->%
params: cJetBundleCategory
comment:
\spad{P(ind)} generates the derivative of the only dependent variable \spad{wrt} the index \spad{ind}.


kind: o
name: P
exposed: n
type: (NonNegativeInteger)->%
params: cJetBundleCategory
comment:
\spad{P(i)} generates the \spad{i}\spad{-}th derivative of the only dependent variable \spad{wrt} the only independent variable.


kind: o
name: P
exposed: n
type: (PositiveInteger,List(NonNegativeInteger))->%
params: cJetBundleCategory
comment:
\spad{P(i,{} ind)} generates the derivative of the \spad{i}\spad{-}th dependent variable \spad{wrt} the index \spad{ind}. Whether \spad{ind} is interpreted as multi-index or as repeated index depends on the chosen notation.


kind: o
name: P
exposed: n
type: (PositiveInteger,NonNegativeInteger)->%
params: cJetBundleCategory
comment:
\spad{P(i,{} j)} generates the \spad{j}\spad{-}th derivative of the \spad{i}\spad{-}th independent variable \spad{wrt} the only independent variable.


kind: o
name: packageCall
exposed: n
type: (Symbol,List(InputForm))->InputForm
params: pInputFormFunctions1(R)
comment:
\spad{packageCall(f,{} l)} returns the input form corresponding to \spad{f}(\spad{l}.1,{} \spad{l}.2,{} ...)\$\spad{R}.


kind: o
name: pack_exps
exposed: n
type: (Integer,Integer,MD)->SortedExponentVector
params: cModularAlgebraicGcdOperations(MP,MPT,MD)
comment:
\spad{pack_exps(d,{} s,{} m)} produces vector of exponents up to degree \spad{d}. \spad{s} is size (degree) of algebraic extension. Use together with \spad{repack1}.


kind: o
name: pack_modulus
exposed: n
type: (List(MP),List(Symbol),Integer)->Union(MD,failed)
params: cModularAlgebraicGcdOperations(MP,MPT,MD)
comment:
\spad{pack_modulus(lp,{} ls,{} p)} converts \spad{lp},{} \spad{ls} and prime \spad{p} which together describe algebraic extension to packed representation.


kind: o
name: pad
exposed: n
type: (NonNegativeInteger,NonNegativeInteger,NonNegativeInteger,NonNegativeInteger)->(%)->%
params: dOutputBox
comment:
\spad{pad(t,{} b,{} l,{} r)(box)} returns a new box that is padded by \spad{t} empty lines at the top,{} \spad{b} empty lines at the bottom,{} \spad{l} space characters at the left,{} \spad{r} space characters at the right. If \spad{w},{} \spad{h},{} \spad{d} are the width,{} height and depth of box then the resulting box will have width l+w+r and height \spad{t+h} and depth \spad{d+b}.


kind: o
name: pade
exposed: x
params: pPadeApproximantPackage(R,x,pt)
type:
(NonNegativeInteger,NonNegativeInteger,UnivariateTaylorSeries(R,x,pt))->Union(Fraction(UnivariatePolynomial(x,R)),failed)

comment:
\spad{pade(nd,{} dd,{} s)} computes the quotient of polynomials (if it exists) with numerator degree at most \spad{nd} and denominator degree at most \spad{dd} which matches the series \spad{s} to order \spad{nd + dd}.


kind: o
name: pade
exposed: n
type: (NonNegativeInteger,NonNegativeInteger,PS,PS)->Union(Fraction(UP),failed)
params: pPadeApproximants(R,PS,UP)
comment:
\spad{pade(nd,{} dd,{} ns,{} ds)} computes the approximant as a quotient of polynomials (if it exists) for arguments \spad{nd} (numerator degree of approximant),{} \spad{dd} (denominator degree of approximant),{} \spad{ns} (numerator series of function),{} and \spad{ds} (denominator series of function).


kind: o
name: pade
exposed: x
params: pPadeApproximantPackage(R,x,pt)
type:
(NonNegativeInteger,NonNegativeInteger,UnivariateTaylorSeries(R,x,pt),UnivariateTaylorSeries(R,x,pt))->Union(Fraction(UnivariatePolynomial(x,R)),failed)

comment:
\spad{pade(nd,{} dd,{} ns,{} ds)} computes the approximant as a quotient of polynomials (if it exists) for arguments \spad{nd} (numerator degree of approximant),{} \spad{dd} (denominator degree of approximant),{} \spad{ns} (numerator series of function),{} and \spad{ds} (denominator series of function).


kind: o
name: padecf
exposed: n
type: (NonNegativeInteger,NonNegativeInteger,PS,PS)->Union(ContinuedFraction(UP),failed)
params: pPadeApproximants(R,PS,UP)
comment:
\spad{padecf(nd,{} dd,{} ns,{} ds)} computes the approximant as a continued fraction of polynomials (if it exists) for arguments \spad{nd} (numerator degree of approximant),{} \spad{dd} (denominator degree of approximant),{} \spad{ns} (numerator series of function),{} and \spad{ds} (denominator series of function).


kind: o
name: padicallyExpand
exposed: x
type: (R,R)->SparseUnivariatePolynomial(R)
params: dPartialFraction(R)
comment:
\spad{padicallyExpand(p,{} x)} is a utility function that expands the second argument \spad{x} \spad{


kind: o
name: padicFraction
exposed: x
type: (%)->%
params: dPartialFraction(R)
comment:
\spad{padicFraction(q)} expands the fraction \spad{p}-adically in the primes \spad{p} in the denominator of \spad{q}. For example,{} \spad{padicFraction(3/(2^2)) = 1/2 + 1/(2^2)}. Use \spadfunFrom{compactFraction}{PartialFraction} to return to compact form.


kind: o
name: palgint0
exposed: n
type: (F,Kernel(F),Kernel(F),F,SparseUnivariatePolynomial(F))->IntegrationResult(F)
params: pGenusZeroIntegration(R,F,L)
comment:
\spad{palgint0(f,{} x,{} y,{} d,{} p)} returns the integral of \spad{f(x,{} y)dx} where \spad{y} is an algebraic function of \spad{x} satisfying \spad{d(x)\^2 y(x)\^2 = P(x)}.


kind: o
name: palgint0
exposed: n
type: (F,Kernel(F),Kernel(F),Kernel(F),F,Fraction(SparseUnivariatePolynomial(F)),F)->IntegrationResult(F)
params: pGenusZeroIntegration(R,F,L)
comment:
\spad{palgint0(f,{} x,{} y,{} z,{} t,{} c)} returns the integral of \spad{f(x,{} y)dx} where \spad{y} is an algebraic function of \spad{x} satisfying \spad{x = eval(t,{} z,{} ry)} and \spad{c = d/dz t}; \spad{r} is rational function of \spad{x},{} \spad{c} and \spad{t} are rational functions of \spad{z}. Argument \spad{z} is a dummy variable not appearing in \spad{f(x,{} y)}.


kind: o
name: palgint
exposed: n
type: (F,Kernel(F),Kernel(F))->IntegrationResult(F)
params: pPureAlgebraicIntegration(R,F,L)
comment:
\spad{palgint(f,{} x,{} y)} returns the integral of \spad{f(x,{} y)dx} where \spad{y} is an algebraic function of \spad{x}.


kind: o
name: palgintegrate
exposed: n
type: (R,F,(UP)->UP)->Record(result1:IntegrationResult(R),result2:F)
params: pAlgebraicIntegrate(R0,F,UP,UPUP,R)
comment:
\spad{palgintegrate(f,{} x,{} d)} integrates \spad{f} with respect to the derivation \spad{d}. Argument \spad{f} must be a pure algebraic function.


kind: o
name: palgLODE0
exposed: n
params: pGenusZeroIntegration(R,F,L)
abbrev: has(L,LinearOrdinaryDifferentialOperatorCategory(F))
type:
(L,F,Kernel(F),Kernel(F),F,SparseUnivariatePolynomial(F))->Record(particular:Union(F,failed),basis:List(F))

comment:
\spad{palgLODE0(op,{} g,{} x,{} y,{} d,{} p)} returns the solution of \spad{op f = g}. Argument \spad{y} is an algebraic function of \spad{x} satisfying \spad{d(x)\^2y(x)\^2 = P(x)}.


kind: o
name: palgLODE0
exposed: n
params: pGenusZeroIntegration(R,F,L)
abbrev: has(L,LinearOrdinaryDifferentialOperatorCategory(F))
type:
(L,F,Kernel(F),Kernel(F),Kernel(F),F,Fraction(SparseUnivariatePolynomial(F)),F)->Record(particular:Union(F,failed),basis:List(F))

comment:
\spad{palgLODE0(op,{} g,{} x,{} y,{} z,{} t,{} c)} returns the solution of \spad{op f = g}. Argument \spad{y} is an algebraic function of \spad{x} satisfying \spad{x = eval(t,{} z,{} ry)} and \spad{c = d/dz t}; \spad{r} is rational function of \spad{x},{} \spad{c} and \spad{t} are rational functions of \spad{z}.


kind: o
name: palgLODE
exposed: n
type: (L,F,Kernel(F),Kernel(F),Symbol)->Record(particular:Union(F,failed),basis:List(F))
params: pPureAlgebraicIntegration(R,F,L)
abbrev: has(L,LinearOrdinaryDifferentialOperatorCategory(F))
comment:
\spad{palgLODE(op,{} g,{} kx,{} y,{} x)} returns the solution of \spad{op f = g}. \spad{y} is an algebraic function of \spad{x}.


kind: o
name: palgRDE0
exposed: n
params: pGenusZeroIntegration(R,F,L)
type:
(F,F,Kernel(F),Kernel(F),(F,F,Symbol)->Union(F,failed),F,SparseUnivariatePolynomial(F))->Union(F,failed)

comment:
\spad{palgRDE0(f,{} g,{} x,{} y,{} foo,{} d,{} p)} returns a function \spad{z(x,{} y)} such that \spad{dz/dx + n * df/dx z(x,{} y) = g(x,{} y)} if such a \spad{z} exists,{} and failed otherwise. Argument \spad{y} is an algebraic function of \spad{x} satisfying \spad{d(x)\^2y(x)\^2 = P(x)}. Argument \spad{foo},{} called by \spad{foo(a,{} b,{} x)},{} is a function that solves \spad{du/dx + n * da/dx u(x) = u(x)} for an unknown \spad{u(x)} not involving \spad{y}.


kind: o
name: palgRDE0
exposed: n
params: pGenusZeroIntegration(R,F,L)
type:
(F,F,Kernel(F),Kernel(F),(F,F,Symbol)->Union(F,failed),Kernel(F),F,Fraction(SparseUnivariatePolynomial(F)),F)->Union(F,failed)

comment:
\spad{palgRDE0(f,{} g,{} x,{} y,{} foo,{} t,{} c)} returns a function \spad{z(x,{} y)} such that \spad{dz/dx + n * df/dx z(x,{} y) = g(x,{} y)} if such a \spad{z} exists,{} and failed otherwise. Argument \spad{y} is an algebraic function of \spad{x} satisfying \spad{x = eval(t,{} z,{} ry)} and \spad{c = d/dz t}; \spad{r} is rational function of \spad{x},{} \spad{c} and \spad{t} are rational functions of \spad{z}. Argument \spad{foo},{} called by \spad{foo(a,{} b,{} x)},{} is a function that solves \spad{du/dx + n * da/dx u(x) = u(x)} for an unknown \spad{u(x)} not involving \spad{y}.


kind: o
name: palgRDE
exposed: n
type: (F,F,F,Kernel(F),Kernel(F),(F,F,Symbol)->Union(F,failed))->Union(F,failed)
params: pPureAlgebraicIntegration(R,F,L)
comment:
\spad{palgRDE(nfp,{} f,{} g,{} x,{} y,{} foo)} returns a function \spad{z(x,{} y)} such that \spad{dz/dx + n * df/dx z(x,{} y) = g(x,{} y)} if such a \spad{z} exists,{} failed otherwise; \spad{y} is an algebraic function of \spad{x}; \spad{foo(a,{} b,{} x)} is a function that solves \spad{du/dx + n * da/dx u(x) = u(x)} for an unknown \spad{u(x)} not involving \spad{y}. \spad{nfp} is \spad{n * df/dx}.


kind: o
name: parabolic
exposed: x
type: (Point(R))->Point(R)
params: pCoordinateSystems(R)
comment:
\spad{parabolic(pt)} transforms \spad{pt} from parabolic coordinates to Cartesian coordinates: the function produced will map the point \spad{(u,{} v)} to \spad{x = 1/2*(u^2 - v^2)},{} \spad{y = u*v}.


kind: o
name: parabolicCylindrical
exposed: x
type: (Point(R))->Point(R)
params: pCoordinateSystems(R)
comment:
\spad{parabolicCylindrical(pt)} transforms \spad{pt} from parabolic cylindrical coordinates to Cartesian coordinates: the function produced will map the point \spad{(u,{} v,{} z)} to \spad{x = 1/2*(u^2 - v^2)},{} \spad{y = u*v},{} \spad{z}.


kind: o
name: paraboloidal
exposed: x
type: (Point(R))->Point(R)
params: pCoordinateSystems(R)
comment:
\spad{paraboloidal(pt)} transforms \spad{pt} from paraboloidal coordinates to Cartesian coordinates: the function produced will map the point \spad{(u,{} v,{} phi)} to \spad{x = u*v*cos(phi)},{} \spad{y = u*v*sin(phi)},{} \spad{z = 1/2 * (u^2 - v^2)}.


kind: o
name: parallel
exposed: n
type: (%,%)->DoubleFloat
params: cSPointCategory
comment:
\spad{parallel(x,{} y)} returns the length of the parallel component of two vectors. In the case of Euclidean space this is the dot product of two vectors. We use this function to test the colinearity


kind: o
name: param_LODE
exposed: n
params: pPureAlgebraicIntegration(R,F,L)
comment: \spad{param_LODE(eq,{} lg,{} x,{} y)}
type:
(List(F),List(F),Kernel(F),Kernel(F))->Record(particular:List(Record(ratpart:F,coeffs:Vector(F))),basis:List(F))


kind: o
name: param_rde2
exposed: n
params: pParametricRischDE(R,F)
type:
(F,List(F),Symbol,List(Kernel(F)),(List(Kernel(F)),List(F))->List(Record(ratpart:F,coeffs:Vector(F))),(List(Kernel(F)),List(F))->Record(logands:List(F),basis:List(Vector(Fraction(Integer)))))->List(Record(ratpart:F,coeffs:Vector(F)))

comment:
\spad{param_rde2(fp,{} lg,{} x,{} lk,{} ext,{} logi)} finds basis of solution to the equation dy/dx + \spad{fp} \spad{y} + \spad{c1} \spad{g1} + ... \spad{cn} \spad{gn} = 0 where \spad{y} is in field generated by \spad{lk} and \spad{ci} are constants.


kind: o
name: param_RDE
exposed: n
params: pPureAlgebraicIntegration(R,F,L)
comment: \spad{param_RDE(fp,{} lg,{} x,{} y)}
type:
(F,List(F),Kernel(F),Kernel(F))->Record(particular:List(Record(ratpart:F,coeffs:Vector(F))),basis:List(F))


kind: o
name: param_rde
exposed: n
params: pParametricRischDE(R,F)
type:
(Integer,F,List(F),Symbol,List(Kernel(F)),(List(Kernel(F)),List(F))->List(Record(ratpart:F,coeffs:Vector(F))),(List(Kernel(F)),List(F))->Record(logands:List(F),basis:List(Vector(Fraction(Integer)))))->List(Record(ratpart:F,coeffs:Vector(F)))

comment:
\spad{param_rde(n,{} f,{} lg,{} x,{} lk,{} ext,{} logi)} finds basis of solution to the equation dy/dx + \spad{n} df/dx \spad{y} + \spad{c1} \spad{g1} + ... \spad{cn} \spad{gn} = 0 where \spad{y} is in field generated by \spad{lk} and \spad{ci} are constants.


kind: o
name: param_rde
exposed: n
params: pParametricRischDE(R,F)
type:
(Integer,F,F,List(F),Symbol,List(Kernel(F)),(List(Kernel(F)),List(F))->List(Record(ratpart:F,coeffs:Vector(F))),(List(Kernel(F)),List(F))->Record(logands:List(F),basis:List(Vector(Fraction(Integer)))))->Record(particular:Union(Record(ratpart:F,coeffs:Vector(F)),failed),basis:List(Record(ratpart:F,coeffs:Vector(F))))

comment:
\spad{param_rde(n,{} f,{} h,{} lg,{} x,{} lk,{} ext,{} logi)} finds a particular solution and basis of solutions to homogeneous equation for equation dy/dx + \spad{n} df/dx \spad{y} + \spad{c1} \spad{g1} + ... \spad{cn} \spad{gn} = \spad{h} where \spad{y} is in field generated by \spad{lk} and \spad{ci} are constants.


kind: o
name: ParCond
exposed: n
type: (Matrix(GR),NonNegativeInteger)->List(Record(det:GR,rows:List(Integer),cols:List(Integer)))
params: pParametricLinearEquations(R,Var,Expon,GR)
comment:
\spad{ParCond(m,{} k)} returns the list of all \spad{k} by \spad{k} subdeterminants in the matrix \spad{m}


kind: o
name: ParCondList
exposed: n
params: pParametricLinearEquations(R,Var,Expon,GR)
type:
(Matrix(GR),NonNegativeInteger)->List(Record(rank:NonNegativeInteger,eqns:List(Record(det:GR,rows:List(Integer),cols:List(Integer))),fgb:List(GR)))

comment:
\spad{ParCondList(c,{} r)} computes a list of subdeterminants of each rank \spad{>=} \spad{r} of the matrix \spad{c} and returns a groebner basis for the ideal they generate


kind: o
name: paren
exposed: n
type: (List(%))->%
params: dOutputForm
comment:
\spad{paren(lf)} creates the form separating the elements of \spad{lf} by commas and encloses the result in parentheses.


kind: o
name: paren
exposed: x
type: (%)->%
params: cExpressionSpace2(K)
comment:
\spad{paren(f)} returns (\spad{f}). This prevents \spad{f} from being evaluated when operators are applied to it. For example,{} \spad{log(1)} returns 0,{} but \spad{log(paren 1)} returns the formal kernel log((1)).


kind: o
name: parent
exposed: n
type: (%)->%
params: dSubSpace(n,R)
comment:
\spad{parent(s)} returns the subspace which is the parent of the indicated 3 dimensional subspace \spad{s}. If \spad{s} is the top level subspace an error message is returned.


kind: o
name: parenthesize
exposed: n
type: (String,String,OutputBox)->OutputBox
params: cFormatterCategory
comment:
\spad{parenthesize(lb,{} rb,{} bx)} returns the box \spad{bx} with left and right brackets (\spad{lb} and \spad{rb}) around it.


kind: o
name: parenthesizeIf
exposed: n
type: (Boolean,OutputBox)->OutputBox
params: cFormatterCategory
comment:
\spad{parenthesizeIf(paren?,{} bx)} returns parentheses (of appropriate size if \spad{paren?} is \spad{true}. Otherwise,{} \spad{bx} is returned.


kind: o
name: parseIL
exposed: n
type: (String)->%
params: dILogic
comment:
Constructs intuitionistic logic terms from a string notation assumes format like this: <term> : \spad{:=} var | <term>/\spad{\<}term> | <term>\spad{\/}<term> | \indented{11}{<term>-><term> | (<term>)}


kind: o
name: parseIL2
exposed: n
type: (String,NonNegativeInteger)->Record(rft:%,pout:NonNegativeInteger)
params: dILogic
comment:
Constructs intuitionistic logic terms from a string notation assumes format like this: <term2> : \spad{:=} var | (<term>) <term> : \spad{:=} var | <term>/\spad{\<}term> | <term>\spad{\/}<term> | \indented{11}{<term>-><term> | (<term>)}


kind: o
name: parseILTerm
exposed: n
type: (String,NonNegativeInteger)->Record(rft:%,pout:NonNegativeInteger)
params: dILogic
comment:
parseTerm is used by parseIL. It would rarely be called externally but it is here to allow it to call parseIL that is to allow circular calls


kind: o
name: parseLambda
exposed: n
type: (String)->%
params: dLambda(UT)
comment:
Constructs nested lambda terms from a string notation assumes format like this: <term> : \spad{:=} \spad{\} var .<term> | \spad{n} | <term><term> | (<term>) where: \\ = lambda (\spad{I} would like to use unicode lambda symbol but \indented{12}{\spad{I} would also like to keep maximum compatibility} \indented{12}{with non-unicode versions of Lisp)} \spad{n} = De Bruijn index which is a integer where,{} 1=inside inner \indented{12}{lambda term,{} 2= next outer lambda term,{} 3= next} \indented{12}{outer and so on.} brackets can be used around whole terms.


kind: o
name: parseTerm
exposed: n
type: (String,NonNegativeInteger)->Record(rft:%,pout:NonNegativeInteger)
params: dLambda(UT)
comment:
parseTerm is used by parseLambda. It would rarely be called externally but it is here to allow it to call parseLambda that is to allow circular calls


kind: o
name: parseTerm
exposed: n
type: (String,NonNegativeInteger)->Record(rft:%,pout:NonNegativeInteger)
params: dSKICombinators(UT)
comment:
parseTerm is used by parseSki. It would rarely be called externally but it is here to allow it to call parseSki that is to allow circular calls


kind: o
name: parseVarTerm
exposed: n
type: (String,NonNegativeInteger)->Record(rft:%,pout:NonNegativeInteger)
params: cVarCat
comment:
construct a variable by parsing a string pin is index to string at start of parse pout is index to string at end of parse


kind: o
name: partialDenominators
exposed: x
type: (%)->Stream(R)
params: dContinuedFraction(R)
comment:
\spad{partialDenominators(x)} extracts the denominators in \spadvar{\spad{x}}. That is,{} if \spad{x = continuedFraction(b0,{} [a1,{} a2,{} a3,{} ...],{} [b1,{} b2,{} b3,{} ...])},{} then \spad{partialDenominators(x) = [b1,{} b2,{} b3,{} ...]}.


kind: o
name: partialFraction
exposed: x
type: (Fraction(R))->%
params: dPartialFraction(R)
abbrev: has(R,UniqueFactorizationDomain)
comment:
\spad{partialFraction(f)} is a user friendly interface for partial fractions when \spad{f} is a fraction of UniqueFactorizationDomain.


kind: o
name: partialFraction
exposed: x
type: (Fraction(Polynomial(R)),Symbol)->Any
params: pPartialFractionPackage(R)
comment:
\spad{partialFraction(rf,{} var)} returns the partial fraction decomposition of the rational function \spad{rf} with respect to the variable var.


kind: o
name: partialFraction
exposed: x
type: (R,Factored(R))->%
params: dPartialFraction(R)
comment:
\spad{partialFraction(numer,{} denom)} is the main function for constructing partial fractions. The second argument is the denominator and should be factored.


kind: o
name: partialFraction
exposed: x
type: (Polynomial(R),Factored(Polynomial(R)),Symbol)->Any
params: pPartialFractionPackage(R)
comment:
\spad{partialFraction(num,{} facdenom,{} var)} returns the partial fraction decomposition of the rational function whose numerator is \spad{num} and whose factored denominator is \spad{facdenom} with respect to the variable var.


kind: o
name: partialNumerators
exposed: x
type: (%)->Stream(R)
params: dContinuedFraction(R)
comment:
\spad{partialNumerators(x)} extracts the numerators in \spadvar{\spad{x}}. That is,{} if \spad{x = continuedFraction(b0,{} [a1,{} a2,{} a3,{} ...],{} [b1,{} b2,{} b3,{} ...])},{} then \spad{partialNumerators(x) = [a1,{} a2,{} a3,{} ...]}.


kind: o
name: partialQuotients
exposed: x
type: (%)->Stream(R)
params: dContinuedFraction(R)
comment:
\spad{partialQuotients(x)} extracts the partial quotients in \spadvar{\spad{x}}. That is,{} if \spad{x = continuedFraction(b0,{} [a1,{} a2,{} a3,{} ...],{} [b1,{} b2,{} b3,{} ...])},{} then \spad{partialQuotients(x) = [b0,{} b1,{} b2,{} b3,{} ...]}.


kind: o
name: particularSolution
exposed: n
type: (Matrix(R),Vector(R))->Union(Vector(Fraction(S)),failed)
params: pLinearDependence(S,R)
abbrev: NOT(has(S,Field))
comment:
\spad{particularSolution([v1,{} ...,{} vn],{} u)} returns \spad{[c1,{} ...,{} cn]} such that \spad{c1*v1 + ... + cn*vn = u},{} failed if no such \spad{ci}\spad{'s} exist in the quotient field of \spad{S}.


kind: o
name: particularSolution
exposed: n
type: (Matrix(R),Vector(R))->Union(Vector(S),failed)
params: pLinearDependence(S,R)
abbrev: has(S,Field)
comment:
\spad{particularSolution([v1,{} ...,{} vn],{} u)} returns \spad{[c1,{} ...,{} cn]} such that \spad{c1*v1 + ... + cn*vn = u},{} failed if no such \spad{ci}\spad{'s} exist in \spad{S}.


kind: o
name: particularSolution
exposed: n
type: (LODO,F,List(F),(F)->F)->Union(F,failed)
params: pODETools(F,LODO)
comment:
\spad{particularSolution(op,{} g,{} [f1,{} ...,{} fm],{} I)} returns a particular solution \spad{h} of the equation \spad{op y = g} where \spad{[f1,{} ...,{} fm]} are linearly independent and \spad{op(\spad{fi})=0}. The value failed is returned if no particular solution is found. Note: the method of variations of parameters is used.


kind: o
name: particularSolutionOverConstants
exposed: n
type: (Matrix(F),Vector(F),List((F)->F))->Union(Vector(F),failed)
params: pConstantLinearDependence(R,F)
comment:
\spad{solveLinearlyOverConstants([v1,{} ...,{} vn],{} u,{} ld)} returns \spad{[c1,{} ...,{} cn]} such that \spad{c1*v1 + ... + cn*vn = u},{} failed if no such rational numbers \spad{ci}\spad{'s} exist.


kind: o
name: particularSolutionOverConstants
exposed: n
type: (Vector(F),F,List((F)->F))->Union(Vector(F),failed)
params: pConstantLinearDependence(R,F)
comment:
\spad{particularSolutionOverConstants([v1,{} ...,{} vn],{} u,{} ld)} returns \spad{[c1,{} ...,{} cn]} such that \spad{c1*v1 + ... + cn*vn = u},{} failed if no such constants numbers \spad{ci}\spad{'s} exist.


kind: o
name: particularSolutionOverQ
exposed: x
type: (Matrix(R),Vector(R))->Union(Vector(Fraction(Integer)),failed)
params: pIntegerLinearDependence(R)
comment:
\spad{solveLinearlyOverQ([v1,{} ...,{} vn],{} u)} returns \spad{[c1,{} ...,{} cn]} such that \spad{c1*v1 + ... + cn*vn = u},{} failed if no such rational numbers \spad{ci}\spad{'s} exist.


kind: o
name: particularSolutionOverQ
exposed: x
type: (Vector(R),R)->Union(Vector(Fraction(Integer)),failed)
params: pIntegerLinearDependence(R)
comment:
\spad{particularSolutionOverQ([v1,{} ...,{} vn],{} u)} returns \spad{[c1,{} ...,{} cn]} such that \spad{c1*v1 + ... + cn*vn = u},{} failed if no such rational numbers \spad{ci}\spad{'s} exist.


kind: o
name: partition
exposed: x
type: (I)->I
params: pIntegerCombinatoricFunctions(I)
comment:
\spad{partition(n)} returns the number of partitions of the integer \spad{n}. This is the number of distinct ways that \spad{n} can be written as a sum of positive integers.


kind: o
name: partitions
exposed: x
type: (Integer,Integer)->Stream(List(Integer))
params: pPartitionsAndPermutations
comment:
\spad{partitions(p,{} l)} is the stream of all \indented{1}{partitions whose number of} \indented{1}{parts and largest part are no greater than \spad{p} and \spad{l}.}


kind: o
name: partitions
exposed: x
type: (Integer,Integer,Integer)->Stream(List(Integer))
params: pPartitionsAndPermutations
comment:
\spad{partitions(p,{} l,{} n)} is the stream of partitions \indented{1}{of \spad{n} whose number of parts is no greater than \spad{p}} \indented{1}{and whose largest part is no greater than \spad{l}.}


kind: o
name: parts
exposed: x
type: (%)->List(S)
params: cHomogeneousAggregate(S)
abbrev: has(%,finiteAggregate)
comment:
\spad{parts(u)} returns a list of the consecutive elements of \spad{u}. For finite collections,{} \spad{construct(parts(u)) = u}.


kind: o
name: pascalTriangle
exposed: n
type: (NonNegativeInteger,Integer)->R
params: pGaloisGroupUtilities(R)
comment:
\spad{pascalTriangle(n,{} r)} returns the binomial coefficient \spad{C(n,{} r)=n!/(r! (n-r)!)} and stores it in a table to prevent recomputation.


kind: o
name: patternMatch
exposed: n
type: (A,Pattern(S),PatternMatchResult(S,B))->PatternMatchResult(S,B)
params: pPatternMatchPushDown(S,A,B)
comment:
\spad{patternMatch(expr,{} pat,{} res)} matches the pattern \spad{pat} to the expression \spad{expr}; res contains the variables of \spad{pat} which are already matched and their matches. Note: this function handles type towers by changing the predicates and calling the matching function provided by \spad{A}.


kind: o
name: patternMatch
exposed: n
type: (CS,Pattern(R),PatternMatchResult(R,CS))->PatternMatchResult(R,CS)
params: pComplexPatternMatch(R,S,CS)
abbrev: has(Polynomial(S),PatternMatchable(R))
comment:
\spad{patternMatch(cexpr,{} pat,{} res)} matches the pattern \spad{pat} to the complex expression \spad{cexpr}. res contains the variables of \spad{pat} which are already matched and their matches.


kind: o
name: patternMatch
exposed: n
type: (F,Pattern(S),PatternMatchResult(S,F))->PatternMatchResult(S,F)
params: pPatternMatchFunctionSpace(S,R,F)
comment:
\spad{patternMatch(expr,{} pat,{} res)} matches the pattern \spad{pat} to the expression \spad{expr}; res contains the variables of \spad{pat} which are already matched and their matches.


kind: o
name: patternMatch
exposed: n
type: (I,Pattern(Integer),PatternMatchResult(Integer,I))->PatternMatchResult(Integer,I)
params: pPatternMatchIntegerNumberSystem(I)
comment:
\spad{patternMatch(n,{} pat,{} res)} matches the pattern \spad{pat} to the integer \spad{n}; res contains the variables of \spad{pat} which are already matched and their matches.


kind: o
name: patternMatch
exposed: n
type: (Kernel(E),Pattern(S),PatternMatchResult(S,E))->PatternMatchResult(S,E)
params: pPatternMatchKernel(S,E)
comment:
\spad{patternMatch(f(e1,{} ...,{} en),{} pat,{} res)} matches the pattern \spad{pat} to \spad{f(e1,{} ...,{} en)}; res contains the variables of \spad{pat} which are already matched and their matches.


kind: o
name: patternMatch
exposed: n
type: (L,Pattern(S),PatternMatchListResult(S,R,L))->PatternMatchListResult(S,R,L)
params: pPatternMatchListAggregate(S,R,L)
comment:
\spad{patternMatch(l,{} pat,{} res)} matches the pattern \spad{pat} to the list \spad{l}; res contains the variables of \spad{pat} which are already matched and their matches.


kind: o
name: patternMatch
exposed: n
type: (P,Pattern(S),PatternMatchResult(S,P))->PatternMatchResult(S,P)
params: pPatternMatchPolynomialCategory(S,E,V,R,P)
abbrev: has(V,PatternMatchable(S))
comment:
\spad{patternMatch(p,{} pat,{} res)} matches the pattern \spad{pat} to the polynomial \spad{p}; res contains the variables of \spad{pat} which are already matched and their matches.


kind: o
name: patternMatch
exposed: n
type: (Q,Pattern(S),PatternMatchResult(S,Q))->PatternMatchResult(S,Q)
params: pPatternMatchQuotientFieldCategory(S,R,Q)
comment:
\spad{patternMatch(a/b,{} pat,{} res)} matches the pattern \spad{pat} to the quotient \spad{a/b}; res contains the variables of \spad{pat} which are already matched and their matches.


kind: o
name: patternMatch
exposed: n
type: (Symbol,Pattern(S),PatternMatchResult(S,Symbol))->PatternMatchResult(S,Symbol)
params: pPatternMatchSymbol(S)
comment:
\spad{patternMatch(expr,{} pat,{} res)} matches the pattern \spad{pat} to the expression \spad{expr}; res contains the variables of \spad{pat} which are already matched and their matches (necessary for recursion).


kind: o
name: patternMatch
exposed: x
type: (%,Pattern(S),PatternMatchResult(S,%))->PatternMatchResult(S,%)
params: cPatternMatchable(S)
comment:
\spad{patternMatch(expr,{} pat,{} res)} matches the pattern \spad{pat} to the expression \spad{expr}. res contains the variables of \spad{pat} which are already matched and their matches (necessary for recursion). Initially,{} res is just the result of \spadfun{new} which is an empty list of matches.


kind: o
name: patternMatch
exposed: n
params: pPatternMatchPolynomialCategory(S,E,V,R,P)
type:
(P,Pattern(S),PatternMatchResult(S,P),(V,Pattern(S),PatternMatchResult(S,P))->PatternMatchResult(S,P))->PatternMatchResult(S,P)

comment:
\spad{patternMatch(p,{} pat,{} res,{} vmatch)} matches the pattern \spad{pat} to the polynomial \spad{p}. \spad{res} contains the variables of \spad{pat} which are already matched and their matches; vmatch is the matching function to use on the variables.


kind: o
name: patternMatch
exposed: n
params: pPatternMatchTools(S,R,P)
type:
(List(P),List(Pattern(S)),(List(P))->P,PatternMatchResult(S,P),(P,Pattern(S),PatternMatchResult(S,P))->PatternMatchResult(S,P))->PatternMatchResult(S,P)

comment:
\spad{patternMatch(lsubj,{} lpat,{} op,{} res,{} match)} matches the list of patterns \spad{lpat} to the list of subjects \spad{lsubj},{} allowing for commutativity; \spad{op} is the operator such that \spad{op}(\spad{lpat}) should match \spad{op}(\spad{lsubj}) at the end,{} \spad{r} contains the previous matches,{} and match is a pattern-matching function on \spad{P}.


kind: o
name: patternMatchTimes
exposed: n
params: pPatternMatchTools(S,R,P)
type:
(List(P),List(Pattern(S)),PatternMatchResult(S,P),(P,Pattern(S),PatternMatchResult(S,P))->PatternMatchResult(S,P))->PatternMatchResult(S,P)

comment:
\spad{patternMatchTimes(lsubj,{} lpat,{} res,{} match)} matches the product of patterns \spad{reduce(*,{} lpat)} to the product of subjects \spad{reduce(*,{} lsubj)}; \spad{r} contains the previous matches and match is a pattern-matching function on \spad{P}.


kind: o
name: patternVariable
exposed: n
type: (Symbol,Boolean,Boolean,Boolean)->%
params: dPattern(R)
comment:
\spad{patternVariable(x,{} c?,{} o?,{} m?)} creates a pattern variable \spad{x},{} which is constant if \spad{c? = true},{} optional if \spad{o? = true},{} and multiple if \spad{m? = true}.


kind: o
name: pdct
exposed: n
type: (%)->Integer
params: dPartition
comment:
\spad{pdct(a1^n1 a2^n2 ...)} returns \spad{n1! * a1^n1 * n2! * a2^n2 * ...}. This function is used in the package \spadtype{CycleIndicators}.


kind: o
name: perfectNthPower?
exposed: x
type: (I,NonNegativeInteger)->Boolean
params: pIntegerRoots(I)
comment:
\spad{perfectNthPower?(n,{} r)} returns \spad{true} if \spad{n} is an \spad{r}th power and \spad{false} otherwise


kind: o
name: perfectNthRoot
exposed: x
type: (I)->Record(base:I,exponent:NonNegativeInteger)
params: pIntegerRoots(I)
comment:
\spad{perfectNthRoot(n)} returns \spad{[x,{} r]},{} where \spad{n = x\^r} and \spad{r} is the largest integer such that \spad{n} is a perfect \spad{r}th power


kind: o
name: perfectNthRoot
exposed: x
type: (I,NonNegativeInteger)->Union(I,failed)
params: pIntegerRoots(I)
comment:
\spad{perfectNthRoot(n,{} r)} returns the \spad{r}th root of \spad{n} if \spad{n} is an \spad{r}th power and returns failed otherwise


kind: o
name: perfectSqrt
exposed: x
type: (I)->Union(I,failed)
params: pIntegerRoots(I)
comment:
\spad{perfectSqrt(n)} returns the square root of \spad{n} if \spad{n} is a perfect square and returns failed otherwise


kind: o
name: perfectSquare?
exposed: x
type: (I)->Boolean
params: pIntegerRoots(I)
comment:
\spad{perfectSquare?(n)} returns \spad{true} if \spad{n} is a perfect square and \spad{false} otherwise


kind: o
name: permanent
exposed: x
type: (SquareMatrix(n,R))->R
params: pPermanent(n,R)
comment:
\spad{permanent(x)} computes the permanent of a square matrix \spad{x}. The {\em permanent} is equivalent to the \spadfun{determinant} except that coefficients have no change of sign. This function is much more difficult to compute than the {\em determinant}. The formula used is by \spad{H}.\spad{J}. Ryser,{} improved by [Nijenhuis and Wilf,{} \spad{Ch}. 19]. Note: permanent(\spad{x}) choose one of three algorithms,{} depending on the underlying ring \spad{R} and on \spad{n},{} the number of rows (and columns) of \spad{x:} \begin{items} \item 1. if 2 has an inverse in \spad{R} we can use the algorithm of \indented{3}{[Nijenhuis and Wilf,{} \spad{ch}.19,{} \spad{p}.158]; if 2 has no inverse,{}} \indented{3}{some modifications are necessary:} \item 2. if {\em n > 6} and \spad{R} is an integral domain with characteristic \indented{3}{different from 2 (the algorithm works if and only 2 is not a} \indented{3}{zero-divisor of \spad{R} and {\em characteristic()\$R ~= 2},{}} \indented{3}{but how to check that for any given \spad{R} ?),{}} \indented{3}{the local function {\em permanent2} is called;} \item 3. else,{} the local function {\em permanent3} is called \indented{3}{(works for all commutative rings \spad{R}).} \end{items}


kind: o
name: permutation
exposed: n
type: (F,F)->F
params: pCombinatorialFunction(R,F)
comment:
\spad{permutation(n,{} r)} returns the number of permutations of \spad{n} objects taken \spad{r} at a time,{} \spadignore{i.e.} \spad{n!/}(\spad{n}-\spad{r})!.


kind: o
name: permutation
exposed: x
type: (%,%)->%
params: cCombinatorialFunctionCategory
comment:
\spad{permutation(n,{} m)} returns the number of permutations of \spad{n} objects taken \spad{m} at a time. Note: \spad{permutation(n,{} m) = n!/(n-m)!}.


kind: o
name: permutation
exposed: x
type: (I,I)->I
params: pIntegerCombinatoricFunctions(I)
comment:
\spad{permutation(n)} returns \spad{!P(n,{} r) = n!/(n-r)!}. This is the number of permutations of \spad{n} objects taken \spad{r} at a time.


kind: o
name: permutationGroup
exposed: x
type: (List(Permutation(S)))->%
params: dPermutationGroup(S)
comment:
\spad{permutationGroup(ls)} coerces a list of permutations {\em ls} to the group generated by this list.


kind: o
name: permutationRepresentation
exposed: n
type: (G)->Permutation(Integer)
params: pFiniteGroupPackage(G)
comment:
\spad{permutationRepresentation(x)} returns the permutation induced by \spad{x} on \spad{enumerate()\$G}


kind: o
name: permutationRepresentation
exposed: x
type: (List(Integer))->Matrix(Integer)
params: pRepresentationPackage1(R)
comment:
\spad{permutationRepresentation(\spad{pi},{} n)} returns the matrix {\em (deltai,{} \spad{pi}(i))} (Kronecker delta) if the permutation {\em \spad{pi}} is in list notation and permutes {\em {1,{} 2,{} ...,{} n}}.


kind: o
name: permutationRepresentation
exposed: x
type: (List(List(Integer)))->List(Matrix(Integer))
params: pRepresentationPackage1(R)
comment:
\spad{permutationRepresentation([pi1,{} ...,{} pik],{} n)} returns the list of matrices {\em [(deltai,{} pi1(i)),{} ...,{} (deltai,{} pik(i))]} if the permutations {\em pi1},{} ...,{} {\em pik} are in list notation and are permuting {\em {1,{} 2,{} ...,{} n}}.


kind: o
name: permutationRepresentation
exposed: x
type: (List(Permutation(Integer)),Integer)->List(Matrix(Integer))
params: pRepresentationPackage1(R)
comment:
\spad{permutationRepresentation([pi1,{} ...,{} pik],{} n)} returns the list of matrices {\em [(deltai,{} pi1(i)),{} ...,{} (deltai,{} pik(i))]} (Kronecker delta) for the permutations {\em pi1,{} ...,{} pik} of {\em {1,{} 2,{} ...,{} n}}.


kind: o
name: permutationRepresentation
exposed: x
type: (Permutation(Integer),Integer)->Matrix(Integer)
params: pRepresentationPackage1(R)
comment:
\spad{permutationRepresentation(\spad{pi},{} n)} returns the matrix {\em (deltai,{} \spad{pi}(i))} (Kronecker delta) for a permutation {\em \spad{pi}} of {\em {1,{} 2,{} ...,{} n}}.


kind: o
name: permutations
exposed: x
type: (Integer)->Stream(List(Integer))
params: pPartitionsAndPermutations
comment:
\spad{permutations(n)} is the stream of permutations \indented{1}{formed from \spad{1,{} 2,{} 3,{} ...,{} n}.}


kind: o
name: perpendicular
exposed: n
type: (%,%)->%
params: cSPointCategory
comment:
\spad{perpendicular(x,{} y)} returns a vector perpendicular to the two vectors in the case of 3D Euclidean space this is the cross the product of two vectors. We use this function to compute orthogonal


kind: o
name: perspective
exposed: x
type: (%,String)->Void
params: dThreeDimensionalViewport
comment:
\spad{perspective(v,{}s)} displays the graph in perspective if \spad{s} is on,{} or does not display perspective if \spad{s} is off for the given three-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{ThreeDimensionalViewport}.


kind: o
name: Pfaffian
exposed: x
type: (%)->R
params: cMatrixCategory(R,Row,Col)
abbrev: has(R,CommutativeRing)
comment:
\spad{Pfaffian(m)} returns the Pfaffian of the matrix \spad{m}. Error: if the matrix is not antisymmetric.


kind: o
name: phiCoord
exposed: n
type: (Point(R))->R
params: pPointPackage(R)
comment:
\spad{phiCoord(pt)} returns the third element of the point,{} \spad{pt},{} although no assumptions are made as to the coordinate system being used. This function is defined for the convenience of the user dealing with a spherical coordinate system.


kind: o
name: physicalLength!
exposed: n
type: (%,Integer)->%
params: dIndexedFlexibleArray(S,mn)
comment:
\spad{physicalLength!(x,{} n)} changes the physical length of \spad{x} to be \spad{n} and returns the new array.


kind: o
name: pi
exposed: n
type: ()->%
params: dFortranExpression(basicSymbols,subscriptedSymbols,R)
comment:
\spad{\spad{pi}(x)} represents the NAG Library function X01AAF which returns \indented{1}{an approximation to the value of \spad{pi}}


kind: o
name: pile
exposed: n
type: ((Integer,List(OutputForm))->OutputBox)->(Integer,List(OutputForm))->OutputBox
params: cFormatterCategory
comment:
\spad{pile()} returns a handler \spad{h} such that \spad{h(prec,{} args)} formats args according to \spad{hh} and then puts them on top of each other left adjusted. The baseline corresponds to the baseline of the first argument.


kind: o
name: pile
exposed: n
type: (List(%))->%
params: dOutputForm
comment:
\spad{pile(l)} creates the form consisting of the elements of \spad{l} which displays as a pile,{} \spadignore{i.e.} the elements begin on a new line and are indented right to the same margin.


kind: o
name: pivot
exposed: n
type: (%,Integer)->Record(Index:C,Entry:D)
params: dSparseEchelonMatrix(C,D)
comment:
\spad{pivot(A,{} i)} returns the leading entry of the \spad{i}\spad{-}th row of the matrix \spad{A} together with its index.


kind: o
name: plenaryPower
exposed: x
type: (%,PositiveInteger)->%
params: cNonAssociativeAlgebra(R)
comment:
\spad{plenaryPower(a,{} n)} is recursively defined to be \spad{plenaryPower(a,{} n-1)*plenaryPower(a,{} n-1)} for \spad{n>1} and \spad{a} for \spad{n=1}.


kind: o
name: pleskenSplit
exposed: n
type: (UP,R)->Factored(UP)
params: pComplexRootFindingPackage(R,UP)
comment:
\spad{pleskenSplit(poly,{} eps)} determines a start polynomial {\em start}\\ by using startPolynomial then it increases the exponent \spad{n} of {\em start ^ n mod poly} to get an approximate factor of {\em poly},{} in general of degree degree \spad{poly} \spad{-1}. Then a divisor cascade is calculated and the best splitting is chosen,{} as soon as the error is small enough.


kind: o
name: pleskenSplit
exposed: n
type: (UP,R,Boolean)->Factored(UP)
params: pComplexRootFindingPackage(R,UP)
comment:
\spad{pleskenSplit(poly,{} eps,{} info)} determines a start polynomial {\em start} by using startPolynomial then it increases the exponent \spad{n} of {\em start ^ n mod poly} to get an approximate factor of {\em poly},{} in general of degree degree \spad{poly} \spad{-1}. Then a divisor cascade is calculated and the best splitting is chosen,{} as soon as the error is small enough. If {\em info} is {\em true},{} then information messages are issued.


kind: o
name: plot
exposed: n
type: (List((DoubleFloat)->DoubleFloat),Segment(DoubleFloat))->%
params: dPlot
comment:
\spad{plot([f1,{} ...,{} fm],{} a..b)} plots the functions \spad{y = f1(x)},{} ...,{} \spad{y = fm(x)} on the interval \spad{a..b}.


kind: o
name: plot
exposed: n
type: ((DoubleFloat)->DoubleFloat,(DoubleFloat)->DoubleFloat,Segment(DoubleFloat))->%
params: dPlot
comment:
\spad{plot(f,{} g,{} a..b)} plots the parametric curve \spad{x = f(t)},{} \spad{y = g(t)} as \spad{t} ranges over the interval \spad{[a,{} b]}.


kind: o
name: plot
exposed: n
type: ((DoubleFloat)->DoubleFloat,Segment(DoubleFloat),Segment(DoubleFloat))->%
params: dPlot
comment:
\spad{plot(f,{} a..b,{} c..d)} plots the function \spad{f(x)} on the interval \spad{[a,{} b]}; \spad{y}-range of \spad{[c,{} d]} is noted in Plot object.


kind: o
name: plot
exposed: n
type: (List((DoubleFloat)->DoubleFloat),Segment(DoubleFloat),Segment(DoubleFloat))->%
params: dPlot
comment:
\spad{plot([f1,{} ...,{} fm],{} a..b,{} c..d)} plots the functions \spad{y = f1(x)},{} ...,{} \spad{y = fm(x)} on the interval \spad{a..b}; \spad{y}-range of \spad{[c,{} d]} is noted in Plot object.


kind: o
name: plot
exposed: n
type: (S,S,Symbol,Segment(DoubleFloat))->Plot
params: pPlotFunctions1(S)
comment:
\spad{plot(f,{} g,{} t,{} seg)} plots the graph of \spad{x = f(t)},{} \spad{y = g(t)} as \spad{t} ranges over an interval.


kind: o
name: plot
exposed: n
params: dPlot3D
type:
((DoubleFloat)->DoubleFloat,(DoubleFloat)->DoubleFloat,(DoubleFloat)->DoubleFloat,(DoubleFloat)->DoubleFloat,Segment(DoubleFloat))->%

comment:
\spad{plot(f,{} g,{} h,{} a..b)} plots \spad{x} = \spad{f}(\spad{t}),{} \spad{y} = \spad{g}(\spad{t}),{} \spad{z} = \spad{h}(\spad{t}) as \spad{t} ranges over [a,{} \spad{b}].


kind: o
name: plot
exposed: n
params: dPlot
type:
((DoubleFloat)->DoubleFloat,(DoubleFloat)->DoubleFloat,Segment(DoubleFloat),Segment(DoubleFloat),Segment(DoubleFloat))->%

comment:
\spad{plot(f,{} g,{} a..b,{} c..d,{} e..f)} plots the parametric curve \spad{x = f(t)},{} \spad{y = g(t)} as \spad{t} ranges over the interval \spad{[a,{} b]}; \spad{x}-range of \spad{[c,{} d]} and \spad{y}-range of \spad{[e,{} f]} are noted in Plot object.


kind: o
name: plot
exposed: n
params: dPlot3D
comment: \spad{plot(f1,{} f2,{} f3,{} f4,{} x,{} y,{} z,{} w)} \undocumented
type:
((DoubleFloat)->DoubleFloat,(DoubleFloat)->DoubleFloat,(DoubleFloat)->DoubleFloat,(DoubleFloat)->DoubleFloat,Segment(DoubleFloat),Segment(DoubleFloat),Segment(DoubleFloat),Segment(DoubleFloat))->%


kind: o
name: plotPolar
exposed: n
type: ((DoubleFloat)->DoubleFloat)->%
params: dPlot
comment:
\spad{plotPolar(f)} plots the polar curve \spad{r = f(theta)} as theta ranges over the interval \spad{[0,{} 2*\%\spad{pi}]}; this is the same as the parametric curve \spad{x = f(t) * cos(t)},{} \spad{y = f(t) * sin(t)}.


kind: o
name: plotPolar
exposed: n
type: ((DoubleFloat)->DoubleFloat,Segment(DoubleFloat))->%
params: dPlot
comment:
\spad{plotPolar(f,{} a..b)} plots the polar curve \spad{r = f(theta)} as theta ranges over the interval \spad{[a,{} b]}; this is the same as the parametric curve \spad{x = f(t) * cos(t)},{} \spad{y = f(t) * sin(t)}.


kind: o
name: plotPolar
exposed: n
type: (S,Symbol)->Plot
params: pPlotFunctions1(S)
comment:
\spad{plotPolar(f,{} theta)} plots the graph of \spad{r = f(theta)} as theta ranges from 0 to 2 \spad{pi}


kind: o
name: plotPolar
exposed: n
type: (S,Symbol,Segment(DoubleFloat))->Plot
params: pPlotFunctions1(S)
comment:
\spad{plotPolar(f,{} theta,{} seg)} plots the graph of \spad{r = f(theta)} as \spad{theta} ranges over an interval


kind: o
name: plus!
exposed: n
type: (Matrix(R),Matrix(R),Matrix(R))->Matrix(R)
params: pStorageEfficientMatrixOperations(R)
comment:
\spad{plus!(c,{} a,{} b)} computes the matrix sum \spad{a + b} and stores the result in the matrix \spad{c}. Error: if \spad{a},{} \spad{b},{} and \spad{c} do not have the same dimensions.


kind: o
name: pmintegrate
exposed: n
type: (F,Symbol,OrderedCompletion(F),OrderedCompletion(F))->Union(F,failed)
params: pPatternMatchIntegration(R,F)
abbrev:
AND(has(R,ConvertibleTo(Pattern(Integer))),has(R,PatternMatchable(Integer)),has(F,SpecialFunctionCategory))

comment:
\spad{pmintegrate(f,{} x = a..b)} returns the integral of \spad{f(x)dx} from a to \spad{b} if it can be found by the built-in pattern matching rules.


kind: o
name: Pnan?
exposed: n
type: (%)->Boolean
params: cSPointCategory
comment:
\spad{Pnan?(p)} returns \spad{true} if any of its elements are not valid DoubleFloat values. Examples of invalid floating point numbers are when we have divided a given element by zero or taken sqrt of negative number at some stage? Note: we can still represent a point at infinity and we can represent points using complex numbers,{} but we do this using projective or conformal space or by using the appropriate instance of SPointCategory,{} not by using invalid floating point numbers.


kind: o
name: point?
exposed: x
type: (%)->Boolean
params: cThreeSpaceCategory(R)
comment:
\spad{point?(s)} queries whether the \spadtype{ThreeSpace},{} \spad{s},{} is composed of a single component which is a point and returns the boolean result.


kind: o
name: point
exposed: x
type: (List(R))->%
params: cPointCategory(R)
comment:
\spad{point(l)} returns a point category defined by a list \spad{l} of elements from the domain \spad{R}.


kind: o
name: point
exposed: x
type: (Point(R))->%
params: cThreeSpaceCategory(R)
comment:
\spad{point(p)} returns a \spadtype{ThreeSpace} object which is composed of one component,{} the point \spad{p}.


kind: o
name: point
exposed: x
type: (%)->Point(R)
params: cThreeSpaceCategory(R)
comment:
\spad{point(s)} checks to see if the \spadtype{ThreeSpace},{} \spad{s},{} is composed of only a single point and if so,{} returns the point. An error is signaled otherwise.


kind: o
name: point
exposed: x
type: (%,List(R))->%
params: cThreeSpaceCategory(R)
comment:
\spad{point(s,{} [x,{} y,{} z])} adds a point component defined by a list of elements which are from the \spad{PointDomain(R)} to the \spadtype{ThreeSpace},{} \spad{s},{} where \spad{R} is the \spadtype{Ring} over which the point elements are defined.


kind: o
name: point
exposed: x
type: (%,NonNegativeInteger)->%
params: cThreeSpaceCategory(R)
comment:
\spad{point(s,{} i)} adds a point component which is placed into a component list of the \spadtype{ThreeSpace},{} \spad{s},{} at the index given by \spad{i}.


kind: o
name: point
exposed: x
type: (%,Point(R))->%
params: cThreeSpaceCategory(R)
comment:
\spad{point(s,{} p)} adds a point component defined by the point,{} \spad{p},{} specified as a list from \spad{List(R)},{} to the \spadtype{ThreeSpace},{} \spad{s},{} where \spad{R} is the \spadtype{Ring} over which the point is defined.


kind: o
name: point
exposed: n
type: (%,Point(DoubleFloat),Palette)->Void
params: dGraphImage
comment:
\spad{point(\spad{gi},{} pt,{} pal)} modifies the graph \spad{\spad{gi}} of the domain \spadtype{GraphImage} to contain one point component,{} \spad{pt} whose point color is set to be the palette color \spad{pal},{} and whose line color and point size are determined by the default functions \spadfun{lineColorDefault} and \spadfun{pointSizeDefault}.


kind: o
name: point
exposed: n
type: (DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat)->Point(DoubleFloat)
params: pTubePlotTools
comment:
\spad{point(x1,{} x2,{} x3,{} c)} creates and returns a point from the three specified coordinates \spad{x1},{} \spad{x2},{} \spad{x3},{} and also a fourth coordinate,{} \spad{c},{} which is generally used to specify the color of the point.


kind: o
name: pointColor
exposed: x
type: (Float)->%
params: dDrawOption
comment:
\spad{pointColor(v)} specifies a color,{} \spad{v},{} for 2D graph points. This option is expressed in the form \spad{pointColor == v}.


kind: o
name: pointColor
exposed: x
type: (Palette)->%
params: dDrawOption
comment:
\spad{pointColor(p)} specifies a color index for 2D graph points from the spadcolors palette \spad{p}. This option is expressed in the form \spad{pointColor == p}.


kind: o
name: pointColorDefault
exposed: x
type: (Palette)->Palette
params: pViewDefaultsPackage
comment:
\spad{pointColorDefault(p)} sets the default color of points in a 2D viewport to the palette \spad{p}.


kind: o
name: pointColorPalette
exposed: n
type: (List(DrawOption),Palette)->Palette
params: pDrawOptionFunctions0
comment:
\spad{pointColorPalette(l,{} p)} takes the list of draw options,{} \spad{l},{} and checks the list to see if it contains the option \spad{pointColorPalette}. If the option does not exist the value,{} \spad{p} is returned.


kind: o
name: pointData
exposed: n
type: (%)->List(Point(R))
params: dSubSpace(n,R)
comment:
\spad{pointData(s)} returns the list of points from the point data field of the 3 dimensional subspace \spad{s}.


kind: o
name: pointLists
exposed: n
type: (%)->List(List(Point(DoubleFloat)))
params: dGraphImage
comment:
\spad{pointLists(\spad{gi})} returns the list of lists of points which compose the given graph,{} \spad{\spad{gi}},{} of the domain \spadtype{GraphImage}.


kind: o
name: pointPlot
exposed: n
type: ((DoubleFloat)->Point(DoubleFloat),Segment(DoubleFloat))->%
params: dPlot3D
comment:
\spad{pointPlot(f,{} g,{} h,{} a..b)} plots \spad{x} = \spad{f}(\spad{t}),{} \spad{y} = \spad{g}(\spad{t}),{} \spad{z} = \spad{h}(\spad{t}) as \spad{t} ranges over [a,{} \spad{b}].


kind: o
name: pointPlot
exposed: n
type: ((DoubleFloat)->Point(DoubleFloat),Segment(DoubleFloat))->%
params: dPlot
comment:
\spad{pointPlot(t +-> (f(t),{} g(t)),{} a..b)} plots the parametric curve \spad{x = f(t)},{} \spad{y = g(t)} as \spad{t} ranges over the interval \spad{[a,{} b]}.


kind: o
name: pointPlot
exposed: n
params: dPlot
type:
((DoubleFloat)->Point(DoubleFloat),Segment(DoubleFloat),Segment(DoubleFloat),Segment(DoubleFloat))->%

comment:
\spad{pointPlot(t +-> (f(t),{} g(t)),{} a..b,{} c..d,{} e..f)} plots the parametric curve \spad{x = f(t)},{} \spad{y = g(t)} as \spad{t} ranges over the interval \spad{[a,{} b]}; \spad{x}-range of \spad{[c,{} d]} and \spad{y}-range of \spad{[e,{} f]} are noted in Plot object.


kind: o
name: pointPlot
exposed: n
params: dPlot3D
comment: \spad{pointPlot(f,{} x,{} y,{} z,{} w)} \undocumented
type:
((DoubleFloat)->Point(DoubleFloat),Segment(DoubleFloat),Segment(DoubleFloat),Segment(DoubleFloat),Segment(DoubleFloat))->%


kind: o
name: points
exposed: n
type: (%,PositiveInteger,String)->Void
params: dTwoDimensionalViewport
comment:
\spad{points(v,{} n,{} s)} displays the points of the graph in field \spad{n} of the given two-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{TwoDimensionalViewport},{} if \spad{s} is on,{} or does not display the points if \spad{s} is off.


kind: o
name: pol
exposed: n
type: (Vector(GF))->SparseUnivariatePolynomial(GF)
params: pInnerNormalBasisFieldFunctions(GF)
comment:
\spad{pol(v)} turns the vector \spad{[v0,{} ...,{} vn]} into the polynomial \spad{v0+v1*x+ ... + vn*x^n}.


kind: o
name: polar
exposed: x
type: (Point(R))->Point(R)
params: pCoordinateSystems(R)
comment:
\spad{polar(pt)} transforms \spad{pt} from polar coordinates to Cartesian coordinates: the function produced will map the point \spad{(r,{} theta)} to \spad{x = r * cos(theta)},{} \spad{y = r * sin(theta)}.


kind: o
name: polarCoordinates
exposed: x
type: (%)->Record(r:R,phi:R)
params: cComplexCategory(R)
abbrev: AND(has(R,RealNumberSystem),has(R,TranscendentalFunctionCategory))
comment:
\spad{polarCoordinates(x)} returns (\spad{r},{} phi) such that \spad{x} = \spad{r} * exp(\%\spad{i} * phi).


kind: o
name: polCase
exposed: n
type: (Z,NonNegativeInteger,List(Z))->Boolean
params: pLeadingCoefDetermination(OV,E,Z,P)
comment:
\spad{polCase(contprod,{} numFacts,{} evallcs)},{} where \spad{contprod} is the product of the content of the leading coefficient of the polynomial to be factored with the content of the evaluated polynomial,{} \spad{numFacts} is the number of factors of the leadingCoefficient,{} and evallcs is the list of the evaluated factors of the leadingCoefficient,{} returns \spad{true} if the factors of the leading Coefficient can be distributed with this valuation.


kind: o
name: pole?
exposed: n
type: (%)->Boolean
params: dInnerTaylorSeries(Coef)
comment:
\spad{pole?(x)} tests if the series \spad{x} has a pole. \indented{1}{Note: this is \spad{false} when \spad{x} is a Taylor series.}


kind: o
name: poly_factor
exposed: n
params: pExpressionFactorPolynomial(R,F)
comment: \spad{poly_factor(p)} should be local but conditional.
type:
(SparseUnivariatePolynomial(SparseMultivariatePolynomial(R,Kernel(F))))->Factored(SparseUnivariatePolynomial(SparseMultivariatePolynomial(R,Kernel(F))))


kind: o
name: polygamma
exposed: x
type: (%,%)->%
params: cSpecialFunctionCategory
comment:
\spad{polygamma(k,{} x)} is the \spad{k-th} derivative of \spad{digamma(x)},{} (often written \spad{psi(k,{} x)} in the literature).


kind: o
name: polygon?
exposed: x
type: (%)->Boolean
params: cThreeSpaceCategory(R)
comment:
\spad{polygon?(s)} returns \spad{true} if the \spadtype{ThreeSpace} \spad{s} contains a single polygon component,{} or \spad{false} otherwise.


kind: o
name: polygon
exposed: x
type: (List(Point(R)))->%
params: cThreeSpaceCategory(R)
comment:
\spad{polygon([p0,{} p1,{} ...,{} pn])} creates a polygon defined by a list of points,{} \spad{p0} through \spad{pn},{} and returns a \spadtype{ThreeSpace} whose component is the polygon.


kind: o
name: polygon
exposed: x
type: (%)->List(Point(R))
params: cThreeSpaceCategory(R)
comment:
\spad{polygon(s)} checks to see if the \spadtype{ThreeSpace},{} \spad{s},{} is composed of a single polygon component defined by a list of points,{} and if so,{} returns the list of points; An error is signaled otherwise.


kind: o
name: polygon
exposed: x
type: (%,List(List(R)))->%
params: cThreeSpaceCategory(R)
comment:
\spad{polygon(s,{} [[r0],{} [r1],{} ...,{} [rn]])} adds a polygon component defined by a list of points \spad{r0} through \spad{rn},{} which are lists of elements from the domain \spad{PointDomain(m,{} R)} to the \spadtype{ThreeSpace} \spad{s},{} where \spad{m} is the dimension of the points and \spad{R} is the \spadtype{Ring} over which the points are defined.


kind: o
name: polygon
exposed: x
type: (%,List(Point(R)))->%
params: cThreeSpaceCategory(R)
comment:
\spad{polygon(s,{} [p0,{} p1,{} ...,{} pn])} adds a polygon component defined by a list of points,{} \spad{p0} through \spad{pn},{} to the \spadtype{ThreeSpace} \spad{s}.


kind: o
name: polylog_int
exposed: n
params: pParametricIntegration(R,F)
comment: \spad{polylog_int(f,{} x,{} k0,{} [k1,{} ...,{} kn],{} g)}
type:
(F,Symbol,Kernel(F),NonNegativeInteger,List(Kernel(F)),F)->Union(Record(ratpart:F,coeff:F,prim:F),failed)


kind: o
name: polynomial
exposed: x
type: (%,NonNegativeInteger)->Polynomial(Coef)
params: cMultivariateTaylorSeriesCategory(Coef,Var)
comment:
\spad{polynomial(f,{} k)} returns a polynomial consisting of the sum of all terms of \spad{f} of degree \spad{<= k}.


kind: o
name: polynomial
exposed: x
type: (%,NonNegativeInteger,NonNegativeInteger)->Polynomial(Coef)
params: cMultivariateTaylorSeriesCategory(Coef,Var)
comment:
\spad{polynomial(f,{} k1,{} k2)} returns a polynomial consisting of the sum of all terms of \spad{f} of degree \spad{d} with \spad{k1 <= d <= k2}.


kind: o
name: polyRicDE
exposed: n
params: pRationalRicDE(F,UP)
type:
(LinearOrdinaryDifferentialOperator2(UP,Fraction(UP)),(UP)->List(F))->List(Record(poly:UP,eq:LinearOrdinaryDifferentialOperator2(UP,Fraction(UP))))

comment:
\spad{polyRicDE(op,{} zeros)} returns \spad{[[p1,{} L1],{} [p2,{} L2],{} ... ,{} [pk,{} Lk]]} such that the polynomial part of any rational solution of the associated Riccati equation of \spad{op y = 0} must be one of the \spad{pi}\spad{'s} (up to the constant coefficient),{} in which case the equation for \spad{z = y e^{-int p}} is \spad{\spad{Li} z = 0}. \spad{zeros} is a zero finder in \spad{UP}.


kind: o
name: polyRicDE
exposed: n
type: (L,(UP)->List(F))->List(Record(poly:UP,eq:L))
params: pPrimitiveRatRicDE(F,UP,L,LQ)
comment:
\spad{polyRicDE(op,{} zeros)} returns \spad{[[p1,{} L1],{} [p2,{} L2],{} ... ,{} [pk,{} Lk]]} such that the polynomial part of any rational solution of the associated Riccati equation of \spad{op y=0} must be one of the \spad{pi}\spad{'s} (up to the constant coefficient),{} in which case the equation for \spad{z=y e^{-int p}} is \spad{\spad{Li} z =0}. \spad{zeros} is a zero finder in \spad{UP}.


kind: o
name: pomopo!
exposed: x
type: (%,R,E,%)->%
params: cFiniteAbelianMonoidRing(R,E)
comment:
\spad{pomopo!(p1,{} r,{} e,{} p2)} returns \spad{p1 + monomial(r,{} e) * p2} and may use \spad{p1} as workspace. The constant \spad{r} is assumed to be nonzero.


kind: o
name: pop!
exposed: x
type: (%)->S
params: cStackAggregate(S)
comment:
\spad{pop!(s)} returns the top element \spad{x},{} destructively removing \spad{x} from \spad{s}. Note: Use \spad{top(s)} to obtain \spad{x} without removing it from \spad{s}. Error: if \spad{s} is empty.


kind: o
name: position
exposed: x
type: ((S)->Boolean,%)->Integer
params: cLinearAggregate(S)
abbrev: has(%,finiteAggregate)
comment:
\spad{position(p,{} a)} returns the index \spad{i} of the first \spad{x} in \spad{a} such that \spad{p(x)} is \spad{true},{} and \spad{minIndex(a) - 1} if there is no such \spad{x}.


kind: o
name: position
exposed: x
type: (S,%)->Integer
params: cLinearAggregate(S)
abbrev: AND(has(%,finiteAggregate),has(S,BasicType))
comment:
\spad{position(x,{} a)} returns the index \spad{i} of the first occurrence of \spad{x} in a,{} and \spad{minIndex(a) - 1} if there is no such \spad{x}.


kind: o
name: position
exposed: x
type: (CharacterClass,%,Integer)->Integer
params: cStringAggregate
comment:
\spad{position(cc,{} t,{} i)} returns the position \spad{j} in string \spad{t} of the first character belonging to \spad{cc},{} beginning at index \spad{i}. Returns \spad{minIndex(t) - 1} if there is no such \spad{j}.


kind: o
name: position
exposed: x
type: (%,%,Integer)->Integer
params: cStringAggregate
comment:
\spad{position(s,{} t,{} i)} returns the position \spad{j} of the substring \spad{s} in string \spad{t},{} beginning at index \spad{i}. Returns \spad{minIndex(s) - 1} if there is no such \spad{j}.


kind: o
name: position
exposed: x
type: (S,%,Integer)->Integer
params: cLinearAggregate(S)
abbrev: AND(has(%,finiteAggregate),has(S,BasicType))
comment:
\spad{position(x,{} a,{} n)} returns the index \spad{i} of the first occurrence of \spad{x} in \spad{a} where \spad{i >= n},{} and \spad{minIndex(a) - 1} if no such \spad{x} is found.


kind: o
name: positive?
exposed: x
type: (%)->Boolean
params: cIntervalCategory(R)
comment:
\spad{positive?(u)} returns \spad{true} if every element of \spad{u} is positive,{} \spad{false} otherwise.


kind: o
name: positivePower
exposed: x
type: (%,Integer)->%
params: cMatrixCategory(R,Row,Col)
abbrev: has(R,SemiRng)
comment:
\spad{positivePower(x,{} n)} computes a positive integral power of the matrix \spad{x}. Error: if the matrix is not square.


kind: o
name: positiveRemainder
exposed: x
type: (%,%)->%
params: cIntegerNumberSystem
comment:
\spad{positiveRemainder(a,{} b)} (where \spad{b > 1}) yields \spad{r} where \spad{0 <= r < b} and \spad{r = a rem b}.


kind: o
name: positiveSolve
exposed: x
type: (RegularChain(R,ls))->List(List(RealClosure(Fraction(R))))
params: pZeroDimensionalSolvePackage(R,ls,ls2)
comment:
\spad{positiveSolve(ts)} returns the points of the regular set of \spad{ts} with (real) strictly positive coordinates.


kind: o
name: positiveSolve
exposed: x
type: (List(Polynomial(R)),Boolean,Boolean)->List(List(RealClosure(Fraction(R))))
params: pZeroDimensionalSolvePackage(R,ls,ls2)
comment:
\spad{positiveSolve(lp,{} info?,{} lextri?)} returns the set of the points in the variety associated with \spad{lp} whose coordinates are (real) strictly positive. Moreover,{} if \spad{info?} is \spad{true} then some information is displayed during decomposition into regular chains. If \spad{lextri?} is \spad{true} then the lexTriangular algorithm is called from the \spadtype{LexTriangularPackage} constructor (see \spadopFrom{zeroSetSplit}{LexTriangularPackage}(\spad{lp},{} \spad{false})). Otherwise,{} the triangular decomposition is computed directly from the input system by using the \spadopFrom{zeroSetSplit}{RegularChain} from \spadtype{RegularChain}. WARNING: For each set of coordinates given by \spad{positiveSolve(lp,{} info?,{} lextri?)} the ordering of the indeterminates is reversed \spad{w}.\spad{r}.\spad{t}. \spad{ls}.


kind: o
name: possibleOrder
exposed: n
type: (FiniteDivisor(F,UP,UPUP,R))->NonNegativeInteger
params: pPointsOfFiniteOrder(R0,F,UP,UPUP,R)
comment:
\spad{possibleOrder(d)} returns \spad{n} such that \spad{d} is of order \spad{n},{} or of infinite order.


kind: o
name: possiblyInfinite?
exposed: x
type: (%)->Boolean
params: cStreamAggregate(S)
comment:
\spad{possiblyInfinite?(s)} tests if the stream \spad{s} could possibly have an infinite number of elements. Note: for many datatypes,{} \spad{possiblyInfinite?(s) = not explictlyFinite?(s)}.


kind: o
name: possiblyNewVariety?
exposed: n
type: (List(P),List(List(P)))->Boolean
params: pPolynomialSetUtilitiesPackage(R,E,V,P)
comment:
\spad{possiblyNewVariety?(newlp,{} llp)} returns \spad{true} iff for every \spad{lp} in \spad{llp} certainlySubVariety?(\spad{newlp},{} \spad{lp}) does not hold.


kind: o
name: pow
exposed: n
type: ()->PrimitiveArray(%)
params: dModMonic(R,Rep)
comment:
\spad{pow()} returns precomputed array of powers of variable modulo current modulus from defree \spad{d} up to degree \spad{2*d -1},{} where \spad{d} is degree of the modulus. Note: element at index 0 is variable to power \spad{d}.


kind: o
name: pow
exposed: n
type: (U32Vector,PositiveInteger,NonNegativeInteger,Integer)->U32Vector
params: pU32VectorPolynomialOperations
comment:
\spad{pow(u,{} n,{} d,{} p)} returns u^n truncated after degree \spad{d},{} except if \spad{n=1},{} in which case \spad{u} itself is returned


kind: o
name: power
exposed: n
params: cFormatterCategory
type:
(Integer,(Integer,List(OutputForm))->OutputBox,(Integer,List(OutputForm))->OutputBox)->(Integer,List(OutputForm))->OutputBox

comment:
\spad{power(op,{} p,{} h1,{} h2)} returns a handler \spad{h} such that \spad{h(prec,{} args)} formats \spad{args.1} and \spad{args.2} according to \spad{h1} and \spad{h2},{} respectively. Outer parentheses are added if \spad{p < prec}.


kind: o
name: power!
exposed: n
type: (Matrix(R),Matrix(R),Matrix(R),Matrix(R),NonNegativeInteger)->Matrix(R)
params: pStorageEfficientMatrixOperations(R)
comment:
\spad{power!(a,{} b,{} c,{} m,{} n)} computes \spad{m} ^ \spad{n} and stores the result in \spad{a}. The matrices \spad{b} and \spad{c} are used to store intermediate results. Error: if \spad{a},{} \spad{b},{} \spad{c},{} and \spad{m} are not square and of the same dimensions.


kind: o
name: power_matrix
exposed: n
type: (PA,NonNegativeInteger,PMD)->Record(matr:MMT,poly:PA)
params: cModularFactorizationOperations(PA,MMT,MD,PMD)
comment:
\spad{power_matrix(s,{} l,{} rd)} computes [\spad{m},{} \spad{p}] such that \spad{p = s^l} modulo reduction data \spad{rd} and column \spad{j} of \spad{m} contain \spad{s^j} modulo reduction data \spad{rd}. Note that lowest column index is \spad{j = 0} and highest index is \spad{j=l-1}. \spad{rd} should be obtained by earlier call to \spad{ini_rdata}.


kind: o
name: powers
exposed: n
type: (List(Integer))->List(List(Integer))
params: dPartition
comment:
\spad{powers(\spad{li})} returns a list of 2-element lists. For each 2-element list,{} the first element is an entry of \spad{li} and the second element is the multiplicity with which the first element occurs in \spad{li}. There is a 2-element list for each value occurring in \spad{l}.


kind: o
name: powToUPS
exposed: n
params: pFunctionSpaceToUnivariatePowerSeries2(R,FE,Expon,UPS,TRAN,UTS,TEXP,coerce_Ex,x)
comment: \spad{powToUPS should} be local but conditional
type:
(List(FE),Record(pos_Check?:Boolean,atan_Flag:Union(complex,real: two sides,real: left side,real: right side,just do it),coeff_check?:Union((FE)->Boolean,none),inv_check?:Union((FE)->Boolean,none),zero_check?:Union((FE)->Boolean,none),log_x_replace:Boolean,log_x_val:FE,cache:List(Record(ker:Kernel(FE),ser:Union(%series:UPS,%problem:Record(func:String,prob:String))))))->Union(%series:UPS,%problem:Record(func:String,prob:String))


kind: o
name: pquo
exposed: x
type: (%,%)->%
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{pquo(a,{} b)} computes the pseudo-quotient of \spad{a} by \spad{b},{} both viewed as univariate polynomials in the main variable of \spad{b}.


kind: o
name: pquo
exposed: x
type: (%,%,V)->%
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{pquo(a,{} b,{} v)} computes the pseudo-quotient of \spad{a} by \spad{b},{} both viewed as univariate polynomials in \spad{v}.


kind: o
name: precedence
exposed: n
type: (Integer,(Integer,List(OutputForm))->OutputBox)->(Integer,List(OutputForm))->OutputBox
params: cFormatterCategory
comment:
\spad{precedence(p,{} hh)} returns a handler \spad{h} such that \spad{h(prec,{} args)} returns \spad{hh(p,{} args)}. This handler can be used to change the context in which an expression is formatted.


kind: o
name: predicate
exposed: n
type: (Pattern(R))->(D)->Boolean
params: pPatternFunctions1(R,D)
comment:
\spad{predicate(p)} returns the predicate attached to \spad{p},{} the constant function \spad{true} if \spad{p} has no predicates attached to it.


kind: o
name: predicates
exposed: n
type: (%)->List(Any)
params: dPattern(R)
comment:
\spad{predicates(p)} returns \spad{[p1,{} ...,{} pn]} such that the predicate attached to \spad{p} is \spad{p1} and ... and \spad{pn}.


kind: o
name: prefix
exposed: n
type: (%,List(%))->%
params: dOutputForm
comment:
\spad{prefix(f,{} l)} creates a form depicting the \spad{n}-ary prefix application of \spad{f} to a tuple of arguments given by list \spad{l}.


kind: o
name: prefix?
exposed: x
type: (%,%)->Boolean
params: cStringAggregate
comment:
\spad{prefix?(s,{} t)} tests if the string \spad{s} is the initial substring of \spad{t}. Note: \spad{prefix?(s,{} t) = reduce(and,{} [s.i = t.i for i in indices s])}.


kind: o
name: prefix
exposed: n
type: (String,Integer,(Integer,List(OutputForm))->OutputBox)->(Integer,List(OutputForm))->OutputBox
params: cFormatterCategory
comment:
\spad{prefix(s,{} p,{} hh)} returns a handler \spad{h} such that \spad{h(prec,{} args)} formats args according to \spad{hh} and then prefixes this box by \spad{box s}. Outer parentheses are added if \spad{p < prec}.


kind: o
name: prefixRagits
exposed: x
type: (%)->List(Integer)
params: dRadixExpansion(bb)
comment:
\spad{prefixRagits(rx)} returns the non-cyclic part of the ragits of the fractional part of a radix expansion. For example,{} if \spad{x = 3/28 = 0.10 714285 714285 ...},{} then \spad{prefixRagits(x)=[1,{} 0]}.


kind: o
name: pre_gauss
exposed: n
type: (Matrix(Integer))->Matrix(Integer)
params: pUnitGaussianElimination
comment:
\spad{pre_gauss(m)} performs Gaussian eliminaton on rows of \spad{m} using only 1 and \spad{-1} as pivots. Note: \spad{m} is modified in place


kind: o
name: pre_lr
exposed: n
type: (Matrix(Integer),Vector(Integer),Vector(Integer))->Matrix(Integer)
params: pUnitGaussianElimination
comment:
\spad{pre_lr(m,{} \spad{pi},{} pj)} is like pre_gauss,{} but records positions of pivots in \spad{pi} and \spad{pj} and returns transformation matrix. \spad{m},{} \spad{pi},{} \spad{pj} are modified in place


kind: o
name: prem
exposed: x
type: (%,%)->%
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{prem(a,{} b)} computes the pseudo-remainder of \spad{a} by \spad{b},{} both viewed as univariate polynomials in the main variable of \spad{b}.


kind: o
name: prem
exposed: x
type: (%,%,V)->%
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{prem(a,{} b,{} v)} computes the pseudo-remainder of \spad{a} by \spad{b},{} both viewed as univariate polynomials in \spad{v}.


kind: o
name: prepareDecompose
exposed: x
type: (List(P),List(TS),Boolean,Boolean)->List(Record(eq:List(P),tower:TS,ineq:List(P)))
params: pQuasiComponentPackage(R,E,V,P,TS)
comment:
\spad{prepareDecompose(lp,{} lts,{} b1,{} b2)} is an internal subroutine,{} exported only for development.


kind: o
name: prepareSubResAlgo
exposed: x
type: (P,P,TS)->List(Record(val:List(P),tower:TS))
params: pRegularTriangularSetGcdPackage(R,E,V,P,TS)
comment:
\spad{prepareSubResAlgo(p1,{} p2,{} ts)} is an internal subroutine,{} exported only for development.


kind: o
name: pre_smith
exposed: n
type: (Matrix(Integer))->Matrix(Integer)
params: pUnitGaussianElimination
comment:
\spad{pre_smith(m)} first performs pre_gauss(\spad{m}) and then drops all rows and columns of \spad{m} containing pivots.


kind: o
name: previous
exposed: x
type: (%)->%
params: cDoublyLinkedAggregate(S)
comment:
\spad{previous(l)} returns the doubly-link list beginning with its previous element. Error: if \spad{l} has no previous element. Note: \spad{next(previous(l)) = l}.


kind: o
name: primaryDecomp
exposed: x
params: pIdealDecompositionPackage(vl)
type:
(PolynomialIdeal(Fraction(Integer),DirectProduct(#(vl),NonNegativeInteger),OrderedVariableList(vl),DistributedMultivariatePolynomial(vl,Fraction(Integer))))->List(PolynomialIdeal(Fraction(Integer),DirectProduct(#(vl),NonNegativeInteger),OrderedVariableList(vl),DistributedMultivariatePolynomial(vl,Fraction(Integer))))

comment:
\spad{primaryDecomp(I)} returns a list of primary ideals such that their intersection is the ideal \spad{I}.


kind: o
name: prime
exposed: n
type: (Integer)->(Integer,List(OutputForm))->OutputBox
params: cFormatterCategory
comment:
\spad{prime(p)} returns a handler that treats the typesetting of primes. Note that differentiate(a,{} 3) gives the following \spad{s}-expression in OutputForm: (PRIME a


kind: o
name: prime?
exposed: x
type: (%)->Boolean
params: cUniqueFactorizationDomain
comment:
\spad{prime?(x)} tests if \spad{x} can never be written as the product of two non-units of the ring,{} \spadignore{i.e.} \spad{x} is an irreducible element.


kind: o
name: prime?
exposed: x
type: (I)->Boolean
params: pIntegerPrimesPackage(I)
comment:
\spad{prime?(n)} returns \spad{true} if \spad{n} is prime and \spad{false} if not. Note that we ignore sign of \spad{n},{} so \spad{-5} is considered prime. The algorithm used is Rabin\spad{'s} probabilistic primality test (reference: Knuth Volume 2 Semi Numerical Algorithms). If \spad{prime? n} returns \spad{false},{} \spad{n} is proven composite. If \spad{prime? n} returns \spad{true},{} prime? may be in error however,{} the probability of error is very low. and is zero below 25*10^9 (due to a result of Pomerance et al),{} below 10^12 and 10^13 due to results of Pinch,{} and below 341550071728321 due to a result of Jaeschke. Specifically,{} this implementation does at least 10 pseudo prime tests and so the probability of error is \spad{< 4^(-10)}. The running time of this method is cubic in the length of the input \spad{n},{} that is \spad{O( (log n)^3 )},{} for \spad{n<10^20}. beyond that,{} the algorithm is quartic,{} \spad{O( (log n)^4 )}. Two improvements due to Davenport have been incorporated which catches some trivial strong pseudo-primes,{} such as [Jaeschke,{} 1991] 1377161253229053 * 413148375987157,{} which the original algorithm regards as prime


kind: o
name: prime?
exposed: x
params: pIdealDecompositionPackage(vl)
comment: \spad{prime?(I)} tests if the ideal \spad{I} is prime.
type:
(PolynomialIdeal(Fraction(Integer),DirectProduct(#(vl),NonNegativeInteger),OrderedVariableList(vl),DistributedMultivariatePolynomial(vl,Fraction(Integer))))->Boolean


kind: o
name: primeFactor
exposed: x
type: (R,NonNegativeInteger)->%
params: dFactored(R)
comment:
\spad{primeFactor(base,{} exponent)} creates a factored object with a single factor whose \spad{base} is asserted to be prime (flag = prime).


kind: o
name: primextint
exposed: n
params: pParametricTranscendentalIntegration(F,UP)
type:
((UP)->UP,(List(F))->List(Record(ratpart:F,coeffs:Vector(F))),(Matrix(F))->List(Vector(F)),List(Fraction(UP)))->List(Record(ratpart:Fraction(UP),coeffs:Vector(F)))

comment:
\spad{primextint(',{} ext,{} csolve,{} [g1,{} ...,{} gn])} returns a basis of solutions of the homogeneous system \spad{h' + c1*g1 + ... + cn*gn = 0}. Argument \spad{ext} is an extended integration function on \spad{F}. \spad{csolve} is solver over constants.


kind: o
name: primintegrate
exposed: n
params: pTranscendentalIntegration(F,UP)
type:
(Fraction(UP),(UP)->UP,(Fraction(UP))->Record(answer:Fraction(UP),logpart:Fraction(UP),ir:IntegrationResult(Fraction(UP))),(F,NonNegativeInteger)->Union(Record(ratpart:F,coeff:F,prim:F),failed))->Record(answer:IntegrationResult(Fraction(UP)),a0:F)

comment:
\spad{primintegrate(f,{} ',{} foo)} returns \spad{[g,{} a]} such that \spad{f = g' + a},{} and \spad{a = 0} or \spad{a} has no integral in UP. Argument foo is an extended integration function on \spad{F}.


kind: o
name: primitive?
exposed: n
type: (SparseUnivariatePolynomial(GF))->Boolean
params: pFiniteFieldPolynomialPackage(GF)
comment:
\spad{primitive?(f)} tests whether the polynomial \spad{f} over a finite field is primitive,{} \spadignore{i.e.} all its roots are primitive.


kind: o
name: primitive?
exposed: x
type: (%)->Boolean
params: cFiniteFieldCategory
comment:
\spad{primitive?(b)} tests whether the element \spad{b} is a generator of the (cyclic) multiplicative group of the field,{} \spadignore{i.e.} is a primitive element. Implementation Note: see \spad{ch}.IX.1.3,{} th.2 in \spad{D}. Lipson.


kind: o
name: primitiveElement
exposed: x
type: ()->%
params: cFiniteFieldCategory
comment:
\spad{primitiveElement()} returns a primitive element stored in a global variable in the domain. At first call,{} the primitive element is computed by calling \spadfun{createPrimitiveElement}.


kind: o
name: primitiveElement
exposed: x
params: pFunctionSpacePrimitiveElement(R,F)
type:
(List(F))->Record(primelt:F,poly:List(SparseUnivariatePolynomial(F)),prim:SparseUnivariatePolynomial(F))

comment:
\spad{primitiveElement([a1,{} ...,{} an])} returns \spad{[a,{} [q1,{} ...,{} qn],{} q]} such that then \spad{k(a1,{} ...,{} an) = k(a)},{} \spad{\spad{ai} = \spad{qi}(a)},{} and \spad{q(a) = 0}. This operation uses the technique of \spadglossSee{groebner bases}{Groebner basis}.


kind: o
name: primitiveElement
exposed: n
params: pPrimitiveElement(F)
type:
(List(Polynomial(F)),List(Symbol))->Record(coef:List(Integer),poly:List(SparseUnivariatePolynomial(F)),prim:SparseUnivariatePolynomial(F))

comment:
\spad{primitiveElement([p1,{} ...,{} pn],{} [a1,{} ...,{} an])} returns \spad{[[c1,{} ...,{} cn],{} [q1,{} ...,{} qn],{} q]} such that then \spad{k(a1,{} ...,{} an) = k(a)},{} where \spad{a = a1 c1 + ... + an cn},{} \spad{\spad{ai} = \spad{qi}(a)},{} and \spad{q(a) = 0}. The \spad{pi}\spad{'s} are the defining polynomials for the \spad{ai}\spad{'s}. This operation uses the technique of \spadglossSee{groebner bases}{Groebner basis}.


kind: o
name: primitiveElement
exposed: x
params: pFunctionSpacePrimitiveElement(R,F)
abbrev: has(F,AlgebraicallyClosedField)
type:
(F,F)->Record(primelt:F,pol1:SparseUnivariatePolynomial(F),pol2:SparseUnivariatePolynomial(F),prim:SparseUnivariatePolynomial(F))

comment:
\spad{primitiveElement(a1,{} a2)} returns \spad{[a,{} q1,{} q2,{} q]} such that \spad{k(a1,{} a2) = k(a)},{} \spad{\spad{ai} = \spad{qi}(a)},{} and \spad{q(a) = 0}. The minimal polynomial for \spad{a2} may involve \spad{a1},{} but the minimal polynomial for \spad{a1} may not involve \spad{a2}; This operations uses \spadfun{resultant}.


kind: o
name: primitiveElement
exposed: n
params: pPrimitiveElement(F)
type:
(List(Polynomial(F)),List(Symbol),Symbol)->Record(coef:List(Integer),poly:List(SparseUnivariatePolynomial(F)),prim:SparseUnivariatePolynomial(F))

comment:
\spad{primitiveElement([p1,{} ...,{} pn],{} [a1,{} ...,{} an],{} a)} returns \spad{[[c1,{} ...,{} cn],{} [q1,{} ...,{} qn],{} q]} such that then \spad{k(a1,{} ...,{} an) = k(a)},{} where \spad{a = a1 c1 + ... + an cn},{} \spad{\spad{ai} = \spad{qi}(a)},{} and \spad{q(a) = 0}. The \spad{pi}\spad{'s} are the defining polynomials for the \spad{ai}\spad{'s}. This operation uses the technique of \spadglossSee{groebner bases}{Groebner basis}.


kind: o
name: primitiveElement
exposed: n
params: pPrimitiveElement(F)
type:
(Polynomial(F),Symbol,Polynomial(F),Symbol)->Record(coef1:Integer,coef2:Integer,prim:SparseUnivariatePolynomial(F))

comment:
\spad{primitiveElement(p1,{} a1,{} p2,{} a2)} returns \spad{[c1,{} c2,{} q]} such that \spad{k(a1,{} a2) = k(a)} where \spad{a = c1 a1 + c2 a2,{} and q(a) = 0}. The \spad{pi}\spad{'s} are the defining polynomials for the \spad{ai}\spad{'s}. The \spad{p2} may involve \spad{a1},{} but \spad{p1} must not involve \spad{a2}. This operation uses \spadfun{resultant}.


kind: o
name: primitiveMonomials
exposed: n
type: (%)->List(%)
params: cMaybeSkewPolynomialCategory(R,E,VarSet)
abbrev: has(R,SemiRing)
comment:
\spad{primitiveMonomials(p)} gives the list of monomials of the polynomial \spad{p} with their coefficients removed. Note: \spad{primitiveMonomials(sum(a_(i) X^(i))) = [X^(1),{} ...,{} X^(n)]}.


kind: o
name: primitivePart
exposed: x
type: (%)->%
params: cFiniteAbelianMonoidRing(R,E)
abbrev: has(R,GcdDomain)
comment:
\spad{primitivePart(p)} returns the unit normalized form of polynomial \spad{p} divided by the content of \spad{p}.


kind: o
name: primitivePart
exposed: x
type: (%)->%
params: cFunctionFieldCategory(F,UP,UPUP)
comment:
\spad{primitivePart(f)} removes the content of the denominator and the common content of the numerator of \spad{f}.


kind: o
name: primitivePart
exposed: x
type: (%)->%
params: cPolynomialCategory(R,E,VarSet)
abbrev: has(R,GcdDomain)
comment:
\spad{primitivePart(p)} returns the unitCanonical associate of the polynomial \spad{p} with its content divided out.


kind: o
name: primitivePart
exposed: n
type: (UP,R)->UP
params: pSubResultantPackage(R,UP)
abbrev: has(R,EuclideanDomain)
comment:
\spad{primitivePart(p,{} q)} reduces the coefficient of \spad{p} modulo \spad{q},{} takes the primitive part of the result,{} and ensures that the leading coefficient of that result is monic.


kind: o
name: primitivePart
exposed: x
type: (%,VarSet)->%
params: cPolynomialCategory(R,E,VarSet)
abbrev: has(R,GcdDomain)
comment:
\spad{primitivePart(p,{} v)} returns the unitCanonical associate of the polynomial \spad{p} with its content with respect to the variable \spad{v} divided out.


kind: o
name: primitiveRowEchelon
exposed: n
type: (%)->Record(Ech:%,Lt:Matrix(Fraction(D)),Pivots:List(D),Rank:NonNegativeInteger)
params: dSparseEchelonMatrix(C,D)
abbrev: has(D,GcdDomain)
comment:
\spad{primitiveRowEchelon(A)} computes a row echelon form for the matrix \spad{A}. The algorithm used is fraction-free elimination. Every row is made primitive by division by the \spad{gcd}. The algorithm is especially adapted to matrices already close to row echelon form. The transformation matrix,{} the used pivots and the rank of the matrix are also returned.


kind: o
name: primPartElseUnitCanonical
exposed: x
type: (%)->%
params: cRecursivePolynomialCategory(R,E,V)
abbrev: has(R,IntegralDomain)
comment:
\spad{primPartElseUnitCanonical(p)} returns \spad{primitivePart(p)} if \spad{R} is a \spad{gcd}-domain,{} otherwise \spad{unitCanonical(p)}.


kind: o
name: principalIdeal
exposed: x
type: (List(%))->Record(coef:List(%),generator:%)
params: cPrincipalIdealDomain
comment:
\spad{principalIdeal([f1,{} ...,{} fn])} returns a record whose generator component is a generator of the ideal generated by \spad{[f1,{} ...,{} fn]} whose coef component satisfies \spad{generator = sum (input.i * coef.i)}


kind: o
name: principalSubResultantSet
exposed: n
params: pCylindricalAlgebraicDecompositionPackage(TheField)
type:
(SparseUnivariatePolynomial(Polynomial(TheField)),SparseUnivariatePolynomial(Polynomial(TheField)))->List(Polynomial(TheField))


kind: o
name: prindINFO
exposed: n
params: pGroebnerInternalPackage(Dom,Expon,Dpol)
comment: \spad{prindINFO }\undocumented
type:
(Record(lcmfij:Expon,totdeg:NonNegativeInteger,poli:Dpol,polj:Dpol),Dpol,Dpol,Integer,Integer,Integer)->Integer


kind: o
name: print
exposed: x
type: (OutputForm)->Void
params: pPrintPackage
comment:
\spad{print(o)} writes the output form \spad{o} on standard output using the two-dimensional formatter.


kind: o
name: printHeader
exposed: n
type: ()->Void
params: dTheSymbolTable
comment:
\spad{printHeader()} produces the FORTRAN header for the current subprogram in the global symbol table on the current FORTRAN output stream.


kind: o
name: printHeader
exposed: n
type: (Symbol)->Void
params: dTheSymbolTable
comment:
\spad{printHeader(f)} produces the FORTRAN header for subprogram \spad{f} in the global symbol table on the current FORTRAN output stream.


kind: o
name: printHeader
exposed: n
type: (Symbol,%)->Void
params: dTheSymbolTable
comment:
\spad{printHeader(f,{} tab)} produces the FORTRAN header for subprogram \spad{f} in symbol table tab on the current FORTRAN output stream.


kind: o
name: printInfo!
exposed: n
type: (String,String)->Void
params: pTabulatedComputationPackage(Key,Entry)
comment:
\spad{printInfo!(x,{} y)} initializes the messages to be printed when manipulating items from the hash-table. If a key is retrieved then \spad{x} is displayed. If an item is stored then \spad{y} is displayed.


kind: o
name: printingInfo?
exposed: n
type: ()->Boolean
params: pTabulatedComputationPackage(Key,Entry)
comment:
\spad{printingInfo?()} returns \spad{true} iff messages are printed when manipulating items from the hash-table.


kind: o
name: printSys
exposed: n
type: (List(D))->OutputForm
params: dJetDifferentialEquation(JB,D)
comment:
\spad{printSys(sys)} writes a list of functions as a vector of equations (with right hand side 0) and coerces the result to \spadtype{OutputForm}.


kind: o
name: printTypes
exposed: n
type: (Symbol)->Void
params: dTheSymbolTable
comment:
\spad{printTypes(tab)} produces FORTRAN type declarations from \spad{tab},{} on the current FORTRAN output stream


kind: o
name: probablyZeroDim?
exposed: n
type: (List(P))->Boolean
params: pPolynomialSetUtilitiesPackage(R,E,V,P)
comment:
\spad{probablyZeroDim?(lp)} returns \spad{true} iff the number of polynomials in \spad{lp} is not smaller than the number of variables occurring in these polynomials.


kind: o
name: processTemplate
exposed: n
type: (FileName)->FileName
params: dFortranTemplate
comment:
\spad{processTemplate(tp)} processes the template \spad{tp},{} writing the result to the current FORTRAN output stream.


kind: o
name: processTemplate
exposed: n
type: (FileName,FileName)->FileName
params: dFortranTemplate
comment:
\spad{processTemplate(tp,{} fn)} processes the template \spad{tp},{} writing the result out to \spad{fn}.


kind: o
name: prod
exposed: n
type: (%,%)->%
params: dOutputForm
comment:
\spad{prod(expr,{} lowerlimit)} creates the form prefixing \spad{expr} by a capital \spad{pi} with a lowerlimit.


kind: o
name: prod
exposed: n
type: (%,%,%)->%
params: dOutputForm
comment:
\spad{prod(expr,{} lowerlimit,{} upperlimit)} creates the form prefixing \spad{expr} by a capital \spad{pi} with both a \spad{lowerlimit} and upperlimit.


kind: o
name: prodiag
exposed: n
type: (Stream(Stream(A)))->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{prodiag(x)} performs diagonal infinite product of a stream of streams. When \spad{x(i)} is interpreted as stream of coefficients of series \spad{f_i(z),{} i=1,{}...},{} then \spad{prodiag(x) = (1 + z*f_1(z))*(1 + z^2*f_2(x))*...}


kind: o
name: product
exposed: n
type: (Integer)->(Integer,List(OutputForm))->OutputBox
params: cFormatterCategory
comment:
\spad{product(p)} returns a handler \spad{h} such that \spad{h(prec,{} args)} formats a product with product sign and respective limits. Outer parentheses are added if \spad{p < prec}.


kind: o
name: product
exposed: n
type: (%,%)->%
params: dCubicalFacet
comment:
This function returns the product of two cubical facets. Unlike the simplex case,{} the product is a single facet


kind: o
name: product
exposed: n
type: (%,%)->%
params: dFiniteSimplicialComplex(VS)
comment:
Forms product of two simplicial complexes. For more detailed explanation of simplex product code see: \url{http://www.euclideanspace.com/prog/scratchpad/mycode/topology/simplex/product/} Also see Hatcher [9]. page 277 - The simplicial cross product. page 278 - The cohomology cross product. Returns list,{} each entry is a 'lattice path' from (0,{} 0) to (\spad{x},{} \spad{y}) where \spad{x} is number of entries in sa and \spad{y} is number of entries in \spad{sb}.


kind: o
name: product
exposed: n
type: (F,SegmentBinding(F))->F
params: pCombinatorialFunction(R,F)
comment:
\spad{product(f(n),{} n = a..b)} returns \spad{f}(a) * ... * \spad{f}(\spad{b}) as a formal product.


kind: o
name: product
exposed: n
type: (F,Symbol)->F
params: pCombinatorialFunction(R,F)
comment:
\spad{product(f(n),{} n)} returns the formal product \spad{P}(\spad{n}) which verifies \spad{P}(\spad{n+1})\spad{/P}(\spad{n}) = \spad{f}(\spad{n}).


kind: o
name: product
exposed: n
type: (%,%)->List(ProductFacet)
params: dOrientedFacet
comment:
This function returns the product of two facets. For more detailed explanation of simplex product code see: \url{http://www.euclideanspace.com/prog/scratchpad/mycode/topology/simplex/product/} Also see Hatcher [9]. page 277 - The simplicial cross product. page 278 - The cohomology cross product. Returns list,{} each entry is a 'lattice path' from (0,{} 0) to (\spad{x},{} \spad{y}) where \spad{x} is number of entries in sa and \spad{y} is number of entries in \spad{sb}.


kind: o
name: product
exposed: x
type: (%,%)->%
params: cGradedAlgebra(R,E)
comment:
\spad{product(a,{} b)} is the degree-preserving \spad{R}-linear product: \blankline \indented{2}{\spad{degree product(a,{} b) = degree a + degree b}} \indented{2}{\spad{product(a1+a2,{} b) = product(a1,{} b) + product(a2,{} b)}} \indented{2}{\spad{product(a,{} b1+b2) = product(a,{} b1) + product(a,{} b2)}} \indented{2}{\spad{product(r*a,{} b) = product(a,{} r*b) = r*product(a,{} b)}} \indented{2}{\spad{product(a,{} product(b,{} c)) = product(product(a,{} b),{} c)}}


kind: o
name: product
exposed: x
type: (%,%)->%
params: dCartesianTensor(minix,dim,R)
comment:
\spad{product(s,{} t)} is the outer product of the tensors \spad{s} and \spad{t}. For example,{} if \spad{r = product(s,{} t)} for rank 2 tensors \spad{s} and \spad{t},{} then \spad{r} is a rank 4 tensor given by \indented{4}{\spad{r(i,{} j,{} k,{} l) = s(i,{} j)*t(k,{} l)}.}


kind: o
name: project
exposed: n
type: (%,NonNegativeInteger)->%
params: dJetDifferentialEquation(JB,D)
comment:
\spad{project(de,{} q)} projects the differential equation \spad{de} of order higher than \spad{q} into the \spad{q}\spad{-}th order jet bundle.


kind: o
name: projectiveSpace
exposed: n
type: (Integer)->FiniteSimplicialComplex(VS)
params: pSimplicialComplexFactory(VS)
comment:
Generate a minimal triangulation of the surface of a projective plane. A one sided surface which cannot be embedded in 3D space without intersecting itself. There are no external boundaries,{} every edge connects two faces. (A punctured projective plane is equivalent to a Moebius band)


kind: o
name: projectiveSpace
exposed: n
type: (NonNegativeInteger)->FiniteCubicalComplex(Integer)
params: pCubicalComplexFactory
comment:
Generate a cubical complex of the surface of a projective plane. A one sided surface which cannot be embedded in 3D space without intersecting itself. There are no external boundaries,{} every edge connects two faces. (A punctured projective plane is equivalent to a Moebius band)


kind: o
name: prolateSpheroidal
exposed: x
type: (R)->(Point(R))->Point(R)
params: pCoordinateSystems(R)
comment:
\spad{prolateSpheroidal(a)} transforms from prolate spheroidal coordinates to Cartesian coordinates: \spad{prolateSpheroidal(a)} is a function which will map the point \spad{(\spad{xi},{} eta,{} phi)} to \spad{x = a*sinh(\spad{xi})*sin(eta)*cos(phi)},{} \spad{y = a*sinh(\spad{xi})*sin(eta)*sin(phi)},{} \spad{z = a*cosh(\spad{xi})*cos(eta)}.


kind: o
name: prolong
exposed: n
type: (%)->Record(SDe:%,IC:List(D))
params: dJetDifferentialEquation(JB,D)
comment:
\spad{prolong(de)} prolongs the differential equation \spad{de}. Additionally the arising integrability conditions are returned.


kind: o
name: prolong
exposed: n
type: (%,NonNegativeInteger)->%
params: dJetVectorField(JB,D)
comment:
\spad{prolong(v,{} q)} prolongs a vector field \spad{v} defined on the base space into the jet bundle of order \spad{q}.


kind: o
name: prolong
exposed: n
type: (%,NonNegativeInteger)->Record(SDe:%,IC:List(D))
params: dJetDifferentialEquation(JB,D)
comment:
\spad{prolong(de,{} q)} is like \spad{prolong(de)}. However,{} only equations of lower order than \spad{q} are prolonged.


kind: o
name: prolongMV
exposed: n
params: dJetDifferentialEquation(JB,D)
type:
(Record(Rank:NonNegativeInteger,NumMultVar:NonNegativeInteger,Betas:List(NonNegativeInteger)))->Record(Rank:NonNegativeInteger,NumMultVar:NonNegativeInteger,Betas:List(NonNegativeInteger))

comment:
\spad{prolongMV(mv)} calculates the number of multiplicative variables for the prolongation of an involutive symbol.


kind: o
name: property
exposed: x
type: (%,Symbol)->Union(None,failed)
params: dBasicOperator
comment:
\spad{property(op,{} s)} returns the value of property \spad{s} if it is attached to \spad{op},{} and failed otherwise.


kind: o
name: pseudoDivide
exposed: x
type: (%,%)->Record(coef:R,quotient:%,remainder:%)
params: cUnivariatePolynomialCategory(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{pseudoDivide(p,{} q)} returns \spad{[c,{} s,{} r]},{} when \spad{p' := p*lc(q)^(deg p - deg q + 1) = c * p} is pseudo right-divided by \spad{q},{} \spadignore{i.e.} \spad{p' = s q + r}.


kind: o
name: pseudoDivide
exposed: x
type: (%,%)->Record(quotient:%,remainder:%)
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{pseudoDivide(a,{} b)} computes \spad{[pquo(a,{} b),{} prem(a,{} b)]},{} both polynomials viewed as univariate polynomials in the main variable of \spad{b},{} if \spad{b} is not a constant polynomial.


kind: o
name: pseudoQuotient
exposed: x
type: (%,%)->%
params: cUnivariatePolynomialCategory(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{pseudoQuotient(p,{} q)} returns \spad{s},{} the quotient when \spad{p' := p*lc(q)^(deg p - deg q + 1)} is pseudo right-divided by \spad{q},{} \spadignore{i.e.} \spad{p' = s q + r}.


kind: o
name: pseudoRemainder
exposed: x
type: (%,%)->%
params: cUnivariatePolynomialCategory(R)
abbrev: has(R,Ring)
comment:
\spad{pseudoRemainder(p,{} q)} = \spad{r},{} for polynomials \spad{p} and \spad{q},{} returns the remainder \spad{r} when \spad{p' := p*lc(q)^(deg p - deg q + 1)} is pseudo right-divided by \spad{q},{} \spadignore{i.e.} \spad{p' = s q + r}.


kind: o
name: psolve
exposed: n
params: pParametricLinearEquations(R,Var,Expon,GR)
type:
(Matrix(GR))->List(Record(eqzro:List(GR),neqzro:List(GR),wcond:List(Polynomial(R)),bsoln:Record(partsol:Vector(Fraction(Polynomial(R))),basis:List(Vector(Fraction(Polynomial(R)))))))

comment:
\spad{psolve(c)} solves the homogeneous linear system \spad{c} \spad{z} = 0 for all possible ranks of the matrix \spad{c}


kind: o
name: psolve
exposed: n
params: pParametricLinearEquations(R,Var,Expon,GR)
type:
(Matrix(GR),List(GR))->List(Record(eqzro:List(GR),neqzro:List(GR),wcond:List(Polynomial(R)),bsoln:Record(partsol:Vector(Fraction(Polynomial(R))),basis:List(Vector(Fraction(Polynomial(R)))))))

comment:
\spad{psolve(c,{} w)} solves \spad{c} \spad{z} = \spad{w} for all possible ranks of the matrix \spad{c} and given right hand side vector \spad{w}


kind: o
name: psolve
exposed: n
params: pParametricLinearEquations(R,Var,Expon,GR)
type:
(Matrix(GR),List(Symbol))->List(Record(eqzro:List(GR),neqzro:List(GR),wcond:List(Polynomial(R)),bsoln:Record(partsol:Vector(Fraction(Polynomial(R))),basis:List(Vector(Fraction(Polynomial(R)))))))

comment:
\spad{psolve(c,{} w)} solves \spad{c} \spad{z} = \spad{w} for all possible ranks of the matrix \spad{c} and indeterminate right hand side \spad{w}


kind: o
name: psolve
exposed: n
params: pParametricLinearEquations(R,Var,Expon,GR)
type:
(Matrix(GR),PositiveInteger)->List(Record(eqzro:List(GR),neqzro:List(GR),wcond:List(Polynomial(R)),bsoln:Record(partsol:Vector(Fraction(Polynomial(R))),basis:List(Vector(Fraction(Polynomial(R)))))))

comment:
\spad{psolve(c)} solves the homogeneous linear system \spad{c} \spad{z} = 0 for all possible ranks \spad{>=} \spad{k} of the matrix \spad{c}


kind: o
name: psolve
exposed: n
type: (Matrix(GR),String)->Integer
params: pParametricLinearEquations(R,Var,Expon,GR)
comment:
\spad{psolve(c,{} s)} solves \spad{c} \spad{z} = 0 for all possible ranks of the matrix \spad{c} and given right hand side vector \spad{w},{} writes the results to a file named \spad{s},{} and returns the number of regimes


kind: o
name: psolve
exposed: n
params: pParametricLinearEquations(R,Var,Expon,GR)
type:
(Matrix(GR),List(GR),PositiveInteger)->List(Record(eqzro:List(GR),neqzro:List(GR),wcond:List(Polynomial(R)),bsoln:Record(partsol:Vector(Fraction(Polynomial(R))),basis:List(Vector(Fraction(Polynomial(R)))))))

comment:
\spad{psolve(c,{} w,{} k)} solves \spad{c} \spad{z} = \spad{w} for all possible ranks \spad{>=} \spad{k} of the matrix \spad{c} and given right hand side vector \spad{w}


kind: o
name: psolve
exposed: n
type: (Matrix(GR),List(GR),String)->Integer
params: pParametricLinearEquations(R,Var,Expon,GR)
comment:
\spad{psolve(c,{} w,{} s)} solves \spad{c} \spad{z} = \spad{w} for all possible ranks of the matrix \spad{c} and given right hand side vector \spad{w},{} writes the results to a file named \spad{s},{} and returns the number of regimes


kind: o
name: psolve
exposed: n
params: pParametricLinearEquations(R,Var,Expon,GR)
type:
(Matrix(GR),List(Symbol),PositiveInteger)->List(Record(eqzro:List(GR),neqzro:List(GR),wcond:List(Polynomial(R)),bsoln:Record(partsol:Vector(Fraction(Polynomial(R))),basis:List(Vector(Fraction(Polynomial(R)))))))

comment:
\spad{psolve(c,{} w,{} k)} solves \spad{c} \spad{z} = \spad{w} for all possible ranks \spad{>=} \spad{k} of the matrix \spad{c} and indeterminate right hand side \spad{w}


kind: o
name: psolve
exposed: n
type: (Matrix(GR),List(Symbol),String)->Integer
params: pParametricLinearEquations(R,Var,Expon,GR)
comment:
\spad{psolve(c,{} w,{} s)} solves \spad{c} \spad{z} = \spad{w} for all possible ranks of the matrix \spad{c} and indeterminate right hand side \spad{w},{} writes the results to a file named \spad{s},{} and returns the number of regimes


kind: o
name: psolve
exposed: n
type: (Matrix(GR),PositiveInteger,String)->Integer
params: pParametricLinearEquations(R,Var,Expon,GR)
comment:
\spad{psolve(c,{} k,{} s)} solves \spad{c} \spad{z} = 0 for all possible ranks \spad{>=} \spad{k} of the matrix \spad{c},{} writes the results to a file named \spad{s},{} and returns the number of regimes


kind: o
name: psolve
exposed: n
type: (Matrix(GR),List(GR),PositiveInteger,String)->Integer
params: pParametricLinearEquations(R,Var,Expon,GR)
comment:
\spad{psolve(c,{} w,{} k,{} s)} solves \spad{c} \spad{z} = \spad{w} for all possible ranks \spad{>=} \spad{k} of the matrix \spad{c} and given right hand side \spad{w},{} writes the results to a file named \spad{s},{} and returns the number of regimes


kind: o
name: psolve
exposed: n
type: (Matrix(GR),List(Symbol),PositiveInteger,String)->Integer
params: pParametricLinearEquations(R,Var,Expon,GR)
comment:
\spad{psolve(c,{} w,{} k,{} s)} solves \spad{c} \spad{z} = \spad{w} for all possible ranks \spad{>=} \spad{k} of the matrix \spad{c} and indeterminate right hand side \spad{w},{} writes the results to a file named \spad{s},{} and returns the number of regimes


kind: o
name: ptFunc
exposed: n
params: pMeshCreationRoutinesForThreeDimensions
comment: \spad{ptFunc(a,{} b,{} c,{} d)} is an internal function exported in order to compile packages.
type:
((DoubleFloat,DoubleFloat)->DoubleFloat,(DoubleFloat,DoubleFloat)->DoubleFloat,(DoubleFloat,DoubleFloat)->DoubleFloat,(DoubleFloat,DoubleFloat,DoubleFloat)->DoubleFloat)->(DoubleFloat,DoubleFloat)->Point(DoubleFloat)


kind: o
name: puiseux
exposed: x
type: (FE)->Any
params: pExpressionToUnivariatePowerSeries(R,FE)
comment:
\spad{puiseux(f)} returns a Puiseux expansion of the expression \spad{f}. Note: \spad{f} should have only one variable; the series will be expanded in powers of that variable.


kind: o
name: puiseux
exposed: x
type: (FE,Equation(FE))->Any
params: pExpressionToUnivariatePowerSeries(R,FE)
comment:
\spad{puiseux(f,{} x = a)} expands the expression \spad{f} as a Puiseux series in powers of \spad{(x - a)}.


kind: o
name: puiseux
exposed: x
type: (FE,Fraction(Integer))->Any
params: pExpressionToUnivariatePowerSeries(R,FE)
comment:
\spad{puiseux(f,{} n)} returns a Puiseux expansion of the expression \spad{f}. Note: \spad{f} should have only one variable; the series will be expanded in powers of that variable and terms will be computed up to order at least \spad{n}.


kind: o
name: puiseux
exposed: x
type: (FE,Equation(FE),Fraction(Integer))->Any
params: pExpressionToUnivariatePowerSeries(R,FE)
comment:
\spad{puiseux(f,{} x = a,{} n)} expands the expression \spad{f} as a Puiseux series in powers of \spad{(x - a)}; terms will be computed up to order at least \spad{n}.


kind: o
name: puiseux
exposed: n
type: ((Fraction(Integer))->FE,Equation(FE),UniversalSegment(Fraction(Integer)),Fraction(Integer))->Any
params: pGenerateUnivariatePowerSeries2(FE)
comment:
\spad{puiseux(n +-> a(n),{} x = a,{} r0..,{} r)} returns \spad{sum(n = r0,{} r0 + r,{} r0 + 2*r...,{} a(n) * (x - a)^n)}; \spad{puiseux(n +-> a(n),{} x = a,{} r0..r1,{} r)} returns \spad{sum(n = r0 + k*r while n <= r1,{} a(n) * (x - a)^n)}.


kind: o
name: puiseux
exposed: n
type: (FE,Symbol,Equation(FE),UniversalSegment(Fraction(Integer)),Fraction(Integer))->Any
params: pGenerateUnivariatePowerSeries2(FE)
abbrev: AND(has(FE,Evalable(FE)),has(FE,RetractableTo(Fraction(Integer))))
comment:
\spad{puiseux(a(n),{} n,{} x = a,{} r0..,{} r)} returns \spad{sum(n = r0,{} r0 + r,{} r0 + 2*r...,{} a(n) * (x - a)^n)}; \spad{puiseux(a(n),{} n,{} x = a,{} r0..r1,{} r)} returns \spad{sum(n = r0 + k*r while n <= r1,{} a(n) * (x - a)^n)}.


kind: o
name: puiseux
exposed: n
type: ((Fraction(Integer))->R,Symbol,R,UniversalSegment(Fraction(Integer)),Fraction(Integer))->Any
params: pGenerateUnivariatePowerSeries1(R)
comment:
\spad{puiseux(n +-> a(n),{} x,{} a,{} r0..,{} r)} returns \spad{sum(n = r0,{} r0 + r,{} r0 + 2*r...,{} a(n) * (x - a)^n)}; \spad{puiseux(n +-> a(n),{} x = a,{} r0..r1,{} r)} returns \spad{sum(n = r0 + k*r while n <= r1,{} a(n) * (x - a)^n)}.


kind: o
name: pureLex
exposed: n
type: (Vector(S),Vector(S))->Boolean
params: pOrderingFunctions(dim,S)
comment:
\spad{pureLex(v1,{} v2)} return \spad{true} if the vector \spad{v1} is less than the vector \spad{v2} in the lexicographic ordering.


kind: o
name: purelyAlgebraic?
exposed: x
type: (%)->Boolean
params: cRegularTriangularSetCategory(R,E,V,P)
comment:
\spad{purelyAlgebraic?(ts)} returns \spad{true} iff for every algebraic variable \spad{v} of \spad{ts} we have \spad{algebraicCoefficients?(t_v,{} ts_v_-)} where \spad{ts_v} is \spadopFrom{select}{TriangularSetCategory}(\spad{ts},{} \spad{v}) and \spad{ts_v_-} is \spadopFrom{collectUnder}{TriangularSetCategory}(\spad{ts},{} \spad{v}).


kind: o
name: purelyAlgebraic?
exposed: x
type: (P,%)->Boolean
params: cRegularTriangularSetCategory(R,E,V,P)
comment:
\spad{purelyAlgebraic?(p,{} ts)} returns \spad{true} iff every variable of \spad{p} is algebraic \spad{w}.\spad{r}.\spad{t}. \spad{ts}.


kind: o
name: purelyAlgebraicLeadingMonomial?
exposed: x
type: (P,%)->Boolean
params: cRegularTriangularSetCategory(R,E,V,P)
comment:
\spad{purelyAlgebraicLeadingMonomial?(p,{} ts)} returns \spad{true} iff the main variable of any non-constant iterarted initial of \spad{p} is algebraic \spad{w}.\spad{r}.\spad{t}. \spad{ts}.


kind: o
name: purelyTranscendental?
exposed: x
type: (P,%)->Boolean
params: cRegularTriangularSetCategory(R,E,V,P)
comment:
\spad{purelyTranscendental?(p,{} ts)} returns \spad{true} iff every variable of \spad{p} is not algebraic \spad{w}.\spad{r}.\spad{t}. \spad{ts}


kind: o
name: purge!
exposed: n
type: (%,(C)->Boolean)->Void
params: dSparseEchelonMatrix(C,D)
comment:
\spad{purge!(A,{} crit)} eliminates all columns belonging to an index \spad{c} such that \spad{crit(c)} yields \spad{true}.


kind: o
name: push!
exposed: x
type: (S,%)->S
params: cStackAggregate(S)
comment:
\spad{push!(x,{} s)} pushes \spad{x} onto stack \spad{s},{} \spadignore{i.e.} destructively changing \spad{s} so as to have a new first (top) element \spad{x}. Afterwards,{} pop!(\spad{s}) produces \spad{x} and pop!(\spad{s}) produces the original \spad{s}.


kind: o
name: pushdown
exposed: x
type: (PRF,OV)->PRF
params: pMPolyCatRationalFunctionFactorizer(E,OV,R,PRF)
comment:
\spad{pushdown(prf,{} var)} pushes all top level occurrences of the variable var into the coefficient domain for the polynomial \spad{prf}.


kind: o
name: pushdterm
exposed: x
type: (SparseUnivariatePolynomial(PRF),OV)->PRF
params: pMPolyCatRationalFunctionFactorizer(E,OV,R,PRF)
comment:
\spad{pushdterm(monom,{} var)} pushes all top level occurrences of the variable var into the coefficient domain for the monomial \spad{monom}.


kind: o
name: pushucoef
exposed: x
type: (SparseUnivariatePolynomial(Polynomial(R)),OV)->PRF
params: pMPolyCatRationalFunctionFactorizer(E,OV,R,PRF)
comment:
\spad{pushucoef(upoly,{} var)} converts the anonymous univariate polynomial \spad{upoly} to a polynomial in var over rational functions.


kind: o
name: pushuconst
exposed: x
type: (Fraction(Polynomial(R)),OV)->PRF
params: pMPolyCatRationalFunctionFactorizer(E,OV,R,PRF)
comment:
\spad{pushuconst(r,{} var)} takes a rational function and raises all occurrences of the variable var to the polynomial level.


kind: o
name: pushup
exposed: x
type: (PRF,OV)->PRF
params: pMPolyCatRationalFunctionFactorizer(E,OV,R,PRF)
comment:
\spad{pushup(prf,{} var)} raises all occurrences of the variable var in the coefficients of the polynomial \spad{prf} back to the polynomial level.


kind: o
name: putColorInfo
exposed: n
type: (List(List(Point(DoubleFloat))),List(Palette))->List(List(Point(DoubleFloat)))
params: dGraphImage
comment:
\spad{putColorInfo(llp,{} lpal)} takes a list of list of points,{} \spad{llp},{} and returns the points with their hue and shade components set according to the list of palette colors,{} \spad{lpal}.


kind: o
name: putGraph
exposed: n
type: (%,GraphImage,PositiveInteger)->Void
params: dTwoDimensionalViewport
comment:
\spad{putGraph(v,{} \spad{gi},{} n)} sets the graph field indicated by \spad{n},{} of the indicated two-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{TwoDimensionalViewport},{} to be the graph,{} \spad{\spad{gi}} of domain \spadtype{GraphImage}. The contents of viewport,{} \spad{v},{} will contain \spad{\spad{gi}} when the function \spadfun{makeViewport2D} is called to create the an updated viewport \spad{v}.


kind: o
name: qaddColumns!
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger,R)->%
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{addColumns!(p,{} i,{} j,{} alpha)} adds alpha*column(\spad{i}) to column(\spad{j}) in all matrices of the linear pencil \spad{p}. (no index check)


kind: o
name: qaddRows!
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger,R)->%
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{qaddRows!(p,{} i,{} j,{} alpha)} adds alpha*row(\spad{i}) to row(\spad{j}) in all matrices of the linear pencil \spad{p} (no index check). (no index check)


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


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


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


