# olibdb

kind: o
name: complexEigenvectors
exposed: x
params: pNumericComplexEigenPackage(Par)
type:
(Matrix(Complex(Fraction(Integer))),Par)->List(Record(outval:Complex(Par),outmult:Integer,outvect:List(Matrix(Complex(Par)))))

comment:
\spad{complexEigenvectors(m,{} eps)} returns a list of records each one containing a complex eigenvalue,{} its algebraic multiplicity,{} and a list of associated eigenvectors. All these results are computed to precision eps and are expressed as complex floats or complex rational numbers depending on the type of eps (float or rational).


kind: o
name: complexElementary
exposed: x
type: (F)->F
params: pComplexTrigonometricManipulations(R,F)
comment:
\spad{complexElementary(f)} rewrites \spad{f} in terms of the 2 fundamental complex transcendental elementary functions: \spad{log,{} exp}.


kind: o
name: complexElementary
exposed: x
type: (F,Symbol)->F
params: pComplexTrigonometricManipulations(R,F)
comment:
\spad{complexElementary(f,{} x)} rewrites the kernels of \spad{f} involving \spad{x} in terms of the 2 fundamental complex transcendental elementary functions: \spad{log,{} exp}.


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


kind: o
name: complexLimit
exposed: x
params: pRationalFunctionLimitPackage(R)
type:
(Fraction(Polynomial(R)),Equation(Fraction(Polynomial(R))))->OnePointCompletion(Fraction(Polynomial(R)))

comment:
\spad{complexLimit(f(x),{} x = a)} computes the complex limit of \spad{f} as its argument \spad{x} approaches \spad{a}.


kind: o
name: complexLimit
exposed: x
params: pRationalFunctionLimitPackage(R)
type:
(Fraction(Polynomial(R)),Equation(OnePointCompletion(Polynomial(R))))->OnePointCompletion(Fraction(Polynomial(R)))

comment:
\spad{complexLimit(f(x),{} x = a)} computes the complex limit of \spad{f} as its argument \spad{x} approaches \spad{a}.


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


kind: o
name: complexNormalize
exposed: x
type: (F,Symbol)->F
params: pComplexTrigonometricManipulations(R,F)
comment:
\spad{complexNormalize(f,{} x)} rewrites \spad{f} using the least possible number of complex independent kernels involving \spad{x}.


kind: o
name: complexNumeric
exposed: x
type: (Complex(S),PositiveInteger)->Complex(Float)
params: pNumeric(S)
abbrev: has(S,CommutativeRing)
comment:
\spad{complexNumeric(x,{} n)} returns a complex approximation of \spad{x} up to \spad{n} decimal places.


kind: o
name: complexNumericIfCan
exposed: x
type: (Expression(Complex(S)))->Union(Complex(Float),failed)
params: pNumeric(S)
abbrev: AND(has(S,IntegralDomain),has(S,OrderedSet))
comment:
\spad{complexNumericIfCan(x)} returns a complex approximation of \spad{x},{} or failed if \spad{x} is not a constant.


kind: o
name: complexNumericIfCan
exposed: x
type: (Polynomial(Complex(S)))->Union(Complex(Float),failed)
params: pNumeric(S)
abbrev: has(S,CommutativeRing)
comment:
\spad{complexNumericIfCan(x)} returns a complex approximation of \spad{x},{} or failed if \spad{x} is not constant.


kind: o
name: complexNumericIfCan
exposed: x
type: (Expression(Complex(S)),PositiveInteger)->Union(Complex(Float),failed)
params: pNumeric(S)
abbrev: AND(has(S,IntegralDomain),has(S,OrderedSet))
comment:
\spad{complexNumericIfCan(x,{} n)} returns a complex approximation of \spad{x} up to \spad{n} decimal places,{} or failed if \spad{x} is not a constant.


kind: o
name: complexNumericIfCan
exposed: x
type: (Fraction(Polynomial(S)),PositiveInteger)->Union(Complex(Float),failed)
params: pNumeric(S)
abbrev: has(S,IntegralDomain)
comment:
\spad{complexNumericIfCan(x,{} n)} returns a complex approximation of \spad{x},{} or failed if \spad{x} is not a constant.


kind: o
name: complex_roots
exposed: n
params: pRootUtilities(R,F)
type:
(SparseUnivariatePolynomial(F))->Union(Record(reals:List(F),complexes:List(Record(real:F,imag:F))),failed)

comment:
\spad{complex_roots(p)} computes roots of \spad{p} in terms of radicals separating real and complex roots. Returns failed when unsuccessful.


kind: o
name: complexRoots
exposed: x
type: (Fraction(Polynomial(Complex(Integer))),Par)->List(Complex(Par))
params: pFloatingComplexPackage(Par)
comment:
\spad{complexRoots(rf,{} eps)} finds all the complex solutions of a univariate rational function with rational number coefficients. The solutions are computed to precision eps.


kind: o
name: complexRoots
exposed: x
type: (List(Fraction(Polynomial(Complex(Integer)))),List(Symbol),Par)->List(List(Complex(Par)))
params: pFloatingComplexPackage(Par)
comment:
\spad{complexRoots(lrf,{} lv,{} eps)} finds all the complex solutions of a list of rational functions with rational number coefficients with respect the variables appearing in \spad{lv}. Each solution is computed to precision eps and returned as list corresponding to the order of variables in \spad{lv}.


kind: o
name: complexSolve
exposed: x
type: (Equation(Fraction(Polynomial(Complex(Integer)))),Par)->List(Equation(Polynomial(Complex(Par))))
params: pFloatingComplexPackage(Par)
comment:
\spad{complexSolve(eq,{} eps)} finds all the complex solutions of the equation \spad{eq} of rational functions with rational rational coefficients with respect to all the variables appearing in \spad{eq},{} with precision eps.


kind: o
name: complexSolve
exposed: x
type: (Fraction(Polynomial(Complex(Integer))),Par)->List(Equation(Polynomial(Complex(Par))))
params: pFloatingComplexPackage(Par)
comment:
\spad{complexSolve(p,{} eps)} find all the complex solutions of the rational function \spad{p} with complex rational coefficients with respect to all the variables appearing in \spad{p},{} with precision eps.


kind: o
name: complexSolve
exposed: x
params: pFloatingComplexPackage(Par)
type:
(List(Equation(Fraction(Polynomial(Complex(Integer))))),Par)->List(List(Equation(Polynomial(Complex(Par)))))

comment:
\spad{complexSolve(leq,{} eps)} finds all the complex solutions to precision eps of the system \spad{leq} of equations of rational functions over complex rationals with respect to all the variables appearing in \spad{lp}.


kind: o
name: complexSolve
exposed: x
type: (List(Fraction(Polynomial(Complex(Integer)))),Par)->List(List(Equation(Polynomial(Complex(Par)))))
params: pFloatingComplexPackage(Par)
comment:
\spad{complexSolve(lp,{} eps)} finds all the complex solutions to precision eps of the system \spad{lp} of rational functions over the complex rationals with respect to all the variables appearing in \spad{lp}.


kind: o
name: complexZeros
exposed: n
type: (UP)->List(Complex(R))
params: pComplexRootFindingPackage(R,UP)
comment:
\spad{complexZeros(p)} tries to determine all complex zeros of the polynomial \spad{p} with accuracy given by the package constant {\em globalEps} which you may change by {\em setErrorBound}.


kind: o
name: complexZeros
exposed: n
type: (UP,R)->List(Complex(R))
params: pComplexRootFindingPackage(R,UP)
comment:
\spad{complexZeros(p,{} eps)} tries to determine all complex zeros of the polynomial \spad{p} with accuracy given by {\em eps}.


kind: o
name: complexZeros
exposed: x
type: (UP,Par)->List(Complex(Par))
params: pComplexRootPackage(UP,Par)
comment:
\spad{complexZeros(poly,{} eps)} finds the complex zeros of the univariate polynomial \spad{poly} to precision eps with solutions returned as complex floats or rationals depending on the type of eps.


kind: o
name: component
exposed: n
type: (%,Point(DoubleFloat))->Void
params: dGraphImage
comment:
\spad{component(\spad{gi},{} pt)} modifies the graph \spad{\spad{gi}} of the domain \spadtype{GraphImage} to contain one point component,{} \spad{pt} whose point color,{} line color and point size are determined by the default functions \spadfun{pointColorDefault},{} \spadfun{lineColorDefault},{} and \spadfun{pointSizeDefault}.


kind: o
name: component
exposed: n
type: (%,List(Point(DoubleFloat)),Palette,Palette,PositiveInteger)->Void
params: dGraphImage
comment:
\spad{component(\spad{gi},{} lp,{} pal1,{} pal2,{} p)} sets the components of the graph,{} \spad{\spad{gi}} of the domain \spadtype{GraphImage},{} to the values given. The point list for \spad{\spad{gi}} is set to the list \spad{lp},{} the color of the points in \spad{lp} is set to the palette color \spad{pal1},{} the color of the lines which connect the points \spad{lp} is set to the palette color \spad{pal2},{} and the size of the points in \spad{lp} is given by the integer \spad{p}.


kind: o
name: component
exposed: n
type: (%,Point(DoubleFloat),Palette,Palette,PositiveInteger)->Void
params: dGraphImage
comment:
\spad{component(\spad{gi},{} pt,{} pal1,{} pal2,{} ps)} modifies the graph \spad{\spad{gi}} of the domain \spadtype{GraphImage} to contain one point component,{} \spad{pt} whose point color is set to the palette color \spad{pal1},{} line color is set to the palette color \spad{pal2},{} and point size is set to the positive integer \spad{ps}.


kind: o
name: components
exposed: x
type: (%)->List(%)
params: cThreeSpaceCategory(R)
comment:
\spad{components(s)} takes the \spadtype{ThreeSpace} \spad{s},{} and creates a list containing a unique \spadtype{ThreeSpace} for each single component of \spad{s}. If \spad{s} has no components defined,{} the list returned is empty.


kind: o
name: composite
exposed: x
type: (List(%))->%
params: cThreeSpaceCategory(R)
comment:
\spad{composite([s1,{} s2,{} ...,{} sn])} will create a new \spadtype{ThreeSpace} that is a union of all the components from each \spadtype{ThreeSpace} in the parameter list,{} grouped as a composite.


kind: o
name: composite
exposed: x
type: (Fraction(%),%)->Union(Fraction(%),failed)
params: cUnivariatePolynomialCategory(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{composite(f,{} q)} returns \spad{h} if \spad{f} = \spad{h}(\spad{q}),{} and failed is no such \spad{h} exists.


kind: o
name: composites
exposed: x
type: (%)->List(%)
params: cThreeSpaceCategory(R)
comment:
\spad{composites(s)} takes the \spadtype{ThreeSpace} \spad{s},{} and creates a list containing a unique \spadtype{ThreeSpace} for each single composite of \spad{s}. If \spad{s} has no composites defined (composites need to be explicitly created),{} the list returned is empty. Note that not all the components need to be part of a composite.


kind: o
name: computeBasis
exposed: n
params: pLinGroebnerPackage(lv,F)
type:
(List(HomogeneousDistributedMultivariatePolynomial(lv,F)))->List(HomogeneousDistributedMultivariatePolynomial(lv,F))

comment:
\spad{computeBasis(l)} is a helper function which computes a basis of a linear space which contains a lexicographic Groebner basis. It expects a basis (ordered by total degree,{} reverse lexicographic) of a zero dimensional ideal.


kind: o
name: computeCycleEntry
exposed: n
type: (ST,ST)->ST
params: pCyclicStreamTools(S,ST)
comment:
\spad{computeCycleEntry(x,{} cycElt)},{} where cycElt is a pointer to a node in the cyclic part of the cyclic stream \spad{x},{} returns a pointer to the first node in the cycle


kind: o
name: computeCycleLength
exposed: n
type: (ST)->NonNegativeInteger
params: pCyclicStreamTools(S,ST)
comment:
\spad{computeCycleLength(s)} returns the length of the cycle of a cyclic stream \spad{t},{} where \spad{s} is a pointer to a node in the cyclic part of \spad{t}.


kind: o
name: computeInt
exposed: n
type: (Kernel(F),F,OrderedCompletion(F),OrderedCompletion(F),Boolean)->Union(OrderedCompletion(F),failed)
params: pDefiniteIntegrationTools(R,F)
comment:
\spad{computeInt(x,{} g,{} a,{} b,{} eval?)} returns the integral of \spad{f} for \spad{x} between a and \spad{b},{} assuming that \spad{g} is an indefinite integral of \spad{f} and \spad{f} has no pole between a and \spad{b}. If \spad{eval?} is \spad{true},{} then \spad{g} can be evaluated safely at \spad{a} and \spad{b},{} provided that they are finite values. Otherwise,{} limits must be computed.


kind: o
name: concat
exposed: x
type: (List(%))->%
params: cLinearAggregate(S)
comment:
\spad{concat(u)},{} where \spad{u} is a list of aggregates \spad{[a,{} b,{} ...,{} c]},{} returns a single aggregate consisting of the elements of \spad{a} followed by those of \spad{b} followed ... by the elements of \spad{c}. Note: \spad{concat([a,{} b,{} ...,{} c]) = concat(a,{} concat([b,{} ...,{} c]))}.


kind: o
name: concat!
exposed: x
type: (List(%))->%
params: cUnaryRecursiveAggregate(S)
abbrev: has(%,shallowlyMutable)
comment:
\spad{concat!(lu)},{} where \spad{lu} is a list of aggregates \spad{[a,{} b,{} ...,{} c]},{} returns a single aggregate consisting of the elements of \spad{a} followed by those of \spad{b} followed ... by the elements of \spad{c}. This function may destructively modify the aggregates in \spad{lu}.


kind: o
name: concat
exposed: x
type: (Stream(Stream(S)))->Stream(S)
params: pStreamFunctions1(S)
comment:
\spad{concat(u)} returns the left-to-right concatenation of the streams in \spad{u}. Note: \spad{concat(u) = reduce(concat,{} u)}.


kind: o
name: concat!
exposed: x
type: (%,%)->%
params: cDoublyLinkedAggregate(S)
abbrev: has(%,shallowlyMutable)
comment:
\spad{concat!(u,{} v)} destructively concatenates doubly-linked aggregate \spad{v} to the end of doubly-linked aggregate \spad{u}.


kind: o
name: concat
exposed: x
type: (%,%)->%
params: cLinearAggregate(S)
comment:
\spad{concat(u,{} v)} returns an aggregate consisting of the elements of \spad{u} followed by the elements of \spad{v}. Note: if \spad{w = concat(u,{} v)} then \spad{w.i = u.i for i in indices u} and \spad{w.(j + maxIndex u) = v.j for j in indices v}.


kind: o
name: concat
exposed: x
type: (%,%)->%
params: cUnaryRecursiveAggregate(S)
comment:
\spad{concat(u,{} v)} returns an aggregate \spad{w} consisting of the elements of \spad{u} followed by the elements of \spad{v}. Note: \spad{v = rest(w,{} \#u)}.


kind: o
name: concat
exposed: x
type: (%,S)->%
params: cLinearAggregate(S)
comment:
\spad{concat(u,{} x)} returns aggregate \spad{u} with additional element \spad{x} at the end. Note: for lists,{} \spad{concat(u,{} x) = concat(u,{} [x])}.


kind: o
name: concat
exposed: x
type: (S,%)->%
params: cLinearAggregate(S)
comment:
\spad{concat(x,{} u)} returns aggregate \spad{u} with additional element \spad{x} at the front. Note: for lists: \spad{concat(x,{} u) = concat([x],{} u)}.


kind: o
name: concat!
exposed: x
type: (%,S)->%
params: cUnaryRecursiveAggregate(S)
abbrev: has(%,shallowlyMutable)
comment:
\spad{concat!(u,{} x)} destructively adds element \spad{x} to the end of \spad{u}. Note: \spad{concat!(a,{} x) = concat!(a,{} [x])}.


kind: o
name: concat
exposed: x
type: (S,%)->%
params: cUnaryRecursiveAggregate(S)
comment:
\spad{concat(x,{} u)} returns aggregate consisting of \spad{x} followed by the elements of \spad{u}. Note: if \spad{v = concat(x,{} u)} then \spad{x = first v} and \spad{u = rest v}.


kind: o
name: cond
exposed: n
type: (Switch,%,%)->%
params: dFortranCode
comment:
\spad{cond(s,{} e,{} f)} creates a representation of the FORTRAN expression IF (\spad{s}) THEN \spad{e} ELSE \spad{f}.


kind: o
name: conditionP
exposed: x
type: (Matrix(%))->Union(Vector(%),failed)
params: cPolynomialFactorizationExplicit
abbrev: has(%,CharacteristicNonZero)
comment:
\spad{conditionP(m)} returns a vector of elements,{} not all zero,{} whose \spad{p}\spad{-}th powers (\spad{p} is the characteristic of the domain) are a solution of the homogeneous linear system represented by \spad{m},{} or failed is there is no such vector.


kind: o
name: conditionsForIdempotents
exposed: n
type: ()->List(Polynomial(R))
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
abbrev: has(R,IntegralDomain)
comment:
\spad{conditionsForIdempotents()} determines a complete list of polynomial equations for the coefficients of idempotents with respect to the fixed \spad{R}-module basis


kind: o
name: conditionsForIdempotents
exposed: n
type: ()->List(Polynomial(R))
params: xFramedNonAssociativeAlgebra&(S,R)
comment:
\spad{conditionsForIdempotents()} determines a complete list of polynomial equations for the coefficients of idempotents with respect to the fixed \spad{R}-module basis.


kind: o
name: conditionsForIdempotents
exposed: n
type: (Vector(%))->List(Polynomial(R))
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
abbrev: has(R,IntegralDomain)
comment:
\spad{conditionsForIdempotents([v1,{} ...,{} vn])} determines a complete list of polynomial equations for the coefficients of idempotents with respect to the \spad{R}-module basis \spad{v1},{} ...,{} \spad{vn}


kind: o
name: conditionsForIdempotents
exposed: x
type: (Vector(%))->List(Polynomial(R))
params: cFiniteRankNonAssociativeAlgebra(R)
comment:
\spad{conditionsForIdempotents([v1,{} ...,{} vn])} determines a complete list of polynomial equations for the coefficients of idempotents with respect to the \spad{R}-module basis \spad{v1},{} ...,{} \spad{vn}.


kind: o
name: cone
exposed: n
type: (%,NonNegativeInteger)->%
params: dFiniteSimplicialComplex(VS)
comment:
The 'cone' of a simplicial complex is formed by adding the vertex to every facet. 'vertex' should not already be included in existing faces,{} this is not checked and so will lead to simplexes with duplicate vertices.


kind: o
name: conical
exposed: x
type: (R,R)->(Point(R))->Point(R)
params: pCoordinateSystems(R)
comment:
\spad{conical(a,{} b)} transforms from conical coordinates to Cartesian coordinates: \spad{conical(a,{} b)} is a function which will map the point \spad{(lambda,{} mu,{} nu)} to \spad{x = lambda*mu*nu/(a*b)},{} \spad{y = lambda/a*sqrt((mu^2-a^2)*(nu^2-a^2)/(a^2-b^2))},{} \spad{z = lambda/b*sqrt((mu^2-b^2)*(nu^2-b^2)/(b^2-a^2))}.


kind: o
name: conj
exposed: x
type: (%)->%
params: dCliffordAlgebra(n,K,bLin)
comment:
implements Clifford conjugate for a multivector by involution and reverse of each term separately using: grade: 0 1 2 3... multi: 1 \spad{-1} \spad{-1} 1...


kind: o
name: conjugate
exposed: x
type: (%)->%
params: cOctonionCategory(R)
comment:
\spad{conjugate(o)} negates the imaginary parts \spad{i},{} \spad{j},{} \spad{k},{} \spad{E},{} \spad{I},{} \spad{J},{} \spad{K} of octonian \spad{o}.


kind: o
name: conjugates
exposed: x
type: (Stream(List(Integer)))->Stream(List(Integer))
params: pPartitionsAndPermutations
comment:
\spad{conjugates(lp)} is the stream of conjugates of a stream \indented{1}{of partitions \spad{lp}.}


kind: o
name: connect
exposed: n
type: (%,PositiveInteger,String)->Void
params: dTwoDimensionalViewport
comment:
\spad{connect(v,{} n,{} s)} displays the lines connecting the graph points 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 lines if \spad{s} is off.


kind: o
name: cons
exposed: x
type: (S,%)->%
params: dList(S)
comment:
\spad{cons(element,{} u)} appends \spad{element} onto the front of list \spad{u} and returns the new list. This new list and the old one will share some structure.


kind: o
name: cons
exposed: x
type: (S,%)->%
params: dStream(S)
comment:
\spad{cons(a,{} s)} returns a stream whose \spad{first} is \spad{a} and whose \spad{rest} is \spad{s}. Note: \spad{cons(a,{} s) = concat(a,{} s)}.


kind: o
name: consnewpol
exposed: n
params: pMultivariateSquareFree(E,OV,R,P)
comment: \spad{consnewpol should} be local
type:
(SparseUnivariatePolynomial(P),SparseUnivariatePolynomial(R),Integer)->Record(pol:SparseUnivariatePolynomial(P),polval:SparseUnivariatePolynomial(R))


kind: o
name: const
exposed: n
type: (%)->R
params: dDistributedJetBundlePolynomial(R,JB,LJV,E)
comment:
\spad{const(p)} coerces a polynomial into an element of the coefficient ring,{} if it is constant. Otherwise an error occurs.


kind: o
name: constant
exposed: x
type: (F)->F
params: pFunctionSpaceAssertions(R,F)
comment:
\spad{constant(x)} tells the pattern matcher that \spad{x} should match only the symbol \spad{'x} and no other quantity. Error: if \spad{x} is not a symbol.


kind: o
name: constant
exposed: x
type: (Symbol)->Expression(Integer)
params: pPatternMatchAssertions
comment:
\spad{constant(x)} tells the pattern matcher that \spad{x} should match only the symbol \spad{'x} and no other quantity.


kind: o
name: constantCoefficientRicDE
exposed: n
type: (L,(UP)->List(F))->List(Record(constant:F,eq:L))
params: pPrimitiveRatRicDE(F,UP,L,LQ)
comment:
\spad{constantCoefficientRicDE(op,{} ric)} returns \spad{[[a1,{} L1],{} [a2,{} L2],{} ... ,{} [ak,{} Lk]]} such that any rational solution with no polynomial part of the associated Riccati equation of \spad{op y = 0} must be one of the \spad{ai}\spad{'s} in which case the equation for \spad{z = y e^{-int \spad{ai}}} is \spad{\spad{Li} z = 0}. \spad{ric} is a Riccati equation solver over \spad{F},{} whose input is the associated linear equation.


kind: o
name: constantOperator
exposed: x
type: (A)->BasicOperator
params: pBasicOperatorFunctions1(A)
comment:
\spad{constantOperator(a)} returns a nullary operator op such that \spad{op()} always evaluate to \spad{a}.


kind: o
name: constantOpIfCan
exposed: x
type: (BasicOperator)->Union(A,failed)
params: pBasicOperatorFunctions1(A)
comment:
\spad{constantOpIfCan(op)} returns \spad{a} if \spad{op} is the constant nullary operator always returning \spad{a},{} failed otherwise.


kind: o
name: constant_subspace
exposed: n
type: (List(Vector(F)),List((F)->F))->Record(transform:Matrix(F),basis:List(Vector(F)))
params: pConstantLinearDependence(R,F)
comment:
\spad{constant_subspace(b,{} ld)} returns [\spad{M},{} \spad{nb}] such that \spad{nb} is basis of subspace spanned by \spad{b} over \spad{F} consistng of vectors with constant coordinates. \spad{M} is the transformation matrix,{} \spadignore{i.e.} \spad{mnb} = \spad{M} \spad{mb} where \spad{mb} (\spad{mnb} respectively) is matrix having \spad{b} (\spad{nb} respectively) as rows.


kind: o
name: constantToUnaryFunction
exposed: n
type: (DoubleFloat)->(DoubleFloat)->DoubleFloat
params: pExpressionTubePlot
comment:
\spad{constantToUnaryFunction(s)} is a local function which takes the value of \spad{s},{} which may be a function of a constant,{} and returns a function which always returns the value \spadtype{DoubleFloat} \spad{s}.


kind: o
name: constDsolve
exposed: n
type: (L,F,Symbol)->Record(particular:F,basis:List(F))
params: pConstantLODE(R,F,L)
comment:
\spad{constDsolve(op,{} g,{} x)} returns \spad{[f,{} [y1,{} ...,{} ym]]} where \spad{f} is a particular solution of the equation \spad{op y = g},{} and the \spad{\spad{yi}}\spad{'s} form a basis for the solutions of \spad{op y = 0}.


kind: o
name: construct
exposed: n
type: (List(Record(key:Symbol,entry:S)))->%
params: dPatternMatchResult(R,S)
comment:
\spad{construct([v1,{} e1],{} ...,{} [vn,{} en])} returns the match result containing the matches (\spad{v1},{} \spad{e1}),{} ...,{} (\spad{vn},{} en).


kind: o
name: construct
exposed: n
type: (List(Record(k:S,c:A)))->%
params: cIndexedProductCategory(A,S)
comment:
\spad{construct(l)} takes a list of terms and creates the object with these components. First components of elements of \spad{l} should be different.


kind: o
name: construct
exposed: n
type: (SplittingNode(V,C))->%
params: dSplittingTree(V,C)
comment:
\spad{construct(s)} creates a splitting tree with value (\spadignore{i.e.} root vertex) given by \spad{s} and no children. Thus,{} if the status of \spad{s} is \spad{false},{} \spad{[s]} represents the starting point of the evaluation \spad{value(s)} under the hypothesis \spad{condition(s)}.


kind: o
name: construct
exposed: x
type: (List(S))->%
params: cCollection(S)
comment:
\spad{construct([x,{} y,{} ...,{} z])} returns the collection of elements \spad{x,{} y,{} ...,{} z} ordered as given. Equivalently written as \spad{[x,{} y,{} ...,{} z]\$D},{} where \spad{D} is the domain. \spad{D} may be omitted for those of type List.


kind: o
name: construct
exposed: n
type: (V,C,Boolean)->%
params: dSplittingNode(V,C)
comment:
\spad{construct(v,{} t,{} b)} returns the non-empty node with value \spad{v},{} condition \spad{t} and flag \spad{b}


kind: o
name: construct
exposed: n
type: (V,C,List(%))->%
params: dSplittingTree(V,C)
comment:
\spad{construct(v,{} t,{} la)} creates a splitting tree with value (\spadignore{i.e.} root vertex) given by \spad{[v,{} t]\$S} and with \spad{la} as children list.


kind: o
name: construct
exposed: n
type: (V,C,List(SplittingNode(V,C)))->%
params: dSplittingTree(V,C)
comment:
\spad{construct(v,{} t,{} ls)} creates a splitting tree with value (\spadignore{i.e.} root vertex) given by \spad{[v,{} t]\$S} and with children list given by \spad{[[s]\$\% for s in ls]}.


kind: o
name: construct
exposed: n
type: (V,C,V,List(C))->%
params: dSplittingTree(V,C)
comment:
\spad{construct(v1,{} t,{} v2,{} lt)} creates a splitting tree with value (\spadignore{i.e.} root vertex) given by \spad{[v,{} t]\$S} and with children list given by \spad{[[[v,{} t]\$S]\$\% for s in ls]}.


kind: o
name: construct
exposed: x
type: (Sequence(R),Sequence(R),Sequence(R),Sequence(R))->%
params: dDistribution(R)
comment:
\spad{construct(mom,{} ccum,{} fcum,{} bcum)} constructs a distribution with moments \spad{mom},{} classical cumulants \spad{ccum},{} free cumulants \spad{fcum} and boolean cumulants \spad{bcum}. The user must make sure that these are consistent,{} otherwise the results are unpredictable!


kind: o
name: constructOrdered
exposed: n
type: (List(Record(k:S,c:A)))->%
params: cIndexedProductCategory(A,S)
abbrev: has(S,Comparable)
comment:
\spad{constructOrdered(l)} takes a list of terms and creates the object with these components. The list is assumed to be sorted (in reverse order) with respect to the ordering of \spad{S}. If \spad{R} is a monoid,{} then the list is assumed to contain no zero elements. Caution: No checking is performed,{} so this should only be used in cases where those conditions are assured. If in doubt use \spad{construct}.


kind: o
name: contains?
exposed: x
type: (%,R)->Boolean
params: cIntervalCategory(R)
comment:
\spad{contains?(i,{} f)} returns \spad{true} if \spad{f} is contained within the interval \spad{i},{} \spad{false} otherwise.


kind: o
name: containsPoint?
exposed: n
type: (%,PT)->Boolean
params: dSBoundary(PT)
comment:
\spad{containsPoint?(n,{} p)} returns \spad{true} if the point is inside \indented{2}{the boundary.} \spad{n} is the boundary \spad{p} is the point


kind: o
name: content
exposed: x
type: (%,VarSet)->%
params: cPolynomialCategory(R,E,VarSet)
abbrev: has(R,GcdDomain)
comment:
\spad{content(p,{} v)} is the \spad{gcd} of the coefficients of the polynomial \spad{p} when \spad{p} is viewed as a univariate polynomial with respect to the variable \spad{v}. Thus,{} for polynomial 7*x^2*y + 14*x*y^2,{} the \spad{gcd} of the coefficients with respect to \spad{x} is 7*y.


kind: o
name: continuedFraction
exposed: n
type: (%)->ContinuedFraction(Fraction(Integer))
params: dPAdicRationalConstructor(p,PADIC)
comment:
\spad{continuedFraction(x)} converts the \spad{p}-adic rational number \spad{x} to a continued fraction.


kind: o
name: continuedFraction
exposed: x
type: (F)->ContinuedFraction(Integer)
params: pNumericContinuedFraction(F)
comment:
\spad{continuedFraction(f)} converts the floating point number \spad{f} to a reduced continued fraction.


kind: o
name: continuedFraction
exposed: x
type: (Fraction(R))->%
params: dContinuedFraction(R)
comment:
\spad{continuedFraction(r)} converts the fraction \spadvar{\spad{r}} with components of type \spad{R} to a continued fraction over \spad{R}.


kind: o
name: continuedFraction
exposed: x
type: (R,Stream(R),Stream(R))->%
params: dContinuedFraction(R)
comment:
\spad{continuedFraction(b0,{} a,{} b)} constructs a continued fraction in the following way: if \spad{a = [a1,{} a2,{} ...]} and \spad{b = [b1,{} b2,{} ...]} then the result is the continued fraction \spad{b0 + a1/(b1 + a2/(b2 + ...))}.


kind: o
name: contract
exposed: x
params: pIdealDecompositionPackage(vl)
comment: \spad{contract(I,{} lvar)} contracts the ideal \spad{I} to the polynomial ring \spad{F[lvar]}.
type:
(PolynomialIdeal(Fraction(Integer),DirectProduct(#(vl),NonNegativeInteger),OrderedVariableList(vl),DistributedMultivariatePolynomial(vl,Fraction(Integer))),List(OrderedVariableList(vl)))->PolynomialIdeal(Fraction(Integer),DirectProduct(#(vl),NonNegativeInteger),OrderedVariableList(vl),DistributedMultivariatePolynomial(vl,Fraction(Integer)))


kind: o
name: contract
exposed: x
type: (%,Integer,Integer)->%
params: dCartesianTensor(minix,dim,R)
comment:
\spad{contract(t,{} i,{} j)} is the contraction of tensor \spad{t} which sums along the \spad{i}\spad{-}th and \spad{j}\spad{-}th indices. For example,{} if \spad{r = contract(t,{} 1,{} 3)} for a rank 4 tensor \spad{t},{} then \spad{r} is the rank 2 \spad{(= 4 - 2)} tensor given by \indented{4}{\spad{r(i,{} j) = sum(h=1..dim,{} t(h,{} i,{} h,{} j))}.}


kind: o
name: contract
exposed: x
type: (%,Integer,%,Integer)->%
params: dCartesianTensor(minix,dim,R)
comment:
\spad{contract(t,{} i,{} s,{} j)} is the inner product of tenors \spad{s} and \spad{t} which sums along the \spad{k1}\spad{-}th index of \spad{t} and the \spad{k2}\spad{-}th index of \spad{s}. For example,{} if \spad{r = contract(s,{} 2,{} t,{} 1)} for rank 3 tensors rank 3 tensors \spad{s} and \spad{t},{} then \spad{r} is the rank 4 \spad{(= 3 + 3 - 2)} tensor given by \indented{4}{\spad{r(i,{} j,{} k,{} l) = sum(h=1..dim,{} s(i,{} h,{} j)*t(h,{} k,{} l))}.}


kind: o
name: contractSolve
exposed: x
params: pRadicalSolvePackage(R)
type:
(Equation(Fraction(Polynomial(R))),Symbol)->SuchThat(List(Expression(R)),List(Equation(Expression(R))))

comment:
\spad{contractSolve(eq,{} x)} finds the solutions expressed in terms of radicals of the equation of rational functions \spad{eq} with respect to the symbol \spad{x}. The result contains new symbols for common subexpressions in order to reduce the size of the output.


kind: o
name: contractSolve
exposed: x
type: (Fraction(Polynomial(R)),Symbol)->SuchThat(List(Expression(R)),List(Equation(Expression(R))))
params: pRadicalSolvePackage(R)
comment:
\spad{contractSolve(rf,{} x)} finds the solutions expressed in terms of radicals of the equation \spad{rf} = 0 with respect to the symbol \spad{x},{} where \spad{rf} is a rational function. The result contains new symbols for common subexpressions in order to reduce the size of the output.


kind: o
name: controlPanel
exposed: n
type: (%,String)->Void
params: dTwoDimensionalViewport
comment:
\spad{controlPanel(v,{} s)} displays the control panel of the given two-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{TwoDimensionalViewport},{} if \spad{s} is on,{} or hides the control panel if \spad{s} is off.


kind: o
name: controlPanel
exposed: x
type: (%,String)->Void
params: dThreeDimensionalViewport
comment:
\spad{controlPanel(v,{} s)} displays the control panel of the given three-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{ThreeDimensionalViewport},{} if \spad{s} is on,{} or hides the control panel if \spad{s} is off.


kind: o
name: convergents
exposed: x
type: (%)->Stream(Fraction(R))
params: dContinuedFraction(R)
comment:
\spad{convergents(x)} returns the stream of the convergents of the continued fraction \spadvar{\spad{x}}. If the continued fraction is finite,{} then the stream will be finite.


kind: o
name: convert
exposed: n
type: (%)->JetBundlePolynomial(R,JB)
params: dDistributedJetBundlePolynomial(R,JB,LJV,E)
comment:
\spad{convert(p)} converts a polynomial \spad{p} in distributive representation into a polynomial in recursive representation.


kind: o
name: convert
exposed: n
type: (JetBundlePolynomial(R,JB))->%
params: dDistributedJetBundlePolynomial(R,JB,LJV,E)
comment:
\spad{convert(p)} converts a polynomial \spad{p} in recursive representation into a polynomial in distributive representation.


kind: o
name: convert
exposed: n
type: (LinearOrdinaryDifferentialOperator1(R))->LinearOrdinaryDifferentialOperator3(Coeff,Ab,R)
params: pLODOConvertions(Coeff,Ab,R)
comment:
\spad{convert(l1)} converts an operator \spad{l1} from \spadtype{LinearOrdinaryDifferentialOperator1} to \spadtype{LinearOrdinaryDifferentialOperator3} such that the resultant operator gives the same result as the original one on application to an element of domain \spad{R}.


kind: o
name: convert
exposed: n
type: (LinearOrdinaryDifferentialOperator3(Coeff,Ab,R))->LinearOrdinaryDifferentialOperator1(R)
params: pLODOConvertions(Coeff,Ab,R)
comment:
\spad{convert(l3)} converts an operator \spad{l3} from \spadtype{LinearOrdinaryDifferentialOperator3} to \spadtype{LinearOrdinaryDifferentialOperator1} such that the resultant operator gives the same result as the original one on application to an element of domain \spad{R}.


kind: o
name: convert
exposed: n
type: (Vector(R))->%
params: cFramedModule(R)
comment:
\spad{convert([a1,{} ..,{} an])} returns \spad{a1*v1 + ... + an*vn},{} where \spad{v1},{} ...,{} \spad{vn} are the elements of the fixed basis.


kind: o
name: convert
exposed: n
type: (%)->Vector(R)
params: cFramedModule(R)
comment:
\spad{convert(a)} returns the coordinates of \spad{a} with respect to the fixed \spad{R}-module basis.


kind: o
name: convert
exposed: x
type: (Factored(%))->%
params: cFunctionSpace2(R,K)
abbrev: has(R,IntegralDomain)
comment:
\spad{convert(f1\^e1 ... fm\^em)} returns \spad{(f1)\^e1 ... (fm)\^em} as an element of \%,{} using formal kernels created using a \spadfunFrom{paren}{ExpressionSpace}.


kind: o
name: convert
exposed: x
type: (List(R))->%
params: cPointCategory(R)
comment:
\spad{convert(l)} takes a list of elements,{} \spad{l},{} from the domain Ring and returns the form of point category.


kind: o
name: convert
exposed: x
params: pZeroDimensionalSolvePackage(R,ls,ls2)
comment: \spad{convert(q)} converts \spad{q}.
type:
(NewSparseMultivariatePolynomial(R,OrderedVariableList(ls)))->NewSparseMultivariatePolynomial(R,OrderedVariableList(ls2))


kind: o
name: convert
exposed: x
params: pZeroDimensionalSolvePackage(R,ls,ls2)
comment: \spad{convert(st)} returns the members of \spad{st}.
type:
(SquareFreeRegularTriangularSet(R,IndexedExponents(OrderedVariableList(ls2)),OrderedVariableList(ls2),NewSparseMultivariatePolynomial(R,OrderedVariableList(ls2))))->List(NewSparseMultivariatePolynomial(R,OrderedVariableList(ls2)))


kind: o
name: convert
exposed: x
type: (UP)->%
params: cMonogenicAlgebra(R,UP)
comment:
\spad{convert(up)} converts the univariate polynomial \spad{up} to an algebra element,{} reducing by the \spad{definingPolynomial()} if necessary.


kind: o
name: convert
exposed: n
type: (List(S),List(FreeGroup(S)))->GroupPresentation
params: pGroupPresentationFunctions1(S)
comment:
\spad{convert(lg,{} lr)} builds group presentation from list of generators \spad{lg} and list of relations \spad{lr}.


kind: o
name: convert
exposed: n
type: (OutputForm,Integer)->%
params: cOutputFormatterCategory
comment:
\spad{convert(o,{} step)} changes \spad{o} in standard output format to given format and also adds the given step number.


kind: o
name: convert
exposed: n
type: (OutputForm,Integer)->%
params: dTexFormat
comment:
\spad{convert(o,{} step)} changes \spad{o} in standard output format to TeX format and also adds the given step number. This is useful if you want to create equations with given numbers or have the equation numbers correspond to the interpreter step numbers.


kind: o
name: convert
exposed: n
type: (OutputForm,Integer,OutputForm)->%
params: dTexFormat
comment:
\spad{convert(o,{} step,{} type)} changes \spad{o} in standard output format to TeX format and also adds the given \spad{step} number and type. This is useful if you want to create equations with given numbers or have the equation numbers correspond to the interpreter \spad{step} numbers.


kind: o
name: convert_mr
exposed: n
params: pFloatingPointConvertion
type:
(Record(mantissa:Integer,exponent:Integer),Integer,Record(default?:Boolean,trim_trailing_zeros?:Boolean,out_mode:String,spacing:Integer,separator:Character))->String


kind: o
name: coord
exposed: x
type: ((Point(DoubleFloat))->Point(DoubleFloat))->%
params: dDrawOption
comment:
\spad{coord(p)} specifies a change of coordinates of point \spad{p}. This option is expressed in the form \spad{coord == p}.


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


kind: o
name: coord
exposed: n
params: pDrawOptionFunctions0
type:
(List(DrawOption),(Point(DoubleFloat))->Point(DoubleFloat))->(Point(DoubleFloat))->Point(DoubleFloat)

comment:
\spad{coord(l,{} p)} takes the list of draw options,{} \spad{l},{} and checks the list to see if it contains the option \spad{coord}. If the option does not exist the value,{} \spad{p} is returned.


kind: o
name: coordinate
exposed: x
type: (%,NonNegativeInteger)->ComponentFunction
params: dParametricPlaneCurve(ComponentFunction)
comment:
\spad{coordinate(c,{} i)} returns a coordinate function for \spad{c} using 1-based indexing according to \spad{i}. This indicates what the function for the coordinate component \spad{i} of the plane curve is.


kind: o
name: coordinate
exposed: x
type: (%,NonNegativeInteger)->ComponentFunction
params: dParametricSpaceCurve(ComponentFunction)
comment:
\spad{coordinate(c,{} i)} returns a coordinate function of \spad{c} using 1-based indexing according to \spad{i}. This indicates what the function for the coordinate component,{} \spad{i},{} of the space curve is.


kind: o
name: coordinate
exposed: x
type: (%,NonNegativeInteger)->ComponentFunction
params: dParametricSurface(ComponentFunction)
comment:
\spad{coordinate(s,{} i)} returns a coordinate function of \spad{s} using 1-based indexing according to \spad{i}. This indicates what the function for the coordinate component,{} \spad{i},{} of the surface is.


kind: o
name: coordinates
exposed: n
type: (Vector(%))->Matrix(R)
params: cFramedModule(R)
comment:
\spad{coordinates([v1,{} ...,{} vm])} returns the coordinates of the \spad{vi}\spad{'s} with to the fixed basis. The coordinates of \spad{vi} are contained in the \spad{i}th row of the matrix returned by this function.


kind: o
name: coordinates
exposed: n
type: (%)->Vector(R)
params: cFramedModule(R)
comment:
\spad{coordinates(a)} returns the coordinates of \spad{a} with respect to the fixed \spad{R}-module basis.


kind: o
name: coordinates
exposed: x
type: ((Point(DoubleFloat))->Point(DoubleFloat))->%
params: dDrawOption
comment:
\spad{coordinates(p)} specifies a change of coordinate systems of point \spad{p}. This option is expressed in the form \spad{coordinates == p}.


kind: o
name: coordinates
exposed: n
type: (Vector(R),%)->Vector(R)
params: dVectorSpaceBasis(R)
comment:
\spad{coordinates(v,{} B)} computes the coordinates of the vector \spad{v} in the basis \spad{B} if possible and produces an error otherwise.


kind: o
name: coordinates
exposed: x
type: (Matrix(R),List(Matrix(R)))->Vector(R)
params: pStructuralConstantsPackage(R)
comment:
\spad{coordinates(a,{} [v1,{} ...,{} vn])} returns the coordinates of \spad{a} with respect to the \spad{R}-module basis \spad{v1},{} ...,{} \spad{vn}.


kind: o
name: coordinates
exposed: x
type: (Vector(%),Vector(%))->Matrix(R)
params: cFiniteRankAlgebra(R,UP)
comment:
\spad{coordinates([v1,{} ...,{} vm],{} basis)} returns the coordinates of the \spad{vi}\spad{'s} with to the basis \spad{basis}. The coordinates of \spad{vi} are contained in the \spad{i}th row of the matrix returned by this function.


kind: o
name: coordinates
exposed: x
type: (Vector(%),Vector(%))->Matrix(R)
params: cFiniteRankNonAssociativeAlgebra(R)
comment:
\spad{coordinates([a1,{} ...,{} am],{} [v1,{} ...,{} vn])} returns a matrix whose \spad{i}-th row is formed by the coordinates of \spad{\spad{ai}} with respect to the \spad{R}-module basis \spad{v1},{} ...,{} \spad{vn}.


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


kind: o
name: coordinatesIfCan
exposed: n
type: (Vector(R),%)->Union(Vector(R),failed)
params: dVectorSpaceBasis(R)
comment:
\spad{coordinatesIfCan(v,{} B)} computes the coordinates of the vector \spad{v} in the basis \spad{B} if possible and returns \spad{failed} otherwise.


kind: o
name: copies
exposed: x
type: (Integer,String)->String
params: pDisplayPackage
comment:
\spad{copies(i,{} s)} will take a string \spad{s} and create a new string composed of \spad{i} copies of \spad{s}.


kind: o
name: copy
exposed: x
type: (%)->%
params: cAggregate
comment:
\spad{copy(u)} returns a top-level (non-recursive) copy of \spad{u}. Note: for collections,{} \spad{copy(u) = [x for x in u]}.


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


kind: o
name: copy_first
exposed: n
type: (U32Vector,U32Vector,Integer)->Void
params: pU32VectorPolynomialOperations
comment:
\spad{copy_first(v1,{} v2,{} n)} copies first \spad{n} elements of \spad{v2} into \spad{n} first positions in \spad{v1}.


kind: o
name: copyInto!
exposed: x
type: (%,%,Integer)->%
params: cLinearAggregate(S)
abbrev: AND(has(%,finiteAggregate),has(%,shallowlyMutable))
comment:
\spad{copyInto!(u,{} v,{} i)} returns aggregate \spad{u} containing a copy of \spad{v} inserted at element \spad{i}.


kind: o
name: copy_mat_part
exposed: n
type: (MMT,Integer)->MMT
params: cModularFactorizationOperations(PA,MMT,MD,PMD)
comment:
\spad{copy_mat_part(man,{} nr)} creates copy of modular composition matrix stored in first \spad{nr} rows of mat.


kind: o
name: copy_poly
exposed: n
type: (PA,Integer,MD)->PA
params: cModularFactorizationOperations(PA,MMT,MD,PMD)
comment:
\spad{copy_poly(pol,{} d,{} m)} creates copy of \spad{pol} with enough space to represent polynomials of degree smaller than \spad{d}. Error if degree of \spad{pol} is bigger or equal than \spad{d}.


kind: o
name: copy_slice
exposed: n
type: (U32Vector,U32Vector,Integer,Integer)->Void
params: pU32VectorPolynomialOperations
comment:
\spad{copy_slice(v1,{} v2,{} m,{} n)} copies the slice of \spad{v2} starting at \spad{m} elements and having \spad{n} elements into corresponding positions in \spad{v1}.


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

comment:
\spad{corrPoly(u,{} lv,{} lr,{} ln,{} lu,{} bsolv)} solves polynomial equation system u/f = sum(ai/lu(\spad{i})) where \spad{f} is product of \spad{lu}(\spad{i}) and deg(\spad{ai}) < deg(\spad{lu}(\spad{i})) using modular method. corrPoly returns failed if there are no solution. \spad{lv} is list of variables,{} \spad{lr} is list of corresponding evaluation points,{} bsolv is solver over \spad{R} specialized for modular images of \spad{lu}.


kind: o
name: cosSinInfo
exposed: n
type: (Integer)->List(List(DoubleFloat))
params: pTubePlotTools
comment:
\spad{cosSinInfo(n)} returns the list of lists of values for \spad{n},{} in the form: \spad{[[cos(n - 1) a,{} sin(n - 1) a],{} ...,{} [cos 2 a,{} sin 2 a],{} [cos a,{} sin a]]} where \spad{a = 2 pi/n}. Note: \spad{n} should be greater than 2.


kind: o
name: coth2trigh
exposed: x
type: (F)->F
params: pTranscendentalManipulations(R,F)
comment:
\spad{coth2trigh(f)} converts every \spad{coth(u)} appearing in \spad{f} into \spad{cosh(u)/sinh(u)}.


kind: o
name: count
exposed: x
type: ((S)->Boolean,%)->NonNegativeInteger
params: cHomogeneousAggregate(S)
abbrev: has(%,finiteAggregate)
comment:
\spad{count(p,{} u)} returns the number of elements \spad{x} in \spad{u} such that \spad{p(x)} is \spad{true}. For collections,{} \spad{count(p,{} u) = reduce(+,{} [1 for x in u | p(x)],{} 0)}.


kind: o
name: count
exposed: x
type: (S,%)->NonNegativeInteger
params: cHomogeneousAggregate(S)
abbrev: AND(has(%,finiteAggregate),has(S,BasicType))
comment:
\spad{count(x,{} u)} returns the number of occurrences of \spad{x} in \spad{u}. For collections,{} \spad{count(x,{} u) = reduce(+,{} [1 for y in u | x = y],{} 0)}.


kind: o
name: countable?
exposed: x
type: (%)->Boolean
params: dCardinalNumber
comment:
\spad{countable?(\spad{a})} determines whether \spad{a} is a countable cardinal,{} \spadignore{i.e.} an integer or \spad{Aleph 0}.


kind: o
name: coverMatrix
exposed: n
type: (%)->IncidenceAlgebra(Integer,S)
params: cPoset(S)
comment:
the covering matrix of a list of elements from a comparison function the list is assumed to be topologically sorted,{} \spadignore{i.e.} \spad{w}.\spad{r}. to a linear extension of the comparison function \spad{f} 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: cPower
exposed: n
type: (%,Coef)->%
params: dInnerSparseUnivariatePowerSeries(Coef)
abbrev: has(Coef,Algebra(Fraction(Integer)))
comment:
\spad{cPower(f,{} r)} computes \spad{f^r},{} where \spad{f} has constant coefficient 1. For use when the coefficient ring is commutative.


kind: o
name: cRationalPower
exposed: n
type: (%,Fraction(Integer))->%
params: dInnerSparseUnivariatePowerSeries(Coef)
abbrev: has(Coef,Algebra(Fraction(Integer)))
comment:
\spad{cRationalPower(f,{} r)} computes \spad{f^r}. For use when the coefficient ring is commutative.


kind: o
name: create3Space
exposed: x
type: ()->%
params: cThreeSpaceCategory(R)
comment:
\spad{create3Space()} creates a \spadtype{ThreeSpace} object capable of holding point,{} curve,{} mesh components and any combination.


kind: o
name: create3Space
exposed: x
type: (SubSpace(3,R))->%
params: cThreeSpaceCategory(R)
comment:
\spad{create3Space(s)} creates a \spadtype{ThreeSpace} object containing objects pre-defined within some \spadtype{SubSpace} \spad{s}.


kind: o
name: createArrows2Din2D
exposed: n
type: ((PT)->PT,Segment(DoubleFloat),Segment(DoubleFloat),NonNegativeInteger)->%
params: dScene(PT)
comment:
\spad{createArrows2Din2D(ptFun,{} uSeg,{} vSeg,{} numPts)} creates arrows to represent output for each input point in other words this represents a two dimensional force field with the arrows showing the direction of the field


kind: o
name: createGenericMatrix
exposed: x
type: (NonNegativeInteger)->Matrix(Polynomial(R))
params: pRepresentationPackage1(R)
comment:
\spad{createGenericMatrix(m)} creates a square matrix of dimension \spad{k} whose entry at the \spad{i}-th row and \spad{j}-th column is the indeterminate {\em x[i,{} j]} (double subscripted).


kind: o
name: createIrreduciblePoly
exposed: n
type: (PositiveInteger)->SparseUnivariatePolynomial(GF)
params: pFiniteFieldPolynomialPackage(GF)
comment:
\spad{createIrreduciblePoly(n)}\$FFPOLY(\spad{GF}) generates a monic irreducible univariate polynomial of degree \spad{n} over the finite field {\em GF}.


kind: o
name: createLowComplexityNormalBasis
exposed: n
params: pFiniteFieldFunctions(GF)
type:
(PositiveInteger)->Union(SparseUnivariatePolynomial(GF),Vector(List(Record(value:GF,index:SingleInteger))))

comment:
\spad{createLowComplexityNormalBasis(n)} tries to find a a low complexity normal basis of degree {\em n} over {\em GF} and returns its multiplication matrix If no low complexity basis is found it calls \spadfunFrom{createNormalPoly}{FiniteFieldPolynomialPackage}(\spad{n}) to produce a normal polynomial of degree {\em n} over {\em GF}


kind: o
name: createLowComplexityTable
exposed: n
type: (PositiveInteger)->Union(Vector(List(Record(value:GF,index:SingleInteger))),failed)
params: pFiniteFieldFunctions(GF)
comment:
\spad{createLowComplexityTable(n)} tries to find a low complexity normal basis of degree {\em n} over {\em GF} and returns its multiplication matrix Fails,{} if it does not find a low complexity basis


kind: o
name: createMultiplicationMatrix
exposed: n
type: (Vector(List(Record(value:GF,index:SingleInteger))))->Matrix(GF)
params: pFiniteFieldFunctions(GF)
comment:
\spad{createMultiplicationMatrix(m)} forms the multiplication table {\em m} into a matrix over the ground field.


kind: o
name: createMultiplicationTable
exposed: n
type: (SparseUnivariatePolynomial(GF))->Vector(List(Record(value:GF,index:SingleInteger)))
params: pFiniteFieldFunctions(GF)
comment:
\spad{createMultiplicationTable(f)} generates a multiplication table for the normal basis of the field extension determined by {\em f}. This is needed to perform multiplications between elements represented as coordinate vectors to this basis. See \spadtype{FFNBP},{} \spadtype{FFNBX}.


kind: o
name: createNormalElement
exposed: x
type: ()->%
params: cFiniteAlgebraicExtensionField(F)
abbrev: has(F,Finite)
comment:
\spad{createNormalElement()} computes a normal element over the ground field \spad{F},{} that is,{} \spad{a^(q^i),{} 0 <= i < extensionDegree()} is an \spad{F}-basis,{} where \spad{q = size()\$F}. Reference: Such an element exists Lidl/Niederreiter: Theorem 2.35.


kind: o
name: createNormalPoly
exposed: n
type: (PositiveInteger)->SparseUnivariatePolynomial(GF)
params: pFiniteFieldPolynomialPackage(GF)
comment:
\spad{createNormalPoly(n)}\$FFPOLY(\spad{GF}) generates a normal polynomial of degree \spad{n} over the finite field {\em GF}.


kind: o
name: createNormalPrimitivePoly
exposed: n
type: (PositiveInteger)->SparseUnivariatePolynomial(GF)
params: pFiniteFieldPolynomialPackage(GF)
comment:
\spad{createNormalPrimitivePoly(n)}\$FFPOLY(\spad{GF}) generates a normal and primitive polynomial of degree \spad{n} over the field {\em GF}. Note: this function is equivalent to createPrimitiveNormalPoly(\spad{n})


kind: o
name: createPlot1Din2D
exposed: n
type: ((DoubleFloat)->DoubleFloat,Segment(DoubleFloat),NonNegativeInteger)->%
params: dScene(PT)
comment:
\spad{createPlot1Din2D(f,{} tRange,{} numPts)} creates two dimensional function plot. Draws the graph of \spad{y} = \spad{f}(\spad{x}) as \spad{x} ranges from min(a,{} \spad{b}) to max(a,{} \spad{b}). \spad{tRange} is a..\spad{b}


kind: o
name: createPlot1Din2D
exposed: n
type: ((DoubleFloat)->PT,Segment(DoubleFloat),NonNegativeInteger)->%
params: dScene(PT)
comment:
\spad{createPlot1Din2D(f,{} tRange,{} numPts)} creates a two dimensional function plot draws the graph from a mapping of float to point as \spad{x} ranges from min(a,{} \spad{b}) to max(a,{} \spad{b}). \spad{tRange} is a..\spad{b}


kind: o
name: createPlot1Din2Dparametric
exposed: n
type: (ParametricPlaneCurve((DoubleFloat)->DoubleFloat),Segment(DoubleFloat),NonNegativeInteger)->%
params: dScene(PT)
comment:
\spad{createPlot1Din2Dparametric(ppc,{} tRange,{} numPts)} creates a node from plot using Parametric Plane Curve. This represents 1 dimension (line - possibly curved) in 2 dimensions (plane) In theory a line has no width but in that case we would not see it so we give it a width given by the material node that is applicable in this part of the scene graph \spad{PPC} is ParametricPlaneCurve(\spad{DF} \spad{->} \spad{DF}) which is created with curve(\spad{f1},{} \spad{f2}) where \spad{f1} and \spad{f2} are functions of type ComponentFunction,{} in this case \spad{DF} \spad{->} \spad{DF}


kind: o
name: createPlot1Din3Dparametric
exposed: n
type: ((DoubleFloat)->PT,Segment(DoubleFloat),NonNegativeInteger)->%
params: dScene(PT)
comment:
\spad{createPlot1Din3Dparametric(pcfun,{} tRange,{} numPts)} create a line (1D subspace) in 3D space. This represents 1 dimension (line - possibly curved) in 3 dimensions In theory a line has no width but in that case we would not see it so we give it a width given by the material node that is applicable in this part of the scene graph PCFUN is a function from float to point: \spad{DF} \spad{->} \spad{PT}


kind: o
name: createPlot1Din3Dparametric
exposed: n
type: (ParametricSpaceCurve((DoubleFloat)->DoubleFloat),Segment(DoubleFloat),NonNegativeInteger)->%
params: dScene(PT)
comment:
\spad{createPlot1Din3Dparametric(psc,{} tRange,{} numPts)} create a line (1D subspace) in 3D space. This represents 1 dimension (line - possibly curved) in 3 dimensions In theory a line has no width but in that case we would not see it so we give it a width given by the material node that is applicable in this part of the scene graph \spad{PSC} ParametricSpaceCurve(\spad{DF} \spad{->} \spad{DF}) is created with curve(\spad{f1},{} \spad{f2},{} \spad{f3}) where \spad{f1},{} \spad{f2} and \spad{f3} are functions of type ComponentFunction,{} in this case \spad{DF} \spad{->} \spad{DF}


kind: o
name: createPlot2Din3D
exposed: n
params: dScene(PT)
type:
((DoubleFloat,DoubleFloat)->DoubleFloat,Segment(DoubleFloat),Segment(DoubleFloat),NonNegativeInteger)->%

comment:
\spad{createPlot2Din3D(f,{} a..b,{} c..d)} returns a scene node which contains the graph of \spad{z} = \spad{f}(\spad{x},{} \spad{y}) as \spad{x} ranges from min(a,{} \spad{b}) to max(a,{} \spad{b}) and \spad{y} ranges from min(\spad{c},{} \spad{d}) to max(\spad{c},{} \spad{d}). create a surface (2D subspace) in 3D space The surface is approximated by polygons which are represented by in indexed face set (IFS) node


kind: o
name: createPlot2Din3D
exposed: n
type: ((DoubleFloat,DoubleFloat)->PT,Segment(DoubleFloat),Segment(DoubleFloat),NonNegativeInteger)->%
params: dScene(PT)
comment:
\spad{createPlot2Din3D(ptFun,{} uSeg,{} vSeg,{} numPts)} create a surface (2D subspace) in 3D space. The surface is approximated by polygons which are represented by in indexed face set (IFS) node


kind: o
name: createPlot2Din3Dparametric
exposed: n
type: ((DoubleFloat,DoubleFloat)->PT,Segment(DoubleFloat),Segment(DoubleFloat),NonNegativeInteger)->%
params: dScene(PT)
comment:
\spad{createPlot2Din3Dparametric(f,{} a..b,{} c..d,{} l)} returns a scene node which contains the graph of the parametric surface \spad{f}(\spad{u},{} \spad{v}) as \spad{u} ranges from min(a,{} \spad{b}) to max(a,{} \spad{b}) and \spad{v} ranges from min(\spad{c},{} \spad{d}) to max(\spad{c},{} \spad{d}). This creates a surface (2D subspace) in 3D space The surface is approximated by polygons which are represented by in indexed face set (IFS) node


kind: o
name: createPlot2Din3Dparametric
exposed: n
params: dScene(PT)
type:
(ParametricSurface((DoubleFloat,DoubleFloat)->DoubleFloat),Segment(DoubleFloat),Segment(DoubleFloat),NonNegativeInteger)->%

comment:
\spad{createPlot2Din3Dparametric(surface(f,{} g,{} h),{} a..b,{} c..d,{} l)} returns a scene node which contains the graph of the parametric surface \spad{x} = \spad{f}(\spad{u},{} \spad{v}),{} \spad{y} = \spad{g}(\spad{u},{} \spad{v}),{} \spad{z} = \spad{h}(\spad{u},{} \spad{v}) as \spad{u} ranges from min(a,{} \spad{b}) to max(a,{} \spad{b}) and \spad{v} ranges from min(\spad{c},{} \spad{d}) to max(\spad{c},{} \spad{d}). This creates a surface (2D subspace) in 3D space The surface is approximated by polygons which are represented by in indexed face set (IFS) node


kind: o
name: createPrimitiveElement
exposed: x
type: ()->%
params: cFiniteFieldCategory
comment:
\spad{createPrimitiveElement()} computes a generator of the (cyclic) multiplicative group of the field.


kind: o
name: createPrimitiveNormalPoly
exposed: n
type: (PositiveInteger)->SparseUnivariatePolynomial(GF)
params: pFiniteFieldPolynomialPackage(GF)
comment:
\spad{createPrimitiveNormalPoly(n)}\$FFPOLY(\spad{GF}) generates a normal and primitive polynomial of degree \spad{n} over the field {\em GF}.


kind: o
name: createPrimitivePoly
exposed: n
type: (PositiveInteger)->SparseUnivariatePolynomial(GF)
params: pFiniteFieldPolynomialPackage(GF)
comment:
\spad{createPrimitivePoly(n)}\$FFPOLY(\spad{GF}) generates a primitive polynomial of degree \spad{n} over the finite field {\em GF}.


kind: o
name: createRandomElement
exposed: x
type: (List(Matrix(R)),Matrix(R))->Matrix(R)
params: pRepresentationPackage2(R)
comment:
\spad{createRandomElement(aG,{} x)} creates a random element of the group algebra generated by {\em aG}.


kind: o
name: createSceneArrow
exposed: n
type: (String,String,PT,Symbol,DoubleFloat)->%
params: dScene(PT)
comment:
\spad{createSceneArrow(st,{} en,{} offset,{} mode,{} size)} constructs an arrow node,{} in \spad{n}-dimensional space,{} going from \spad{st} to \spad{en}. 'st' and 'en' are determined from a list of points from named points node. \spad{st} is the start of the arrow \spad{en} is the end of the arrow 'mode' and 'size' parameters determine the size of the arrowhead. \spad{mode} can have the following values: \indented{2}{fixed::Symbol \spad{--} fixed size line width given by 'size' parameter} \indented{2}{proportional::Symbol \spad{--} size as a proportion of the overall bounds} \indented{2}{variable::Symbol \spad{--} size as a proportion of the arrow length} So proportional would typically be used when drawing a graph (in graph theory) where it looks better if each arrow head is the same. variable would typically be used when drawing a force field where a bigger arrow head might indicate a stronger force.


kind: o
name: createSceneArrow
exposed: n
type: (%,%,PT,Symbol,DoubleFloat,DoubleFloat)->%
params: dScene(PT)
comment:
\spad{createSceneArrow(st,{} en,{} offset,{} mode,{} size,{} fontScale)} constructs an arrow node,{} in \spad{n}-dimensional space,{} going from \spad{st} to \spad{en}. 'st' and 'en' are nodes in the scene and the arrows will be drawn upto their boundary. \spad{st} is the node at the start of the arrow \spad{en} is the node at the end of the arrow 'mode' and 'size' parameters determine the \spad{size} of the arrowhead. \spad{mode} can have the following values: \indented{2}{fixed::Symbol \spad{--} fixed \spad{size} line width given by 'size' parameter} \indented{2}{proportional::Symbol \spad{--} \spad{size} as a proportion of the overall bounds} \indented{2}{variable::Symbol \spad{--} \spad{size} as a proportion of the arrow length} So proportional would typically be used when drawing a graph (in graph theory) where it looks better if each arrow head is the same. variable would typically be used when drawing a force field where a bigger arrow head might indicate a stronger force. fontScale should be set to the full width of the diagram (not just the width of this node). If this is not known then choose an approximate value. This only affects text nodes,{} if \spad{st} or \spad{en},{} or its subnodes,{} do not contain a text node then its value is not significant.


kind: o
name: createSceneArrows
exposed: n
type: (List(List(PT)),Symbol,DoubleFloat)->%
params: dScene(PT)
comment:
\spad{createSceneArrows(line,{} mode,{} size)} constructs an arrow node,{} this contains arrows (represented by a list of points) in \spad{n}-dimensional space. The space is implicit in the \spad{PT} and \spad{TR} parameters supplied when this Scene was created. 'mode' and 'size' parameters determine the size of the arrowhead. \spad{mode} can have the following values: \indented{2}{fixed::Symbol \spad{--} fixed size \spad{line} width given by 'size' parameter} \indented{2}{proportional::Symbol \spad{--} size as a proportion of the overall bounds} \indented{2}{variable::Symbol \spad{--} size as a proportion of the arrow length} So proportional would typically be used when drawing a graph (in graph theory) where it looks better if each arrow head is the same. variable would typically be used when drawing a force field where a bigger arrow head might indicate a stronger force.


kind: o
name: createSceneBox
exposed: n
type: (DoubleFloat)->%
params: dScene(PT)
comment:
\spad{createSceneBox(size)} constructs an indexed face set node which is a 3D box of a given \spad{size}


kind: o
name: createSceneClip
exposed: n
type: (SBoundary(PT))->%
params: dScene(PT)
comment:
\spad{createSceneClip(bb)} constructs a clip node,{} clips its sub nodes in the coordinate system in force at the clip node.


kind: o
name: createSceneDef
exposed: n
type: (String,%)->%
params: dScene(PT)
comment:
\spad{createSceneDef(nam,{} nde)} defines a point in the scenegraph so that it can be used elsewhere.


kind: o
name: createSceneGrid
exposed: n
type: (SBoundary(PT))->%
params: dScene(PT)
comment:
\spad{createSceneGrid(bb)} constructs a grid with narrow blue lines every 20 units wide blue lines every 100 units wide red lines every 200 units


kind: o
name: createSceneGrid
exposed: n
type: (DoubleFloat,SBoundary(PT))->%
params: dScene(PT)
comment:
\spad{createSceneGrid(stepSize,{} bb)} constructs a grid,{} consists of a group,{} under which are vertical and horizontal lines. The spacing between lines is given by step.


kind: o
name: createSceneGroup
exposed: n
type: ()->%
params: dScene(PT)
comment:
\spad{createSceneGroup()} constructs a group node,{} this node does not do anything itself but contains other nodes


kind: o
name: createSceneIFS
exposed: n
type: (SceneIFS(PT))->%
params: dScene(PT)
comment:
\spad{createSceneIFS(in1)} constructs an indexed face set node,{} this defines a surface represented by a set of polygons in \spad{n}-dimensional space.


kind: o
name: createSceneIFS
exposed: n
type: (List(List(NonNegativeInteger)),List(PT))->%
params: dScene(PT)
comment:
\spad{createSceneIFS(inx,{} pts)} constructs an indexed face set node,{} this defines a surface represented by a set of polygons in \spad{n}-dimensional space.


kind: o
name: createSceneLine
exposed: n
type: (List(PT))->%
params: dScene(PT)
comment:
\spad{createSceneLine(line)} constructs a \spad{line} node,{} this contains a \spad{line} (represented by a list of points) in \spad{n}-dimensional space. The space is implicit in the \spad{PT} and \spad{TR} parameters supplied when this Scene was created.


kind: o
name: createSceneLine
exposed: n
type: (%,%,DoubleFloat)->%
params: dScene(PT)
comment:
\spad{createSceneLine(st,{} en,{} fontScale)} constructs a line node,{} that contains a line,{} in \spad{n}-dimensions,{} from \spad{st} to \spad{en}. 'st' and 'en' are nodes in the scene and the line will be drawn upto their boundary. \spad{st} is the node at the start of the line \spad{en} is the node at the end of the line fontScale should be set to the full width of the diagram (not just the width of this node). If this is not known then choose an approximate value. This only affects text nodes,{} if \spad{st} or \spad{en},{} or its subnodes,{} do not contain a text node then its value is not significant.


kind: o
name: createSceneLine
exposed: n
type: (%,%,DoubleFloat,Boolean)->%
params: dScene(PT)
comment:
\spad{createSceneLine(st,{} en,{} fontScale,{} shortenLine)} constructs a line node,{} that contains a line,{} in \spad{n}-dimensions,{} from \spad{st} to \spad{en}. 'st' and 'en' are nodes in the scene and the line will be drawn upto their boundary. \spad{st} is the node at the start of the line \spad{en} is the node at the end of the line \spad{fontScale} should be set to the full width of the diagram (not just the width of this node). If this is not known then choose an approximate value. This only affects text nodes,{} if \spad{st} or \spad{en},{} or its subnodes,{} do not contain a text node then its value is not significant. shortenLine if \spad{true} line drawn upto boundary rather than \indented{12}{centre of destination.}


kind: o
name: createSceneLines
exposed: n
type: (List(List(PT)))->%
params: dScene(PT)
comment:
\spad{createSceneLines(line)} constructs a \spad{line} node,{} this contains lines (represented by a list of points) in \spad{n}-dimensional space. The space is implicit in the \spad{PT} and \spad{TR} parameters supplied when this Scene was created.


kind: o
name: createSceneMaterial
exposed: n
type: (Record(lineWidth:DoubleFloat,lineCol:String,fillCol:String,matOpacity:DoubleFloat))->%
params: dScene(PT)
comment:
\spad{createSceneMaterial(mat)} constructs a material node This sets the lineWidth,{} lineCol and fillCol for all nodes under this,{} unless overridden by another material node. That is the material parameters that apply to a given node are those of the closest material node above it in the hierarchy line width is expressed relative to the width of current boundary


kind: o
name: createSceneMaterial
exposed: n
type: (DoubleFloat,String,String)->%
params: dScene(PT)
comment:
\spad{createSceneMaterial(lineW,{} lineC,{} fillC)} constructs a material node This sets the lineWidth,{} lineCol and fillCol for all nodes under this,{} unless overridden by another material node. That is the material parameters that apply to a given node are those of the closest material node above it in the hierarchy


kind: o
name: createSceneNamedPoints
exposed: n
type: (SceneNamedPoints(PT))->%
params: dScene(PT)
comment:
\spad{createSceneNamedPoints(np)} constructs a named points node,{} this allows us to define a set of points which can be used multiple times in the scenegraph.


kind: o
name: createScenePattern
exposed: n
type: (Symbol,NonNegativeInteger,SBoundary(PT))->%
params: dScene(PT)
comment:
\spad{createScenePattern(ptype,{} step,{} bb)} creates a test pattern suitable for showing the effect of transforms. The pattern depends on \spad{ptype} parameter as follows: ptype=GRID::Symbol : construct a set of horizontal and vertical lines in the current clip boundary and current material with a spacing between lines given by the \spad{step} parameter. ptype=SIERPINSKI::Symbol: constructs a Sierpinski fractal. \spad{step} parameter gives the level of subdivision. ptype=HOUSE::Symbol: constructs a house shape.


kind: o
name: createSceneRoot
exposed: n
type: ()->%
params: dScene(PT)
comment:
\spad{createSceneRoot()} constructs the root node,{} all other nodes are contained in a tree structure under this node


kind: o
name: createSceneRoot
exposed: n
type: (SBoundary(PT))->%
params: dScene(PT)
comment:
\spad{createSceneRoot(bb)} constructs the root node,{} all other nodes are contained in a tree structure under this node


kind: o
name: createSceneRoot
exposed: n
type: (Integer,Integer,Integer,Integer)->%
params: dScene(PT)
comment:
\spad{createSceneRoot(minx,{} miny,{} maxx,{} maxy)} constructs the root node,{} all other nodes are contained in a tree structure under this node


kind: o
name: createSceneRuler
exposed: n
type: (Symbol,PT,SBoundary(PT))->%
params: dScene(PT)
comment:
\spad{createSceneRuler(ptype,{} offset,{} bb)} creates a scale that can be used to provide numeric values for an axis: ptype= HORIZONTAL::Symbol : horizontal axis. ptype= VERTICAL::Symbol: vertical axis. ptype= DEBTH::Symbol: depth axis.


kind: o
name: createSceneShape
exposed: n
type: (Record(shptype:Symbol,centre:PT,size:PT,fill:Boolean))->%
params: dScene(PT)
comment:
\spad{createSceneShape(shape)} constructs a \spad{shape} node,{} this contains a \spad{shape} such as a rectangle or an ellipse.


kind: o
name: createSceneShape
exposed: n
type: (SBoundary(PT))->%
params: dScene(PT)
comment:
\spad{createSceneShape(shape)} constructs a \spad{shape} node from a boundary,{} this contains a \spad{shape} such as a rectangle or an ellipse.


kind: o
name: createSceneText
exposed: n
type: (Record(txt:String,siz:NonNegativeInteger,pos:PT,np:List(String)))->%
params: dScene(PT)
comment:
\spad{createSceneText(text)} constructs a \spad{text} node,{} \spad{text} can be used for labelling anything such as graphs,{} axes and so on.


kind: o
name: createSceneText
exposed: n
type: (List(String),NonNegativeInteger,PT)->%
params: dScene(PT)
comment:
\spad{createSceneText(str,{} sz,{} pz)} constructs a text node using information from named points node.


kind: o
name: createSceneText
exposed: n
type: (String,NonNegativeInteger,PT)->%
params: dScene(PT)
comment:
\spad{createSceneText(str,{} sz,{} pz)} constructs a text node,{} text can be used for labelling anything such as graphs,{} axes and so on.


kind: o
name: createSceneTransform
exposed: n
type: (STransform(PT))->%
params: dScene(PT)
comment:
\spad{createSceneTransform(tran)} constructs a transform node This transforms the points and vectors below this node If a given node has more than one transform node above it in the hierarchy then the transforms are compound


kind: o
name: createThreeSpace
exposed: x
type: ()->ThreeSpace(DoubleFloat)
params: pTopLevelThreeSpace
comment:
\spad{createThreeSpace()} creates a \spadtype{ThreeSpace(DoubleFloat)} object capable of holding point,{} curve,{} mesh components and any combination.


kind: o
name: createWidth
exposed: n
type: (NonNegativeInteger)->NonNegativeInteger
params: cFiniteGraph(S)
comment:
\spad{createWidth(x)} can be used by domains which extend graph to help in creating coordinates for objects in a graph


kind: o
name: createX
exposed: n
type: (NonNegativeInteger,NonNegativeInteger)->NonNegativeInteger
params: cFiniteGraph(S)
comment:
\spad{createX(x,{} n)} can be used by domains which extend graph to help in creating the \spad{x} coordinate for objects in a graph


kind: o
name: createY
exposed: n
type: (NonNegativeInteger,NonNegativeInteger)->NonNegativeInteger
params: cFiniteGraph(S)
comment:
\spad{createY(x,{} n)} can be used by domains which extend graph to help in creating the \spad{y} coordinate for objects in a graph


kind: o
name: createZechTable
exposed: n
type: (SparseUnivariatePolynomial(GF))->PrimitiveArray(SingleInteger)
params: pFiniteFieldFunctions(GF)
comment:
\spad{createZechTable(f)} generates a Zech logarithm table for the cyclic group representation of a extension of the ground field by the primitive polynomial {\em f(x)},{} \spadignore{i.e.} \spad{Z(i)},{} defined by {\em x^Z(i) = 1+x^i} is stored at index \spad{i}. This is needed in particular to perform addition of field elements in finite fields represented in this way. See \spadtype{FFCGP},{} \spadtype{FFCGX}.


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


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


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


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


kind: o
name: cross
exposed: n
type: (Point(DoubleFloat),Point(DoubleFloat))->Point(DoubleFloat)
params: pTubePlotTools
comment:
\spad{cross(p,{} q)} computes the cross product of the two points \spad{p} and \spad{q} using only the first three coordinates,{} and keeping the color of the first point \spad{p}. The result is returned as a point.


kind: o
name: cross
exposed: x
type: (%,%)->%
params: cPointCategory(R)
comment:
\spad{cross(p,{} q)} computes the cross product of the two points \spad{p} and \spad{q}. Error if the \spad{p} and \spad{q} are not 3 dimensional


kind: o
name: cross
exposed: x
type: (%,%)->%
params: cVectorCategory(R)
abbrev: has(R,Ring)
comment:
\spad{cross(u,{} v)} constructs the cross product of \spad{u} and \spad{v}. Error: if \spad{u} and \spad{v} are not of length 3.


kind: o
name: crushedSet
exposed: n
type: (List(P))->List(P)
params: pPolynomialSetUtilitiesPackage(R,E,V,P)
comment:
\spad{crushedSet(lp)} returns \spad{lq} such that \spad{lp} and and \spad{lq} generate the same ideal and no rough basic sets reduce (in the sense of Groebner bases) the other polynomials in \spad{lq}.


kind: o
name: cSec
exposed: n
type: (%)->%
params: dInnerSparseUnivariatePowerSeries(Coef)
abbrev: has(Coef,Algebra(Fraction(Integer)))
comment:
\spad{cSec(f)} computes the secant of the power series \spad{f}. For use when the coefficient ring is commutative.


kind: o
name: cSech
exposed: n
type: (%)->%
params: dInnerSparseUnivariatePowerSeries(Coef)
abbrev: has(Coef,Algebra(Fraction(Integer)))
comment:
\spad{cSech(f)} computes the hyperbolic secant of the power series \spad{f}. For use when the coefficient ring is commutative.


kind: o
name: cSin
exposed: n
type: (%)->%
params: dInnerSparseUnivariatePowerSeries(Coef)
abbrev: has(Coef,Algebra(Fraction(Integer)))
comment:
\spad{cSin(f)} computes the sine of the power series \spad{f}. For use when the coefficient ring is commutative.


kind: o
name: cSinh
exposed: n
type: (%)->%
params: dInnerSparseUnivariatePowerSeries(Coef)
abbrev: has(Coef,Algebra(Fraction(Integer)))
comment:
\spad{cSinh(f)} computes the hyperbolic sine of the power series \spad{f}. For use when the coefficient ring is commutative.


kind: o
name: csolve_pol
exposed: n
type: ((Matrix(F))->List(Vector(Q)),List(UP))->List(Vector(Q))
params: pLiftLinearDependence(F,Q,UP)
comment:
\spad{csolve_pol(solf,{} lp)} uses \spad{solf} to solve linear dependence for univariate polynomials.


kind: o
name: csolve_rf
exposed: n
type: ((Matrix(F))->List(Vector(Q)),List(Fraction(UP)))->List(Vector(Q))
params: pLiftLinearDependence(F,Q,UP)
comment:
\spad{csolve_rf(solf,{} lrf)} uses \spad{solf} to solve linear dependence for univariate rational functions.


kind: o
name: csolve_rmat
exposed: n
type: ((Matrix(F))->List(Vector(Q)),Matrix(Fraction(UP)))->List(Vector(Q))
params: pLiftLinearDependence(F,Q,UP)
comment:
\spad{csolve_rmat(solf,{} mrf)} uses \spad{solf} to solve linear dependence for univariate rational functions.


kind: o
name: cTan
exposed: n
type: (%)->%
params: dInnerSparseUnivariatePowerSeries(Coef)
abbrev: has(Coef,Algebra(Fraction(Integer)))
comment:
\spad{cTan(f)} computes the tangent of the power series \spad{f}. For use when the coefficient ring is commutative.


kind: o
name: cTanh
exposed: n
type: (%)->%
params: dInnerSparseUnivariatePowerSeries(Coef)
abbrev: has(Coef,Algebra(Fraction(Integer)))
comment:
\spad{cTanh(f)} computes the hyperbolic tangent of the power series \spad{f}. For use when the coefficient ring is commutative.


kind: o
name: cubicalFacet
exposed: n
type: (Integer,List(Segment(Integer)))->%
params: dCubicalFacet
comment:
Constructor for cubical facet intervals are always stored in low..high order orientation is calculated by the number of intervals that have to be flipped to put it in order.


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


kind: o
name: cup
exposed: x
params: pCycleIndicators
type:
(SymmetricPolynomial(Fraction(Integer)),SymmetricPolynomial(Fraction(Integer)))->SymmetricPolynomial(Fraction(Integer))

comment:
\spad{cup(s1,{} s2)},{} introduced by Redfield,{} \indented{1}{is the scalar product of two cycle indices,{} in which the} \indented{1}{power sums are retained to produce a cycle index.}


kind: o
name: curve?
exposed: x
type: (%)->Boolean
params: cThreeSpaceCategory(R)
comment:
\spad{curve?(s)} queries whether the \spadtype{ThreeSpace},{} \spad{s},{} is a curve,{} \spadignore{i.e.} has one component,{} a list of list of points,{} and returns \spad{true} if it is,{} or \spad{false} otherwise.


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


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


kind: o
name: curve
exposed: x
type: (%,List(List(R)))->%
params: cThreeSpaceCategory(R)
comment:
\spad{curve(s,{} [[p0],{} [p1],{} ...,{} [pn]])} adds a space curve which is a list of points \spad{p0} through \spad{pn} defined by lists of elements from the domain \spad{PointDomain(m,{} R)},{} where \spad{R} is the \spadtype{Ring} over which the point elements are defined and \spad{m} is the dimension of the points,{} to the \spadtype{ThreeSpace} \spad{s}.


kind: o
name: curve
exposed: x
type: (%,List(Point(R)))->%
params: cThreeSpaceCategory(R)
comment:
\spad{curve(s,{} [p0,{} p1,{} ...,{} pn])} adds a space curve component defined by a list of points \spad{p0} through \spad{pn},{} to the \spadtype{ThreeSpace} \spad{s}.


kind: o
name: curve
exposed: x
type: (ComponentFunction,ComponentFunction,ComponentFunction)->%
params: dParametricSpaceCurve(ComponentFunction)
comment:
\spad{curve(c1,{} c2,{} c3)} creates a space curve from 3 component functions \spad{c1},{} \spad{c2},{} and \spad{c3}.


kind: o
name: curveColor
exposed: x
type: (Float)->%
params: dDrawOption
comment:
\spad{curveColor(v)} specifies a color,{} \spad{v},{} for 2D graph curves. This option is expressed in the form \spad{curveColor == v}.


kind: o
name: curveColor
exposed: x
type: (Palette)->%
params: dDrawOption
comment:
\spad{curveColor(p)} specifies a color index for 2D graph curves from the spadcolors palette \spad{p}. This option is expressed in the form \spad{curveColor ==p}.


kind: o
name: curveColorPalette
exposed: n
type: (List(DrawOption),Palette)->Palette
params: pDrawOptionFunctions0
comment:
\spad{curveColorPalette(l,{} p)} takes the list of draw options,{} \spad{l},{} and checks the list to see if it contains the option \spad{curveColorPalette}. If the option does not exist the value,{} \spad{p} is returned.


kind: o
name: cycle
exposed: x
type: (List(S))->%
params: cPermutationCategory(S)
comment:
\spad{cycle(ls)} coerces a cycle {\em ls},{} \spadignore{i.e.} a list with not repetitions to a permutation,{} which maps {\em ls.i} to {\em ls.i+1},{} indices modulo the length of the list. Error: if repetitions occur.


kind: o
name: cycleClosed
exposed: n
type: (List(S),String)->%
params: cFiniteGraph(S)
comment:
\spad{cycleClosed(objs,{} arrowName)} constructs a graph with vertices (from \spad{objs}) connected in a cycle. 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: cycleElt
exposed: n
type: (ST)->Union(ST,failed)
params: pCyclicStreamTools(S,ST)
comment:
\spad{cycleElt(s)} returns a pointer to a node in the cycle if the stream \spad{s} is cyclic and returns failed if \spad{s} is not cyclic


kind: o
name: cycleEntry
exposed: x
type: (%)->%
params: cUnaryRecursiveAggregate(S)
comment:
\spad{cycleEntry(u)} returns the head of a top-level cycle contained in aggregate \spad{u},{} or \spad{empty()} if none exists.


kind: o
name: cycleLength
exposed: x
type: (%)->NonNegativeInteger
params: cUnaryRecursiveAggregate(S)
comment:
\spad{cycleLength(u)} returns the length of a top-level cycle contained in aggregate \spad{u},{} or 0 if \spad{u} has no such cycle.


kind: o
name: cycleOpen
exposed: n
type: (List(S),String)->%
params: cFiniteGraph(S)
comment:
\spad{cycleOpen(objs,{} arrowName)} constructs a graph with vertices (from \spad{objs}) connected in a cycle but with one gap. The last vertex in the sequence loops back to itself so all vertices have one outgoing arrow. 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: cyclePartition
exposed: x
type: (%)->Partition
params: dPermutation(S)
comment:
\spad{cyclePartition(p)} returns the cycle structure of a permutation \spad{p} including cycles of length 1 only if \spad{S} is finite.


kind: o
name: cycleRagits
exposed: x
type: (%)->List(Integer)
params: dRadixExpansion(bb)
comment:
\spad{cycleRagits(rx)} returns the 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{cycleRagits(x) = [7,{} 1,{} 4,{} 2,{} 8,{} 5]}.


kind: o
name: cycles
exposed: x
type: (List(List(S)))->%
params: cPermutationCategory(S)
comment:
\spad{cycles(lls)} coerces a list list of cycles {\em lls} to a permutation,{} each cycle being a list with not repetitions,{} is coerced to the permutation,{} which maps {\em ls.i} to {\em ls.i+1},{} indices modulo the length of the list,{} then these permutations are multiplied. Error: if repetitions occur in one cycle.


kind: o
name: cycleSplit!
exposed: x
type: (%)->%
params: cUnaryRecursiveAggregate(S)
abbrev: has(%,shallowlyMutable)
comment:
\spad{cycleSplit!(u)} splits the aggregate by dropping off the cycle. The value returned is the cycle entry,{} or empty() if none exists. For example,{} if \spad{w = concat(u,{} v)} is the cyclic list where \spad{v} is the head of the cycle,{} \spad{cycleSplit!(w)} will drop \spad{v} off \spad{w} thus destructively changing \spad{w} to \spad{u},{} and returning \spad{v}.


kind: o
name: cyclicGroup
exposed: n
type: (PositiveInteger)->%
params: dGroupPresentation
comment:
\spad{cyclicGroup(n)} constructs the cyclic group of order \spad{n} acting on the integers 1,{} ...,{} \spad{n}.


kind: o
name: cyclicGroup
exposed: x
type: (List(Integer))->PermutationGroup(Integer)
params: pPermutationGroupExamples
comment:
\spad{cyclicGroup([i1,{} ...,{} ik])} constructs the cyclic group of order \spad{k} acting on the integers {\em i1},{} ...,{} {\em ik}. Note: duplicates in the list will be removed.


kind: o
name: cyclicSubmodule
exposed: x
type: (List(Matrix(R)),Vector(R))->Vector(Vector(R))
params: pRepresentationPackage2(R)
abbrev: has(R,EuclideanDomain)
comment:
\spad{cyclicSubmodule(lm,{} v)} generates a basis as follows. It is assumed that the size \spad{n} of the vector equals the number of rows and columns of the matrices. Then the matrices generate a subalgebra,{} say \spad{A},{} of the algebra of all square matrices of dimension \spad{n}. {\em V R} is an \spad{A}-module in the natural way. cyclicSubmodule(\spad{lm},{} \spad{v}) generates the \spad{R}-Basis of {\em Av} as described in section 6 of \spad{R}. A. Parker\spad{'s} The Meat-Axe. Note: in contrast to the description in The Meat-Axe and to {\em standardBasisOfCyclicSubmodule} the result is in echelon form.


kind: o
name: cyclotomic
exposed: n
type: (Integer)->SparseUnivariatePolynomial(Integer)
params: pPolynomialNumberTheoryFunctions
comment:
\spad{cyclotomic(n)} returns the \spad{n}th cyclotomic polynomial \spad{phi[n](x)}. Note: \spad{phi[n](x)} is the factor of \spad{x^n - 1} whose roots are the primitive \spad{n}th roots of unity.


kind: o
name: cyclotomic?
exposed: n
type: (SparseUnivariatePolynomial(Integer))->Union(Integer,failed)
params: pCyclotomicUtilities
comment:
\spad{cyclotomic?(p)} checks if \spad{p} is a cyclotomic polynomial. If yes returns \spad{n} such that \spad{p = cyclotomic(n)}. Otherwise returns failed.


kind: o
name: cyclotomic_array
exposed: n
type: (Integer)->PrimitiveArray(Integer)
params: pCyclotomicUtilities
comment:
\spad{cyclotomic_array(n)} computes pa containing lower half of coefficients of \spad{n}-th cyclotomic polynomial. maximal index in \spad{pa} is \spad{eulerPhi(n)/2}. Due to symmetry this is enough to reconstruct cyclotomic polynomial from computed coefficients.


kind: o
name: cyclotomic_decomposition
exposed: n
type: (Integer)->List(SparseUnivariatePolynomial(Integer))
params: pCyclotomicUtilities
comment:
\spad{cyclotomic_decomposition(n)} computes list of irreducible factors of \spad{x^n - 1} over integers.


kind: o
name: cylindrical
exposed: x
type: (Point(R))->Point(R)
params: pCoordinateSystems(R)
comment:
\spad{cylindrical(pt)} transforms \spad{pt} from polar coordinates to Cartesian coordinates: the function produced will map the point \spad{(r,{} theta,{} z)} to \spad{x = r * cos(theta)},{} \spad{y = r * sin(theta)},{} \spad{z}.


kind: o
name: cylindricalDecomposition
exposed: n
type: (List(Polynomial(TheField)))->List(Cell(TheField))
params: pCylindricalAlgebraicDecompositionPackage(TheField)
comment:
\spad{cylindricalDecomposition(lp)} is cylindricalDecomposition(\spad{lp},{} \spad{lv}) where \spad{lv} is list of variables in \spad{lp}.


kind: o
name: cylindricalDecomposition
exposed: n
type: (List(Polynomial(TheField)),List(Symbol))->List(Cell(TheField))
params: pCylindricalAlgebraicDecompositionPackage(TheField)
comment:
\spad{cylindricalDecomposition(lp,{} lv)} computes cylindrical decomposition of \spad{lp} in using variable order given by \spad{lv}


kind: o
name: D
exposed: x
type: (%)->%
params: cDifferentialRing
comment:
\spad{D(x)} returns the derivative of \spad{x}. This function is a simple differential operator where no variable needs to be specified.


kind: o
name: D
exposed: n
type: (Symbol,List(Symbol))->%
params: dJetBundle(IVar,DVar)
comment:
\spad{D(U,{} [X1,{} ...,{} Xq])} generates a derivative. \spad{U} must be in \spad{DVar}; all other symbols in \spad{IVar}.


kind: o
name: D
exposed: x
type: (%,List(S))->%
params: cPartialDifferentialRing(S)
comment:
\spad{D(x,{} [s1,{} ...sn])} computes successive partial derivatives,{} \spadignore{i.e.} \spad{D(...D(x,{} s1)...,{} sn)}.


kind: o
name: D
exposed: x
type: (%,List(S),List(NonNegativeInteger))->%
params: cPartialDifferentialRing(S)
comment:
\spad{D(x,{} [s1,{} ...,{} sn],{} [n1,{} ...,{} nn])} computes multiple partial derivatives,{} \spadignore{i.e.} \spad{D(...D(x,{} s1,{} n1)...,{} sn,{} nn)}.


kind: o
name: D
exposed: x
type: (%,(R)->R,NonNegativeInteger)->%
params: cDifferentialExtension(R)
comment:
\spad{D(x,{} deriv,{} n)} differentiate \spad{x} \spad{n} times using a derivation which extends \spad{deriv} on \spad{R}.


kind: o
name: D
exposed: x
type: (%,S,NonNegativeInteger)->%
params: cPartialDifferentialRing(S)
comment:
\spad{D(x,{} s,{} n)} computes multiple partial derivatives,{} \spadignore{i.e.} \spad{n}-th derivative of \spad{x} with respect to \spad{s}.


kind: o
name: dAndcExp
exposed: n
type: (Vector(GF),NonNegativeInteger,SingleInteger)->Vector(GF)
params: pInnerNormalBasisFieldFunctions(GF)
comment:
\spad{dAndcExp(v,{} n,{} k)} computes \spad{v^e} interpreting \spad{v} as an element of normal basis field. A divide and conquer algorithm similar to the one from \spad{D}.\spad{R}.Stinson,{} Some observations on parallel Algorithms for fast exponentiation in \spad{GF}(2^n),{} Siam \spad{J}. Computation,{} Vol.19,{} No.4,{} \spad{pp}.711-717,{} August 1990 is used. Argument \spad{k} is a parameter of this algorithm.


kind: o
name: danilewski
exposed: n
type: (Matrix(F))->Record(matrix:Matrix(F),block_list:List(Integer))
params: pCharacteristicPolynomial2(F)
comment:
\spad{danilewski(m)} converts \spad{m} to block form where each block represents transposition of multiplication by a polynomial.


kind: o
name: ddfact
exposed: n
type: (PA,MD)->List(Record(poly:PA,degree:NonNegativeInteger,separate_factors:()->List(PA)))
params: pModularFactorizationGeneral(PA,MMT,MD,PMD,MO)
comment:
\spad{ddfact(pv,{} md)} computes distinct degree factorization of \spad{pv}. \spad{pv} is assumed square-free and monic,{} \spad{md} is info representing finite field.


kind: o
name: ddfact
exposed: n
params: pModularFactorizationK(K)
type:
(PrimitiveArray(K),Record(i_mod:Integer,deg:Integer))->List(Record(poly:PrimitiveArray(K),degree:NonNegativeInteger,separate_factors:()->List(PrimitiveArray(K))))


kind: o
name: ddfact
exposed: n
params: pModularFactorization
type:
(U32Vector,Integer)->List(Record(poly:U32Vector,degree:NonNegativeInteger,separate_factors:()->List(U32Vector)))


kind: o
name: debug
exposed: n
type: (List(GuessOption))->Boolean
params: dGuessOptionFunctions0
comment:
\spad{debug returns} whether we want additional output on the progress,{} default being \spad{false}


kind: o
name: debug
exposed: x
type: (Boolean)->%
params: dGuessOption
comment:
\spad{debug(d)} specifies whether we want additional output on the progress. This option is expressed in the form \spad{debug == d}.


kind: o
name: declare
exposed: n
type: (List(%))->Symbol
params: dInputForm
comment:
\spad{declare(t)} returns a name \spad{f} such that \spad{f} has been declared to the interpreter to be of type \spad{t},{} but has not been assigned a value yet. Note: \spad{t} should be created as \spad{devaluate(T)\$Lisp} where \spad{T} is the actual type of \spad{f} (this hack is required for the case where \spad{T} is a mapping type).


kind: o
name: declare!
exposed: n
type: (Symbol,FortranType)->FortranType
params: dTheSymbolTable
comment:
\spad{declare!(u,{} t)} declares the parameter \spad{u} to have type \spad{t} in the current level of the symbol table.


kind: o
name: declare!
exposed: n
type: (List(Symbol),FortranType,%)->FortranType
params: dSymbolTable
comment:
\spad{declare!(l,{} t,{} tab)} creates new entries in tab,{} declaring each of \spad{l} to be of type \spad{t}


kind: o
name: declare!
exposed: n
type: (Symbol,FortranType,%)->FortranType
params: dSymbolTable
comment:
\spad{declare!(u,{} t,{} tab)} creates a new entry in tab,{} declaring \spad{u} to be of type \spad{t}


kind: o
name: declare!
exposed: n
type: (List(Symbol),FortranType,Symbol,%)->FortranType
params: dTheSymbolTable
comment:
\spad{declare!(u,{} t,{} asp,{} tab)} declares the parameters \spad{u} of subprogram \spad{asp} to have type \spad{t} in symbol table tab.


kind: o
name: declare!
exposed: n
type: (Symbol,FortranType,Symbol,%)->FortranType
params: dTheSymbolTable
comment:
\spad{declare!(u,{} t,{} asp,{} tab)} declares the parameter \spad{u} of subprogram \spad{asp} to have type \spad{t} in symbol table tab.


kind: o
name: decompose
exposed: n
type: (Fraction(UP),(UP)->UP)->Record(poly:UP,normal:Fraction(UP),special:Fraction(UP))
params: pMonomialExtensionTools(F,UP)
comment:
\spad{decompose(f,{} D)} returns \spad{[p,{} n,{} s]} such that \spad{f = p+n+s},{} all the squarefree factors of \spad{denom(n)} are normal \spad{w}.\spad{r}.\spad{t}. \spad{D},{} \spad{denom(s)} is special \spad{w}.\spad{r}.\spad{t}. \spad{D},{} and \spad{n} and \spad{s} are proper fractions (no pole at infinity). \spad{D} is the derivation to use.


kind: o
name: decompose
exposed: n
type: (UP,List(UP))->List(UP)
params: pPartialFractionUtilities(F,UP)
comment:
\spad{decompose(n,{} [p1,{} ...,{} pn])} returns numerators of partial fraction decomposition of \spad{n} divided by product of \spad{pi}-\spad{s} Note: decomposition is assumed to have no whole part.


kind: o
name: decomposeFunc
exposed: n
params: pTransSolvePackageService(R)
type:
(Fraction(SparseUnivariatePolynomial(Expression(R))),Fraction(SparseUnivariatePolynomial(Expression(R))),Fraction(SparseUnivariatePolynomial(Expression(R))))->Fraction(SparseUnivariatePolynomial(Expression(R)))

comment:
\spad{decomposeFunc(func1,{} func2,{} newvar)} returns a function \spad{func3} where \spad{func1} = \spad{func3}(\spad{func2}) and expresses it in the new variable newvar. If there is no solution then \spad{func1} will be returned.


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


kind: o
name: decreasePrecision
exposed: x
type: (Integer)->PositiveInteger
params: cFloatingPointSystem
abbrev: has(%,arbitraryPrecision)
comment:
\spad{decreasePrecision(n)} decreases the current \spadfunFrom{precision}{FloatingPointSystem} precision by \spad{n} decimal digits.


kind: o
name: deductions
exposed: n
type: (List(%))->List(%)
params: dILogic
comment:
assumes \spad{ln} contains a list of factors which must be \spad{true} for the whole to be \spad{true} (such as the list produced by factor). From this deductions attempts to produce a list of other proposition that must also be \spad{true} by using modus ponens. This is used to determine the returned type when converting ILogic to types by using the Curry-Howard isomorphism.


kind: o
name: deepestInitial
exposed: x
type: (%)->%
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{deepestInitial(p)} returns an error if \spad{p} belongs to \spad{R},{} otherwise returns the last term of \spad{iteratedInitials(p)}.


kind: o
name: deepestTail
exposed: x
type: (%)->%
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{deepestTail(p)} returns \spad{0} if \spad{p} belongs to \spad{R},{} otherwise returns tail(\spad{p}),{} if \spad{tail(p)} belongs to \spad{R} or \spad{mvar(tail(p)) < mvar(p)},{} otherwise returns \spad{deepestTail(tail(p))}.


kind: o
name: defineProperty
exposed: n
type: (%,List(NonNegativeInteger),SubSpaceComponentProperty)->%
params: dSubSpace(n,R)
comment:
\spad{defineProperty(s,{} \spad{li},{} p)} defines the component property in the 3 dimensional subspace,{} \spad{s},{} to be that of \spad{p},{} where \spad{p} is of the domain \spadtype{SubSpaceComponentProperty}. The list of non negative integers,{} \spad{li},{} dictates the path to follow,{} or,{} to look at it another way,{} points to the component whose property is being defined. The subspace,{} \spad{s},{} is returned with the component property definition.


kind: o
name: definingEquations
exposed: n
type: (%)->List(Dpoly)
params: dQuasiAlgebraicSet(R,Var,Expon,Dpoly)
comment:
\spad{definingEquations(s)} returns a list of defining polynomials for equations,{} that is,{} for the Zariski closed part of \spad{s}.


kind: o
name: definingInequation
exposed: n
type: (%)->Dpoly
params: dQuasiAlgebraicSet(R,Var,Expon,Dpoly)
comment:
\spad{definingInequation(s)} returns a single defining polynomial for the inequation,{} that is,{} the Zariski open part of \spad{s}.


kind: o
name: definingPolynomial
exposed: n
type: (F)->F
params: pAlgebraicFunction(R,F)
abbrev: has(R,RetractableTo(Integer))
comment:
\spad{definingPolynomial(f)} returns the defining polynomial of \spad{f} as an element of \spad{F}. Error: if \spad{f} is not a kernel.


kind: o
name: definingPolynomial
exposed: x
type: (%)->ThePols
params: cRealRootCharacterizationCategory(TheField,ThePols)
comment:
\spad{definingPolynomial(aRoot)} gives a polynomial such that \spad{definingPolynomial(aRoot).aRoot = 0}


kind: o
name: degree
exposed: n
type: (%)->NonNegativeInteger
params: dExtAlgBasis
comment:
\spad{degree(x)} gives the numbers of 1\spad{'s} in \spad{x},{} \spadignore{i.e.} the number of non-zero exponents in the basis element that \spad{x} represents.


kind: o
name: degree
exposed: x
type: (%)->E
params: cGradedModule(R,E)
comment:
\spad{degree(g)} names the degree of \spad{g}. The set of all elements of a given degree form an \spad{R}-module.


kind: o
name: degree
exposed: x
type: (%)->Fraction(Integer)
params: cUnivariatePuiseuxSeriesConstructorCategory(Coef,ULS)
comment:
\spad{degree(f(x))} returns the degree of the leading term of the Puiseux series \spad{f(x)},{} which may have zero as a coefficient.


kind: o
name: degree
exposed: x
type: (%)->Integer
params: cUnivariateLaurentSeriesConstructorCategory(Coef,UTS)
comment:
\spad{degree(f(x))} returns the degree of the lowest order term of \spad{f(x)},{} which may have zero as a coefficient.


kind: o
name: degree
exposed: x
type: (%)->NonNegativeInteger
params: cXPolynomialsCat(vl,R)
comment:
\spad{degree(p)} returns the degree of \spad{p}. \indented{1}{Note that the degree of a word is its length.}


kind: o
name: degree
exposed: x
type: (%)->OnePointCompletion(PositiveInteger)
params: cExtensionField(F)
comment:
\spad{degree(a)} returns the degree of minimal polynomial of an element \spad{a} if \spad{a} is algebraic with respect to the ground field \spad{F},{} and \spad{infinity} otherwise.


kind: o
name: degree
exposed: x
type: (%)->PositiveInteger
params: cFiniteAlgebraicExtensionField(F)
comment:
\spad{degree(a)} returns the degree of the minimal polynomial of an element \spad{a} over the ground field \spad{F}.


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


kind: o
name: degree
exposed: n
type: (SparseUnivariatePolynomial(P),List(OV))->List(NonNegativeInteger)
params: pFactoringUtilities(E,OV,R,P)
comment:
\spad{degree(upoly,{} lvar)} returns a list containing the maximum degree for each variable in lvar.


kind: o
name: degree
exposed: n
type: (%,VarSet)->NonNegativeInteger
params: cMaybeSkewPolynomialCategory(R,E,VarSet)
comment:
\spad{degree(p,{} v)} gives the degree of polynomial \spad{p} with respect to the variable \spad{v}.


kind: o
name: degree
exposed: x
type: (%,S)->NonNegativeInteger
params: cDifferentialPolynomialCategory(R,S,V,E)
comment:
\spad{degree(p,{} s)} returns the maximum degree of the differential polynomial \spad{p} viewed as a differential polynomial in the differential indeterminate \spad{s} alone.


kind: o
name: degreePartition
exposed: n
type: (Factored(UP))->Multiset(NonNegativeInteger)
params: pGaloisGroupPolynomialUtilities(R,UP)
comment:
\spad{degreePartition(f)} returns the degree partition (\spadignore{i.e.} the multiset of the degrees of the irreducible factors) of the polynomial \spad{f}.


kind: o
name: degreePartition
exposed: n
type: (List(Record(factor:UP,degree:Integer)))->Multiset(NonNegativeInteger)
params: pGaloisGroupFactorizer(UP)
comment:
\spad{degreePartition(ddfactorization)} returns the degree partition of the polynomial \spad{f} modulo \spad{p} where \spad{ddfactorization} is the distinct degree factorization of \spad{f} computed by \spad{ddfact} from modular factorization package for some prime \spad{p}.


kind: o
name: degreeSubResultantEuclidean
exposed: n
type: (polR,polR,NonNegativeInteger)->Record(coef1:polR,coef2:polR,subResultant:polR)
params: pPseudoRemainderSequence(R,polR)
comment:
\spad{degreeSubResultantEuclidean(P,{} Q,{} d)} returns a subresultant \spad{S_i} of degree \spad{d} and carries out the equality \spad{coef1*P + coef2*Q = S_i}.


kind: o
name: dehomogenize
exposed: n
params: pLinearCombinationUtilities(F,UP)
type:
(List(Record(ratpart:F,coeffs:Vector(F))))->Record(particular:Union(Record(ratpart:F,coeffs:Vector(F)),failed),basis:List(Record(ratpart:F,coeffs:Vector(F))))

comment:
\spad{dehomogenize(ls)} converts list of solutions (a,{} [\spad{c0},{} \spad{c1},{} ...,{} \spad{cn}]) to homogeneous equation \spad{L}(a) + \spad{c0} \spad{f} + \spad{c1} \spad{g1} + ... + \spad{cn} \spad{gn} = 0 into list of solutions of inhomogeneous equation \spad{L}(a) + \spad{f} + \spad{c1} \spad{g1} + ... + \spad{cn} \spad{gn} = 0. This transformation works the same for all equations,{} so we only need list of solutions as argument


kind: o
name: delay
exposed: x
type: (()->%)->%
params: dStream(S)
comment:
\spad{delay(f)} creates a stream with a lazy evaluation defined by function \spad{f}. Caution: This function can only be called in compiled code.


kind: o
name: delete
exposed: x
type: (%,Integer)->%
params: cLinearAggregate(S)
comment:
\spad{delete(u,{} i)} returns a copy of \spad{u} with the \spad{i}th element deleted. Note: \spad{delete(u,{} i) = concat(u(minIndex(u)..i - 1),{} u(i + 1..))}.


kind: o
name: delete!
exposed: x
type: (%,UniversalSegment(Integer))->%
params: cExtensibleLinearAggregate(S)
comment:
\spad{delete!(u,{} i..j)} destructively deletes elements \spad{u}.\spad{i} through \spad{u}.\spad{j}.


kind: o
name: delete
exposed: x
type: (%,UniversalSegment(Integer))->%
params: cLinearAggregate(S)
comment:
\spad{delete(u,{} i..j)} returns a copy of \spad{u} with the \spad{i}th through \spad{j}th element deleted. Note: \spad{delete(u,{} i..j) = concat(u(minIndex(u)..i-1),{} u(j+1..))}.


kind: o
name: deleteProperty!
exposed: x
type: (%,Symbol)->%
params: dBasicOperator
comment:
\spad{deleteProperty!(op,{} s)} unattaches property \spad{s} from \spad{op}. Argument \spad{op} is modified in place,{} \spadignore{i.e.} no copy is made.


kind: o
name: delta
exposed: n
type: (%,PositiveInteger,PositiveInteger)->NonNegativeInteger
params: dSetOfMIntegersInOneToN(m,n)
comment:
\spad{delta(S,{} k,{} p)} returns the number of elements of \spad{S} which are strictly between \spad{p} and the \spad{k^}{th} element of \spad{S}.


kind: o
name: denom
exposed: x
type: (%)->SparseMultivariatePolynomial(Integer,Kernel(%))
params: dAlgebraicNumber
comment:
\spad{denom(f)} returns the denominator of \spad{f} viewed as a polynomial in the kernels over \spad{Z}.


kind: o
name: denom
exposed: x
type: (%)->SparseMultivariatePolynomial(R,K)
params: cFunctionSpace2(R,K)
abbrev: has(R,IntegralDomain)
comment:
\spad{denom(f)} returns the denominator of \spad{f} viewed as a polynomial in the kernels over \spad{R}.


kind: o
name: denominators
exposed: x
type: (%)->Stream(R)
params: dContinuedFraction(R)
comment:
\spad{denominators(x)} returns the stream of denominators 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: denomLODE
exposed: n
type: (L,Fraction(UP))->Union(UP,failed)
params: pPrimitiveRatDE(F,UP,L,LQ)
comment:
\spad{denomLODE(op,{} g)} returns a polynomial \spad{d} such that any rational solution of \spad{op y = g} is of the form \spad{p/d} for some polynomial \spad{p},{} and failed,{} if the equation has no rational solution.


kind: o
name: denomLODE
exposed: n
type: (L,List(Fraction(UP)))->UP
params: pPrimitiveRatDE(F,UP,L,LQ)
comment:
\spad{denomLODE(op,{} [g1,{} ...,{} gm])} returns a polynomial \spad{d} such that any rational solution of \spad{op y = c1 g1 + ... + cm gm} is of the form \spad{p/d} for some polynomial \spad{p}.


kind: o
name: denomRicDE
exposed: n
type: (L)->UP
params: pPrimitiveRatRicDE(F,UP,L,LQ)
comment:
\spad{denomRicDE(op)} returns a polynomial \spad{d} such that any rational solution of the associated Riccati equation of \spad{op y = 0} is of the form \spad{p/d + q'/q + r} for some polynomials \spad{p} and \spad{q} and a reduced \spad{r}. Also,{} \spad{deg(p) < deg(d)} and {\spad{gcd}(\spad{d},{} \spad{q}) = 1}.


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


kind: o
name: dequeue!
exposed: x
type: (%)->S
params: cQueueAggregate(S)
comment:
\spad{dequeue!(q)} destructively extracts the first (top) element from queue \spad{q}. The element previously second in the queue becomes the first element. Error: if \spad{q} is empty.


kind: o
name: deriv
exposed: n
type: (Stream(A))->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{deriv(a)} returns the derivative of the power series with respect to the power series variable. Thus \spad{deriv([a0,{} a1,{} a2,{} ...])} returns \spad{[a1,{} 2 a2,{} 3 a3,{} ...]}.


kind: o
name: derivative
exposed: x
type: (BasicOperator)->Union(List((List(A))->A),failed)
params: pBasicOperatorFunctions1(A)
comment:
\spad{derivative(op)} returns the value of the \%diff property of \spad{op} if it has one,{} and failed otherwise.


kind: o
name: derivative
exposed: x
type: (BasicOperator,(A)->A)->BasicOperator
params: pBasicOperatorFunctions1(A)
comment:
\spad{derivative(op,{} foo)} attaches foo as the \%diff property of \spad{op}. If \spad{op} has an \%diff property \spad{f},{} then applying a derivation \spad{D} to \spad{op}(a) returns \spad{f(a) * D(a)}. Argument \spad{op} must be unary.


kind: o
name: derivative
exposed: x
type: (BasicOperator,List((List(A))->A))->BasicOperator
params: pBasicOperatorFunctions1(A)
comment:
\spad{derivative(op,{} [foo1,{} ...,{} foon])} attaches [\spad{foo1},{} ...,{} foon] as the \%diff property of \spad{op}. If \spad{op} has an \%diff property \spad{[f1,{} ...,{} fn]} then applying a derivation \spad{D} to \spad{op(a1,{} ...,{} an)} returns \spad{f1(a1,{} ...,{} an) * D(a1) + ... + fn(a1,{} ...,{} an) * D(an)}.


kind: o
name: derivativeOf?
exposed: n
type: (%,%)->List(NonNegativeInteger)
params: cJetBundleCategory
comment:
\spad{derivativeOf?(jv1,{} jv2)} checks whether \spad{jv1} is a derivative of \spad{jv2}. In this case,{} the difference of their multi-indices is returned. Otherwise,{} an empty list is returned.


kind: o
name: destruct
exposed: n
type: (%)->List(Record(key:Symbol,entry:S))
params: dPatternMatchResult(R,S)
comment:
\spad{destruct(r)} returns the list of matches (var,{} expr) in \spad{r}. Error: if \spad{r} is a failed match.


kind: o
name: determinant
exposed: n
type: (M)->R
params: pInnerMatrixLinearAlgebraFunctions(R,Row,Col,M)
abbrev: has(R,Field)
comment:
\spad{determinant(m)} returns the determinant of the matrix \spad{m}. an error message is returned if the matrix is not square.


kind: o
name: determinant
exposed: x
type: (%)->R
params: cMatrixCategory(R,Row,Col)
abbrev: has(R,CommutativeRing)
comment:
\spad{determinant(m)} returns the determinant of the matrix \spad{m}. Error: if the matrix is not square.


kind: o
name: detSys
exposed: n
type: (List(JetBundleExpression(JB1)))->List(JetBundleExpression(JetBundleSymAna(JB1,xi,eta)))
params: pSymmetryAnalysis(JB1,xi,eta)
comment:
\spad{detSys(sys)} computes the determining system for symmetry generators of the system \spad{sys}. It is assumed that each equation can be solved for its leading derivative.


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

comment:
\spad{detSys(sys,{} vf)} computes the determining system for symmetry generators of the system \spad{sys} with a given ansatz for the generators. It is assumed that each equation can be solved for its leading derivative.


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

comment:
\spad{detSys(sys,{} sjb,{} vf)} computes the determining system for symmetry generators of the system \spad{sys} with a given ansatz for the generators. \spad{sjb} contains jet variables for which the individual equations can be solved.


kind: o
name: detSysNS
exposed: n
type: (List(JetBundleExpression(JB1)))->List(JetBundleExpression(JetBundleSymAna(JB1,xi,eta)))
params: pSymmetryAnalysis(JB1,xi,eta)
comment:
\spad{detSysNS(sys,{} vf)} computes the determining system for symmetry generators without assuming solvability of the equations for some derivatives.


kind: o
name: diagonal?
exposed: x
type: (%)->Boolean
params: cMatrixCategory(R,Row,Col)
comment:
\spad{diagonal?(m)} returns \spad{true} if the matrix \spad{m} is square and diagonal (\spadignore{i.e.} all entries of \spad{m} not on the diagonal are zero) and \spad{false} otherwise.


kind: o
name: diagonalMatrix
exposed: n
type: (M)->M
params: pMatrixManipulation(R,Row,Col,M)
abbrev: has(R,AbelianMonoid)
comment:
\spad{diagonalMatrix} returns the main diagonal out of a matrix. The diagonal is put into a matrix of same shape as the original one.


kind: o
name: diagonalMatrix
exposed: x
type: (List(%))->%
params: cMatrixCategory(R,Row,Col)
comment:
\spad{diagonalMatrix([m1,{} ...,{} mk])} creates a block diagonal matrix \spad{M} with block matrices {\em m1},{} ...,{} {\em mk} down the diagonal,{} with 0 block matrices elsewhere. More precisely: if \spad{\spad{ri} := nrows \spad{mi}},{} \spad{\spad{ci} := ncols \spad{mi}},{} then \spad{m} is an (\spad{r1+}..\spad{+rk}) by (\spad{c1+}..\spad{+ck}) - matrix with entries \spad{m.i.j = ml.(i-r1-..-r(l-1)).(j-n1-..-n(l-1))},{} if \spad{(r1+..+r(l-1)) < i <= r1+..+rl} and \spad{(c1+..+c(l-1)) < i <= c1+..+cl},{} \spad{m.i.j} = 0 otherwise.


kind: o
name: diagonalMatrix
exposed: x
type: (Vector(R))->%
params: dMatrix(R)
comment:
\spad{diagonalMatrix(v)} returns a diagonal matrix where the elements of \spad{v} appear on the diagonal.


kind: o
name: diagonalMatrix
exposed: n
type: (M,Integer)->M
params: pMatrixManipulation(R,Row,Col,M)
abbrev: has(R,AbelianMonoid)
comment:
\spad{diagonalMatrix} returns a diagonal out of a matrix. The diagonal is put into a matrix of same shape as the original one. Positive integer arguments select upper off-diagonals,{} negative ones lower off-diagonals.


kind: o
name: diagonalProduct
exposed: n
type: (Matrix(R))->R
params: pIntegralBasisTools(R,UP,F)
comment:
\spad{diagonalProduct(m)} returns the product of the elements on the diagonal of the matrix \spad{m}


kind: o
name: diagonalProduct
exposed: x
type: (%)->R
params: cSquareMatrixCategory(ndim,R,Row,Col)
comment:
\spad{diagonalProduct(m)} returns the product of the elements on the diagonal of the matrix \spad{m}.


kind: o
name: diagonals
exposed: x
type: (%,String)->Void
params: dThreeDimensionalViewport
comment:
\spad{diagonals(v,{} s)} displays the diagonals of the polygon outline showing a triangularized surface instead of a quadrilateral surface outline,{} for the given three-dimensional viewport \spad{v} which is of domain \spadtype{ThreeDimensionalViewport},{} if \spad{s} is on,{} or does not display the diagonals if \spad{s} is off.


kind: o
name: diagramHeight
exposed: n
type: (%)->NonNegativeInteger
params: cFiniteGraph(S)
comment:
\spad{diagramHeight(s)} returns the height of the diagram that will be generated by diagramSvg. This is the maximum posY of all vertices in graph \spad{s}


kind: o
name: diagramsSvg
exposed: n
type: (String,List(%),Boolean)->Void
params: cFiniteGraph(S)
comment:
creates \spad{SVG} diagram containing multiple graphs fileName: String is the name of the \spad{SVG} file that will be created \spad{ln:} List \% is list of graphs that will be written dispArrowName: Boolean is \spad{true} to include the name of each arrow


kind: o
name: diagramSvg2
exposed: n
type: (String,%,Boolean)->Void
params: dUndirectedGraph(S)
comment:
diagramSvg(fileName,{} \spad{n},{} dispArrowName) creates an \spad{SVG} diagram. This is an alternative version which does not shorten lines. fileName: String is the name of the \spad{SVG} file that will be created \spad{n:} \% is the graph that will be written dispArrowName: Boolean is \spad{true} to include the name of each arrow


kind: o
name: diagramSvg
exposed: n
type: (String,%,Boolean)->Void
params: cFiniteGraph(S)
comment:
\spad{diagramSvg(fileName,{} n,{} dispArrowName)} creates an \spad{SVG} diagram fileName: String is the name of the \spad{SVG} file that will be created \spad{n:} \% is the graph that will be written dispArrowName: Boolean is \spad{true} to include the name of each arrow


kind: o
name: diagramWidth
exposed: n
type: (%)->NonNegativeInteger
params: cFiniteGraph(S)
comment:
\spad{diagramWidth(s)} returns the width of the diagram that will be generated by diagramSvg. This is the maximum posX of all vertices in graph \spad{s}


kind: o
name: dictionary
exposed: x
type: (List(S))->%
params: cDictionaryOperations(S)
comment:
\spad{dictionary([x,{} y,{} ...,{} z])} creates a dictionary consisting of entries \spad{x,{} y,{} ...,{} z}.


kind: o
name: DiffAction
exposed: n
type: (NonNegativeInteger,NonNegativeInteger,V)->D
params: pFractionFreeFastGaussian(D,V)
comment:
\spad{DiffAction(k,{} l,{} g)} gives the coefficient of \spad{x^k} in \spad{z^l} \spad{g}(\spad{x}),{} where \spad{z*}(a+b*x+c*x^2+d*x^3+...) = (a*x+b*x^2+c*x^3+...),{} \spadignore{i.e.} multiplication with \spad{x}.


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


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


kind: o
name: difference
exposed: x
type: (%,S)->%
params: cSetAggregate(S)
comment:
\spad{difference(u,{} x)} returns the set aggregate \spad{u} with element \spad{x} removed. If \spad{u} does not contain \spad{x},{} a copy of \spad{u} is returned. Note: \spad{difference(s,{} x) = difference(s,{} set [x])}.


kind: o
name: differentialVariables
exposed: x
type: (%)->List(S)
params: cDifferentialPolynomialCategory(R,S,V,E)
comment:
\spad{differentialVariables(p)} returns a list of differential indeterminates occurring in a differential polynomial \spad{p}.


kind: o
name: differentiate
exposed: x
type: (%)->%
params: cDifferentialRing
comment:
\spad{differentiate(x)} returns the derivative of \spad{x}. This function is a simple differential operator where no variable needs to be specified.


kind: o
name: differentiate
exposed: n
type: (%,JB)->%
params: cJetBundleFunctionCategory(JB)
comment:
\spad{differentiate(f,{} jv)} differentiates the function \spad{f} \spad{wrt} the jet variable \spad{jv}.


kind: o
name: differentiate
exposed: n
type: (%,NonNegativeInteger)->%
params: dOutputForm
comment:
\spad{differentiate(f,{} n)} creates a form for the \spad{n}th derivative of \spad{f},{} \spadignore{e.g.} \spad{f'},{} \spad{f''},{} \spad{f'''},{} \spad{f} super \spad{iv}.


kind: o
name: differentiate
exposed: n
type: (%,PositiveInteger)->Union(%,0)
params: cJetBundleCategory
comment:
\spad{differentiate(jv,{} i)} differentiates \spad{jv} \spad{wrt} the \spad{i}\spad{-}th independent variable.


kind: o
name: differentiate
exposed: x
type: (%,List(S))->%
params: cPartialDifferentialRing(S)
comment:
\spad{differentiate(x,{} [s1,{} ...sn])} computes successive partial derivatives,{} \spadignore{i.e.} \spad{differentiate(...differentiate(x,{} s1)...,{} sn)}.


kind: o
name: differentiate
exposed: x
type: (%,(R)->R)->%
params: cDifferentialExtension(R)
comment:
\spad{differentiate(x,{} deriv)} differentiates \spad{x} extending the derivation deriv on \spad{R}.


kind: o
name: differentiate
exposed: x
type: (%,(UP)->UP)->%
params: cFunctionFieldCategory(F,UP,UPUP)
comment:
\spad{differentiate(x,{} d)} extends the derivation \spad{d} from UP to \$ and applies it to \spad{x}.


kind: o
name: differentiate
exposed: x
type: (%,List(S),List(NonNegativeInteger))->%
params: cPartialDifferentialRing(S)
comment:
\spad{differentiate(x,{} [s1,{} ...,{} sn],{} [n1,{} ...,{} nn])} computes multiple partial derivatives,{} \spadignore{i.e.}


kind: o
name: differentiate
exposed: x
type: (%,(R)->R,%)->%
params: cUnivariatePolynomialCategory(R)
abbrev: has(R,Ring)
comment:
\spad{differentiate(p,{} d,{} x')} extends the \spad{R}-derivation \spad{d} to an extension \spad{D} in \spad{R[x]} where \spad{Dx} is given by \spad{x'},{} and returns \spad{Dp}.


kind: o
name: differentiate
exposed: x
type: (%,(R)->R,NonNegativeInteger)->%
params: cDifferentialExtension(R)
comment:
\spad{differentiate(x,{} deriv,{} n)} differentiate \spad{x} \spad{n} times using a derivation which extends \spad{deriv} on \spad{R}.


kind: o
name: differentiate
exposed: x
type: (%,S,NonNegativeInteger)->%
params: cPartialDifferentialRing(S)
comment:
\spad{differentiate(x,{} s,{} n)} computes multiple partial derivatives,{} \spadignore{i.e.} \spad{n}-th derivative of \spad{x} with respect to \spad{s}.


kind: o
name: diffextint
exposed: n
params: pParametricTranscendentalIntegration(F,UP)
type:
((List(UP))->List(Record(ratpart:F,coeffs:Vector(F))),(Matrix(F))->List(Vector(F)),List(Fraction(UP)))->List(Record(ratpart:F,coeffs:Vector(F)))

comment:
\spad{diffextint(ext,{} csolve,{} [g1,{} ...,{} gn])} is like primextint and expextint but for differentialy transcendental extensions.


kind: o
name: diffHP
exposed: n
params: pGuessAlgebraicNumber
type:
(List(GuessOption))->Record(degreeStream:Stream(NonNegativeInteger),guessStream:(UnivariateFormalPowerSeries(AlgebraicNumber))->Stream(UnivariateFormalPowerSeries(AlgebraicNumber)),guessModGen:(NonNegativeInteger)->(List(U32Vector),Integer,Integer)->Vector(U32Vector),testGen:(List(PositiveInteger))->(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(AlgebraicNumber,NonNegativeInteger)))->Vector(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(AlgebraicNumber,NonNegativeInteger))),exprStream:(Expression(Integer),Symbol)->Stream(Expression(Integer)),kind:Symbol,qvar:Symbol,A:(NonNegativeInteger,NonNegativeInteger,SparseUnivariatePolynomial(AlgebraicNumber))->AlgebraicNumber,AF:(NonNegativeInteger,NonNegativeInteger,UnivariateFormalPowerSeries(SparseMultivariatePolynomial(AlgebraicNumber,NonNegativeInteger)))->SparseMultivariatePolynomial(AlgebraicNumber,NonNegativeInteger),AX:(NonNegativeInteger,Symbol,Expression(Integer))->Expression(Integer),C:(NonNegativeInteger)->List(AlgebraicNumber))


kind: o
name: diffHP
exposed: n
params: pGuessAlgebraicNumber
abbrev: has(AlgebraicNumber,RetractableTo(Symbol))
type:
(Symbol)->(List(GuessOption))->Record(degreeStream:Stream(NonNegativeInteger),guessStream:(UnivariateFormalPowerSeries(AlgebraicNumber))->Stream(UnivariateFormalPowerSeries(AlgebraicNumber)),guessModGen:(NonNegativeInteger)->(List(U32Vector),Integer,Integer)->Vector(U32Vector),testGen:(List(PositiveInteger))->(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(AlgebraicNumber,NonNegativeInteger)))->Vector(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(AlgebraicNumber,NonNegativeInteger))),exprStream:(Expression(Integer),Symbol)->Stream(Expression(Integer)),kind:Symbol,qvar:Symbol,A:(NonNegativeInteger,NonNegativeInteger,SparseUnivariatePolynomial(AlgebraicNumber))->AlgebraicNumber,AF:(NonNegativeInteger,NonNegativeInteger,UnivariateFormalPowerSeries(SparseMultivariatePolynomial(AlgebraicNumber,NonNegativeInteger)))->SparseMultivariatePolynomial(AlgebraicNumber,NonNegativeInteger),AX:(NonNegativeInteger,Symbol,Expression(Integer))->Expression(Integer),C:(NonNegativeInteger)->List(AlgebraicNumber))


kind: o
name: diffHP
exposed: x
params: pGuessInteger
type:
(List(GuessOption))->Record(degreeStream:Stream(NonNegativeInteger),guessStream:(UnivariateFormalPowerSeries(Fraction(Integer)))->Stream(UnivariateFormalPowerSeries(Fraction(Integer))),guessModGen:(NonNegativeInteger)->(List(U32Vector),Integer,Integer)->Vector(U32Vector),testGen:(List(PositiveInteger))->(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(Fraction(Integer),NonNegativeInteger)))->Vector(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(Fraction(Integer),NonNegativeInteger))),exprStream:(Expression(Integer),Symbol)->Stream(Expression(Integer)),kind:Symbol,qvar:Symbol,A:(NonNegativeInteger,NonNegativeInteger,SparseUnivariatePolynomial(Integer))->Integer,AF:(NonNegativeInteger,NonNegativeInteger,UnivariateFormalPowerSeries(SparseMultivariatePolynomial(Fraction(Integer),NonNegativeInteger)))->SparseMultivariatePolynomial(Fraction(Integer),NonNegativeInteger),AX:(NonNegativeInteger,Symbol,Expression(Integer))->Expression(Integer),C:(NonNegativeInteger)->List(Integer))


kind: o
name: diffHP
exposed: x
params: pGuessPolynomialInteger
type:
(List(GuessOption))->Record(degreeStream:Stream(NonNegativeInteger),guessStream:(UnivariateFormalPowerSeries(Fraction(Polynomial(Integer))))->Stream(UnivariateFormalPowerSeries(Fraction(Polynomial(Integer)))),guessModGen:(NonNegativeInteger)->(List(U32Vector),Integer,Integer)->Vector(U32Vector),testGen:(List(PositiveInteger))->(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(Fraction(Polynomial(Integer)),NonNegativeInteger)))->Vector(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(Fraction(Polynomial(Integer)),NonNegativeInteger))),exprStream:(Expression(Integer),Symbol)->Stream(Expression(Integer)),kind:Symbol,qvar:Symbol,A:(NonNegativeInteger,NonNegativeInteger,SparseUnivariatePolynomial(Polynomial(Integer)))->Polynomial(Integer),AF:(NonNegativeInteger,NonNegativeInteger,UnivariateFormalPowerSeries(SparseMultivariatePolynomial(Fraction(Polynomial(Integer)),NonNegativeInteger)))->SparseMultivariatePolynomial(Fraction(Polynomial(Integer)),NonNegativeInteger),AX:(NonNegativeInteger,Symbol,Expression(Integer))->Expression(Integer),C:(NonNegativeInteger)->List(Polynomial(Integer)))


kind: o
name: diffHP
exposed: x
params: pGuessPolynomial(R)
type:
(List(GuessOption))->Record(degreeStream:Stream(NonNegativeInteger),guessStream:(UnivariateFormalPowerSeries(Fraction(Polynomial(R))))->Stream(UnivariateFormalPowerSeries(Fraction(Polynomial(R)))),guessModGen:(NonNegativeInteger)->(List(U32Vector),Integer,Integer)->Vector(U32Vector),testGen:(List(PositiveInteger))->(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(Fraction(Polynomial(R)),NonNegativeInteger)))->Vector(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(Fraction(Polynomial(R)),NonNegativeInteger))),exprStream:(Expression(Integer),Symbol)->Stream(Expression(Integer)),kind:Symbol,qvar:Symbol,A:(NonNegativeInteger,NonNegativeInteger,SparseUnivariatePolynomial(Polynomial(R)))->Polynomial(R),AF:(NonNegativeInteger,NonNegativeInteger,UnivariateFormalPowerSeries(SparseMultivariatePolynomial(Fraction(Polynomial(R)),NonNegativeInteger)))->SparseMultivariatePolynomial(Fraction(Polynomial(R)),NonNegativeInteger),AX:(NonNegativeInteger,Symbol,Expression(Integer))->Expression(Integer),C:(NonNegativeInteger)->List(Polynomial(R)))


kind: o
name: diffHP
exposed: x
params: pGuessFinite(F)
type:
(List(GuessOption))->Record(degreeStream:Stream(NonNegativeInteger),guessStream:(UnivariateFormalPowerSeries(F))->Stream(UnivariateFormalPowerSeries(F)),guessModGen:(NonNegativeInteger)->(List(U32Vector),Integer,Integer)->Vector(U32Vector),testGen:(List(PositiveInteger))->(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(F,NonNegativeInteger)))->Vector(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(F,NonNegativeInteger))),exprStream:(Expression(Integer),Symbol)->Stream(Expression(Integer)),kind:Symbol,qvar:Symbol,A:(NonNegativeInteger,NonNegativeInteger,SparseUnivariatePolynomial(F))->F,AF:(NonNegativeInteger,NonNegativeInteger,UnivariateFormalPowerSeries(SparseMultivariatePolynomial(F,NonNegativeInteger)))->SparseMultivariatePolynomial(F,NonNegativeInteger),AX:(NonNegativeInteger,Symbol,Expression(Integer))->Expression(Integer),C:(NonNegativeInteger)->List(F))


kind: o
name: diffHP
exposed: x
params: pGuess(F,S,EXPRR,retract,coerce)
type:
(List(GuessOption))->Record(degreeStream:Stream(NonNegativeInteger),guessStream:(UnivariateFormalPowerSeries(F))->Stream(UnivariateFormalPowerSeries(F)),guessModGen:(NonNegativeInteger)->(List(U32Vector),Integer,Integer)->Vector(U32Vector),testGen:(List(PositiveInteger))->(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(F,NonNegativeInteger)))->Vector(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(F,NonNegativeInteger))),exprStream:(EXPRR,Symbol)->Stream(EXPRR),kind:Symbol,qvar:Symbol,A:(NonNegativeInteger,NonNegativeInteger,SparseUnivariatePolynomial(S))->S,AF:(NonNegativeInteger,NonNegativeInteger,UnivariateFormalPowerSeries(SparseMultivariatePolynomial(F,NonNegativeInteger)))->SparseMultivariatePolynomial(F,NonNegativeInteger),AX:(NonNegativeInteger,Symbol,EXPRR)->EXPRR,C:(NonNegativeInteger)->List(S))

comment:
\spad{diffHP options} returns a specification for Hermite-Pade approximation with the differential operator


kind: o
name: diffHP
exposed: x
params: pGuessInteger
abbrev: AND(has(Fraction(Integer),RetractableTo(Symbol)),has(Integer,RetractableTo(Symbol)))
type:
(Symbol)->(List(GuessOption))->Record(degreeStream:Stream(NonNegativeInteger),guessStream:(UnivariateFormalPowerSeries(Fraction(Integer)))->Stream(UnivariateFormalPowerSeries(Fraction(Integer))),guessModGen:(NonNegativeInteger)->(List(U32Vector),Integer,Integer)->Vector(U32Vector),testGen:(List(PositiveInteger))->(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(Fraction(Integer),NonNegativeInteger)))->Vector(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(Fraction(Integer),NonNegativeInteger))),exprStream:(Expression(Integer),Symbol)->Stream(Expression(Integer)),kind:Symbol,qvar:Symbol,A:(NonNegativeInteger,NonNegativeInteger,SparseUnivariatePolynomial(Integer))->Integer,AF:(NonNegativeInteger,NonNegativeInteger,UnivariateFormalPowerSeries(SparseMultivariatePolynomial(Fraction(Integer),NonNegativeInteger)))->SparseMultivariatePolynomial(Fraction(Integer),NonNegativeInteger),AX:(NonNegativeInteger,Symbol,Expression(Integer))->Expression(Integer),C:(NonNegativeInteger)->List(Integer))


kind: o
name: diffHP
exposed: x
params: pGuessPolynomialInteger
type:
(Symbol)->(List(GuessOption))->Record(degreeStream:Stream(NonNegativeInteger),guessStream:(UnivariateFormalPowerSeries(Fraction(Polynomial(Integer))))->Stream(UnivariateFormalPowerSeries(Fraction(Polynomial(Integer)))),guessModGen:(NonNegativeInteger)->(List(U32Vector),Integer,Integer)->Vector(U32Vector),testGen:(List(PositiveInteger))->(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(Fraction(Polynomial(Integer)),NonNegativeInteger)))->Vector(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(Fraction(Polynomial(Integer)),NonNegativeInteger))),exprStream:(Expression(Integer),Symbol)->Stream(Expression(Integer)),kind:Symbol,qvar:Symbol,A:(NonNegativeInteger,NonNegativeInteger,SparseUnivariatePolynomial(Polynomial(Integer)))->Polynomial(Integer),AF:(NonNegativeInteger,NonNegativeInteger,UnivariateFormalPowerSeries(SparseMultivariatePolynomial(Fraction(Polynomial(Integer)),NonNegativeInteger)))->SparseMultivariatePolynomial(Fraction(Polynomial(Integer)),NonNegativeInteger),AX:(NonNegativeInteger,Symbol,Expression(Integer))->Expression(Integer),C:(NonNegativeInteger)->List(Polynomial(Integer)))

abbrev:
AND(has(Fraction(Polynomial(Integer)),RetractableTo(Symbol)),has(Polynomial(Integer),RetractableTo(Symbol)))


kind: o
name: diffHP
exposed: x
params: pGuessPolynomial(R)
abbrev: AND(has(Fraction(Polynomial(R)),RetractableTo(Symbol)),has(Polynomial(R),RetractableTo(Symbol)))
type:
(Symbol)->(List(GuessOption))->Record(degreeStream:Stream(NonNegativeInteger),guessStream:(UnivariateFormalPowerSeries(Fraction(Polynomial(R))))->Stream(UnivariateFormalPowerSeries(Fraction(Polynomial(R)))),guessModGen:(NonNegativeInteger)->(List(U32Vector),Integer,Integer)->Vector(U32Vector),testGen:(List(PositiveInteger))->(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(Fraction(Polynomial(R)),NonNegativeInteger)))->Vector(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(Fraction(Polynomial(R)),NonNegativeInteger))),exprStream:(Expression(Integer),Symbol)->Stream(Expression(Integer)),kind:Symbol,qvar:Symbol,A:(NonNegativeInteger,NonNegativeInteger,SparseUnivariatePolynomial(Polynomial(R)))->Polynomial(R),AF:(NonNegativeInteger,NonNegativeInteger,UnivariateFormalPowerSeries(SparseMultivariatePolynomial(Fraction(Polynomial(R)),NonNegativeInteger)))->SparseMultivariatePolynomial(Fraction(Polynomial(R)),NonNegativeInteger),AX:(NonNegativeInteger,Symbol,Expression(Integer))->Expression(Integer),C:(NonNegativeInteger)->List(Polynomial(R)))


kind: o
name: diffHP
exposed: x
params: pGuessFinite(F)
abbrev: has(F,RetractableTo(Symbol))
type:
(Symbol)->(List(GuessOption))->Record(degreeStream:Stream(NonNegativeInteger),guessStream:(UnivariateFormalPowerSeries(F))->Stream(UnivariateFormalPowerSeries(F)),guessModGen:(NonNegativeInteger)->(List(U32Vector),Integer,Integer)->Vector(U32Vector),testGen:(List(PositiveInteger))->(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(F,NonNegativeInteger)))->Vector(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(F,NonNegativeInteger))),exprStream:(Expression(Integer),Symbol)->Stream(Expression(Integer)),kind:Symbol,qvar:Symbol,A:(NonNegativeInteger,NonNegativeInteger,SparseUnivariatePolynomial(F))->F,AF:(NonNegativeInteger,NonNegativeInteger,UnivariateFormalPowerSeries(SparseMultivariatePolynomial(F,NonNegativeInteger)))->SparseMultivariatePolynomial(F,NonNegativeInteger),AX:(NonNegativeInteger,Symbol,Expression(Integer))->Expression(Integer),C:(NonNegativeInteger)->List(F))


kind: o
name: diffHP
exposed: x
params: pGuess(F,S,EXPRR,retract,coerce)
abbrev: AND(has(F,RetractableTo(Symbol)),has(S,RetractableTo(Symbol)))
type:
(Symbol)->(List(GuessOption))->Record(degreeStream:Stream(NonNegativeInteger),guessStream:(UnivariateFormalPowerSeries(F))->Stream(UnivariateFormalPowerSeries(F)),guessModGen:(NonNegativeInteger)->(List(U32Vector),Integer,Integer)->Vector(U32Vector),testGen:(List(PositiveInteger))->(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(F,NonNegativeInteger)))->Vector(UnivariateFormalPowerSeries(SparseMultivariatePolynomial(F,NonNegativeInteger))),exprStream:(EXPRR,Symbol)->Stream(EXPRR),kind:Symbol,qvar:Symbol,A:(NonNegativeInteger,NonNegativeInteger,SparseUnivariatePolynomial(S))->S,AF:(NonNegativeInteger,NonNegativeInteger,UnivariateFormalPowerSeries(SparseMultivariatePolynomial(F,NonNegativeInteger)))->SparseMultivariatePolynomial(F,NonNegativeInteger),AX:(NonNegativeInteger,Symbol,EXPRR)->EXPRR,C:(NonNegativeInteger)->List(S))

comment:
\spad{diffHP options} returns a specification for Hermite-Pade approximation with the \$\spad{q}\$-dilation operator


kind: o
name: digamma
exposed: x
type: (%)->%
params: cSpecialFunctionCategory
comment:
\spad{digamma(x)} is the logarithmic derivative of \spad{Gamma(x)} (often written \spad{psi(x)} in the literature).


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


kind: o
name: dihedralGroup
exposed: n
type: (PositiveInteger)->%
params: dGroupPresentation
comment:
\spad{dihedralGroup(n)} constructs the dihedral group of order 2n acting on integers 1,{} ...,{} \spad{N}.


kind: o
name: dihedralGroup
exposed: x
type: (List(Integer))->PermutationGroup(Integer)
params: pPermutationGroupExamples
comment:
\spad{dihedralGroup([i1,{} ...,{} ik])} constructs the dihedral group of order 2k acting on the integers out of {\em i1},{} ...,{} {\em ik}. Note: duplicates in the list will be removed.


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


kind: o
name: dimension
exposed: x
type: (%)->Integer
params: dPolynomialIdeal(F,Expon,VarSet,DPoly)
comment:
\spad{dimension(I)} gives the dimension of the ideal \spad{I}. in the ring \spad{F[lvar]},{} where lvar are the variables appearing in \spad{I}


kind: o
name: dimension
exposed: n
type: (%,NonNegativeInteger)->NonNegativeInteger
params: dJetDifferentialEquation(JB,D)
comment:
\spad{dimension(de,{} q)} computes the dimension of the differential equation \spad{de} as a submanifold of the \spad{q}\spad{-}th order jet bundle. The result is correct only,{} if \spad{de} is simplified.


kind: o
name: dimension
exposed: n
type: (List(%),SparseEchelonMatrix(JB,%),NonNegativeInteger)->NonNegativeInteger
params: cJetBundleFunctionCategory(JB)
comment:
\spad{dimension(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}.


kind: o
name: dimensionOfIrreducibleRepresentation
exposed: x
type: (List(Integer))->NonNegativeInteger
params: pIrrRepSymNatPackage
comment:
\spad{dimensionOfIrreducibleRepresentation(lambda)} is the dimension of the ordinary irreducible representation of the symmetric group corresponding to {\em lambda}. Note: the Robinson-Thrall hook formula is implemented.


kind: o
name: dimensions
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger,PositiveInteger,PositiveInteger)->Void
params: dTwoDimensionalViewport
comment:
\spad{dimensions(v,{} x,{} y,{} width,{} height)} sets the position of the upper left-hand corner of the two-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{TwoDimensionalViewport},{} to the window coordinate \spad{x},{} \spad{y},{} and sets the dimensions of the window to that of \spad{width},{} \spad{height}. The new dimensions are not displayed until the function \spadfun{makeViewport2D} is executed again for \spad{v}.


kind: o
name: dimensions
exposed: x
type: (%,NonNegativeInteger,NonNegativeInteger,PositiveInteger,PositiveInteger)->Void
params: dThreeDimensionalViewport
comment:
\spad{dimensions(v,{} x,{} y,{} width,{} height)} sets the position of the upper left-hand corner of the three-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{ThreeDimensionalViewport},{} to the window coordinate \spad{x},{} \spad{y},{} and sets the dimensions of the window to that of \spad{width},{} \spad{height}. The new dimensions are not displayed until the function \spadfun{makeViewport3D} is executed again for \spad{v}.


kind: o
name: dimS
exposed: n
type: (NonNegativeInteger)->NonNegativeInteger
params: cJetBundleCategory
comment:
\spad{dimS(q)} computes dimension of \spad{SqT} \spad{x} VE (= number of derivatives of order \spad{q}).


kind: o
name: diophantineSystem
exposed: x
type: (M,Col)->Record(particular:Union(Col,failed),basis:List(Col))
params: pSmithNormalForm(R,Row,Col,M)
comment:
\spad{diophantineSystem(A,{} B)} returns a particular integer solution and an integer basis of the equation \spad{A X = B}.


kind: o
name: dioSolve
exposed: x
params: pDiophantineSolutionPackage
type:
(Equation(Polynomial(Integer)))->Record(varOrder:List(Symbol),inhom:Union(List(Vector(NonNegativeInteger)),failed),hom:List(Vector(NonNegativeInteger)))

comment:
\spad{dioSolve(u)} computes a basis of all minimal solutions for linear homogeneous Diophantine equation \spad{u},{} then all minimal solutions of inhomogeneous equation


kind: o
name: directedGraph
exposed: n
type: (FinitePoset(S))->%
params: dDirectedGraph(S)
comment:
\spad{directedGraph(poset)} constructs graph from a partially ordered set. This will be a graph with,{} at most,{} one arrow between any two nodes.


kind: o
name: directedGraph
exposed: n
type: (List(Record(value:S,posX:NonNegativeInteger,posY:NonNegativeInteger)))->%
params: dDirectedGraph(S)
comment:
\spad{directedGraph(ob)} is a constructor for graph with given objects \spad{ob},{} more objects and arrows can be added later if required.


kind: o
name: directedGraph
exposed: n
type: (List(S))->%
params: dDirectedGraph(S)
comment:
\spad{directedGraph(ob)} is a constructor for graph with given list of object names and no arrows. Use this version of the constructor if you don\spad{'t} want to create specific \spad{x},{} \spad{y} coordinates. more objects and arrows can be added later if required.


kind: o
name: directedGraph
exposed: n
params: dDirectedGraph(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{directedGraph(ob,{} ar)} constructs graph with objects \spad{ob} and arrows ar,{} more objects and arrows can be added later if required.


kind: o
name: directedGraph
exposed: n
type: (List(S),List(Record(fromOb:NonNegativeInteger,toOb:NonNegativeInteger)))->%
params: dDirectedGraph(S)
comment:
\spad{directedGraph(obs,{} ars)} constructs graph with objects \spad{obs} and arrows ars. This constructor just has pure abstract graph information without decoration information.


kind: o
name: directions
exposed: n
type: (%)->List(JB)
params: dJetVectorField(JB,D)
comment:
\spad{directions(v)} yields the directions of the base vectors where \spad{v} has non-vanishing coefficients.


kind: o
name: directProduct
exposed: x
type: (Vector(R))->%
params: cDirectProductCategory(dim,R)
comment:
\spad{directProduct(v)} converts the vector \spad{v} to a direct product. Error: if the length of \spad{v} is different from dim.


kind: o
name: directSum
exposed: x
type: (%,%)->%
params: cLinearOrdinaryDifferentialOperatorCategory(A)
abbrev: has(A,Field)
comment:
\spad{directSum(a,{} b)} computes an operator \spad{c} of minimal order such that the nullspace of \spad{c} is generated by all the sums of a solution of \spad{a} by a solution of \spad{b}.


kind: o
name: directSum
exposed: n
type: (L,L,(A)->A)->L
params: pLinearOrdinaryDifferentialOperatorsOps(A,L)
comment:
\spad{directSum(a,{} b,{} D)} computes an operator \spad{c} of minimal order such that the nullspace of \spad{c} is generated by all the sums of a solution of \spad{a} by a solution of \spad{b}. \spad{D} is the derivation to use.


kind: o
name: discreteLog
exposed: x
type: (%)->NonNegativeInteger
params: cFiniteFieldCategory
comment:
\spad{discreteLog(a)} computes the discrete logarithm of \spad{a} with respect to \spad{primitiveElement()} of the field.


kind: o
name: discriminant
exposed: n
type: ()->Integer
params: pNumberFieldIntegralBasis(UP,F)
comment:
\spad{discriminant()} returns the discriminant of the integral closure of \spad{Z} in the quotient field of the framed algebra \spad{F}.


kind: o
name: discriminant
exposed: x
type: (%,VarSet)->%
params: cPolynomialCategory(R,E,VarSet)
abbrev: has(R,CommutativeRing)
comment:
\spad{discriminant(p,{} v)} returns the disriminant of the polynomial \spad{p} with respect to the variable \spad{v}.


kind: o
name: discriminantEuclidean
exposed: n
type: (polR)->Record(coef1:polR,coef2:polR,discriminant:R)
params: pPseudoRemainderSequence(R,polR)
comment:
\spad{discriminantEuclidean(P)} carries out the equality \spad{coef1 * P + coef2 * D(P) = discriminant(P)}.


kind: o
name: display
exposed: n
type: (Record(rows:List(FreeMonoid(VAR)),cols:List(FreeMonoid(VAR)),H:Matrix(F)))->OutputForm
params: pXDistributedPolynomialFunctions(VAR,F)
comment:
\spad{display(sys)} prints the Hankel matrix in an extended form with row-indices as column 0 and column-indices as row 0.


kind: o
name: display
exposed: n
type: (%)->Void
params: dJetDifferentialEquation(JB,D)
comment:
\spad{display(de)} prints all information stored about the differential equation \spad{de}. This comprises the system ordered by the order of the equations,{} the Jacobi matrices separately for each order and the index of the independent variable with respect to which the equation was lastly differentiated (1 for not prolonged equations).


kind: o
name: display
exposed: n
type: (%)->Void
params: dTexFormat
comment:
\spad{display(t)} outputs the TeX formatted code \spad{t} so that each line has length less than or equal to the value set by the system command \spadsys{)set output length}.


kind: o
name: display
exposed: x
type: (%)->Union((List(OutputForm))->OutputForm,failed)
params: dBasicOperator
comment:
\spad{display(op)} returns the \%display property of \spad{op} if it has one attached,{} and failed otherwise.


kind: o
name: display
exposed: n
type: (%,Integer)->Void
params: dTexFormat
comment:
\spad{display(t,{} width)} outputs the TeX formatted code \spad{t} so that each line has length less than or equal to \spadvar{width}.


kind: o
name: display
exposed: n
type: (%,List(Symbol))->OutputForm
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{display(f,{}[s])} prints the element \spad{f} as A*(\spad{s_1},{}\spad{s_2},{}...,{}\spad{s_n})' = \spad{v}.


kind: o
name: display
exposed: x
type: (%,(List(OutputForm))->OutputForm)->%
params: dBasicOperator
comment:
\spad{display(op,{} foo)} attaches foo as the \%display property of \spad{op}. If \spad{op} has a \%display property \spad{f},{} then \spad{op(a1,{}...,{}an)} gets converted to OutputForm as \spad{f(a1,{} ...,{} an)}.


kind: o
name: display
exposed: x
type: (%,(OutputForm)->OutputForm)->%
params: dBasicOperator
comment:
\spad{display(op,{} foo)} attaches foo as the \%display property of \spad{op}. If \spad{op} has a \%display property \spad{f},{} then \spad{op(a)} gets converted to OutputForm as \spad{f(a)}. Argument \spad{op} must be unary.


kind: o
name: displayKind
exposed: n
type: (List(GuessOption))->Symbol
params: dGuessOptionFunctions0
comment:
\spad{displayKind(d)} specifies kind of the result: generating function,{} recurrence or equation. This option should not be set by the user,{} but rather by the \spad{HP}-specification.


kind: o
name: distance
exposed: n
type: (%,%)->DoubleFloat
params: cSPointCategory
comment:
\spad{distance(p1,{} p2)} returns the distance between the points \spad{p1} is the first point. \spad{p2} is the second point. There are 2 metrics associated with any SPointCategory the underlying space and the space that it is embedded in this is the distance in the underlying space.


kind: o
name: distance
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger)->Integer
params: cFiniteGraph(S)
comment:
\spad{distance(s,{} a,{} b)} gives the shortest distance between nodes 'a' and \spad{'b'} as a number of hops. 0 if 'a' = \spad{'b'},{} \spad{-1} if it is not possible to go from 'a' to \spad{'b'}


kind: o
name: distanceMatrix
exposed: n
type: (%)->Matrix(Integer)
params: cFiniteGraph(S)
comment:
\spad{distanceMatrix(s)} gives matrix of distances between vertices. Element a_{\spad{i},{} \spad{j}} is the distance from \spad{i} to \spad{j}. Distance matrices are related to adjacency matrices,{} with the differences that: a. the latter only provides the information which vertices are connected \indented{3}{but does not tell about costs or distances between the vertices} \spad{b}. adjacency matrix only tells us about directly connected \indented{3}{vertices while distance matrix also considers indirect connections.}


kind: o
name: distanceSquared
exposed: n
type: (%,%)->DoubleFloat
params: cSPointCategory
comment:
\spad{distanceSquared(p1,{} p2)} returns the distance between the points \spad{p1} and \spad{p2}. There are 2 metrics associated with any SPointCategory the underlying space and the space that it is embedded in this is the distance in the underlying space.


kind: o
name: distFact
exposed: n
params: pLeadingCoefDetermination(OV,E,Z,P)
type:
(Z,List(SparseUnivariatePolynomial(Z)),Record(contp:Z,factors:List(Record(irr:P,pow:NonNegativeInteger))),List(Z),List(OV),List(Z))->Union(Record(polfac:List(P),correct:Z,corrfact:List(SparseUnivariatePolynomial(Z))),failed)

comment:
\spad{distFact(contm,{} unilist,{} plead,{} vl,{} lvar,{} lval)},{} where \spad{contm} is the content of the evaluated polynomial,{} \spad{unilist} is the list of factors of the evaluated polynomial,{} \spad{plead} is the complete factorization of the leading coefficient,{} \spad{vl} is the list of factors of the leading coefficient evaluated,{} \spad{lvar} is the list of variables,{} lval is the list of values,{} returns a record giving the list of leading coefficients to impose on the univariate factors,{}


kind: o
name: distinct_partition
exposed: x
type: (I)->I
params: pIntegerCombinatoricFunctions(I)
comment:
\spad{distinct_partition(n)} returns the number of partitions of the integer \spad{n} with distinct members. This is the number of ways that \spad{n} can be written as a sum of distinct positive integers. For \spad{n > 0} this is the same as number of ways that \spad{n} can be written as a sum of odd positive integers.


kind: o
name: distinct_partitions
exposed: x
type: (Integer)->Stream(List(Integer))
params: pPartitionsAndPermutations
comment:
\spad{distinct_partitions(n)} is the stream of all partitions \indented{1}{of \spad{n} into distinct numbers.}


kind: o
name: distinct_partitions
exposed: x
type: (Integer,Integer,Integer)->Stream(List(Integer))
params: pPartitionsAndPermutations
comment:
\spad{distinct_partitions(p,{} l,{} n)} is the stream of partitions \indented{1}{of \spad{n} into distinct 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: distribute
exposed: x
type: (%)->%
params: cExpressionSpace2(K)
comment:
\spad{distribute(f)} expands all the kernels in \spad{f} that are formally enclosed by a \spadfunFrom{box}{ExpressionSpace} or \spadfunFrom{paren}{ExpressionSpace} expression.


kind: o
name: distribute
exposed: x
type: (%,%)->%
params: cExpressionSpace2(K)
comment:
\spad{distribute(f,{} g)} expands all the kernels in \spad{f} that contain \spad{g} in their arguments and that are formally enclosed by a \spadfunFrom{box}{ExpressionSpace} or a \spadfunFrom{paren}{ExpressionSpace} expression.


kind: o
name: distributionByBooleanCumulants
exposed: x
type: (Sequence(R))->%
params: dDistribution(R)
comment:
\spad{distributionByBooleanCumulants(bb)} initiates a distribution with given Boolean cumulants \spad{bb}.


kind: o
name: distributionByClassicalCumulants
exposed: x
type: (Sequence(R))->%
params: dDistribution(R)
comment:
\spad{distributionByEvenMoments(kk)} initiates a distribution with given classical cumulants \spad{kk}.


kind: o
name: distributionByEvenMoments
exposed: x
type: (Sequence(R))->%
params: dDistribution(R)
comment:
\spad{distributionByEvenMoments(mm)} initiates a distribution with given even moments \spad{mm} and odd moments zero.


kind: o
name: distributionByFreeCumulants
exposed: x
type: (Sequence(R))->%
params: dDistribution(R)
comment:
\spad{distributionByFreeCumulants(cc)} initiates a distribution with given free cumulants \spad{cc}.


kind: o
name: distributionByJacobiParameters
exposed: x
type: (Sequence(R),Sequence(R))->%
params: dDistribution(R)
comment:
\spad{distributionByJacobiParameters(aa,{} bb)} initiates a distribution with given Jacobi parameters \spad{[aa,{} bb]}.


kind: o
name: distributionByMonotoneCumulants
exposed: x
type: (Sequence(R))->%
params: dDistribution(R)
abbrev: has(R,Algebra(Fraction(Integer)))
comment:
\spad{distributionByMonotoneCumulants(hh)} initiates a distribution with given monotone cumulants \spad{hh}.


kind: o
name: distributionBySTransform
exposed: x
type: (Record(puiseux:Fraction(Integer),laurent:Fraction(Integer),coef:Sequence(R)))->%
params: dDistribution(R)
abbrev: has(R,Algebra(Fraction(Integer)))
comment:
\spad{distributionBySTransform(series)} initiates a distribution with given \spad{S}-transform \spad{series}.


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


kind: o
name: divide
exposed: n
type: (polR,polR)->Record(quotient:polR,remainder:polR)
params: pPseudoRemainderSequence(R,polR)
comment:
\spad{divide(F,{} G)} computes quotient and rest of the exact euclidean division of \spad{F} by \spad{G}.


kind: o
name: divide
exposed: n
type: (%,%)->Union(Record(lm:%,rm:%),failed)
params: dFreeMonoid(S)
comment:
\spad{divide(x,{} y)} returns the left and right exact quotients of \spad{x} by \spad{y},{} \spadignore{i.e.} \spad{[l,{} r]} such that \spad{x = l * y * r},{} failed if \spad{x} is not of the form \spad{l * y * r}.


kind: o
name: divide
exposed: x
type: (%,%)->Record(quotient:%,remainder:%)
params: cEuclideanDomain
comment:
\spad{divide(x,{} y)} divides \spad{x} by \spad{y} producing a record containing a \spad{quotient} and \spad{remainder},{} where the remainder is smaller (see \spadfunFrom{sizeLess?}{EuclideanDomain}) than the divisor \spad{y}.


kind: o
name: divide!
exposed: n
type: (PA,PA,MD)->PA
params: cModularFactorizationOperations(PA,MMT,MD,PMD)
comment:
\spad{divide!(pol1,{} pol2,{} md)} performs division with remainder of \spad{pol1} by \spad{pol2}. \spad{pol1} is modified in place to contain remainder. Quotient is return value.


kind: o
name: divideExponents
exposed: x
type: (%,NonNegativeInteger)->Union(%,failed)
params: cUnivariatePolynomialCategory(R)
comment:
\spad{divideExponents(p,{} n)} returns a new polynomial resulting from dividing all exponents of the polynomial \spad{p} by the non negative integer \spad{n},{} or failed if some exponent is not exactly divisible by \spad{n}.


kind: o
name: divideIfCan
exposed: n
type: (UP,UP)->Union(Record(quotient:UP,remainder:UP),failed)
params: pUnivariatePolynomialDivisionPackage(R,UP)
comment:
\spad{divideIfCan(f,{} g)} returns quotient and remainder of the division of \spad{f} by \spad{g} or failed if it has not succeeded.


kind: o
name: divideIfCan!
exposed: n
type: (Matrix(R),Matrix(R),R,Integer)->R
params: pIntegralBasisTools(R,UP,F)
comment:
\spad{divideIfCan!(matrix,{} matrixOut,{} prime,{} n)} attempts to divide the entries of \spad{matrix} by \spad{prime} and store the result in \spad{matrixOut}. If it is successful,{} 1 is returned and if not,{} \spad{prime} is returned. Here both \spad{matrix} and \spad{matrixOut} are \spad{n}-by-\spad{n} upper triangular matrices.


kind: o
name: divisor
exposed: x
type: (F,F)->%
params: cFiniteDivisorCategory(F,UP,UPUP,R)
comment:
\spad{divisor(a,{} b)} makes the divisor \spad{P:} \spad{(x = a,{} y = b)}. Error: if \spad{P} is singular.


kind: o
name: divisor
exposed: x
type: (F,F,Integer)->%
params: cFiniteDivisorCategory(F,UP,UPUP,R)
comment:
\spad{divisor(a,{} b,{} n)} makes the divisor \spad{nP} where \spad{P:} \spad{(x = a,{} y = b)}. \spad{P} is allowed to be singular if \spad{n} is a multiple of the rank.


kind: o
name: divisor
exposed: x
type: (R,UP,UP)->%
params: cFiniteDivisorCategory(F,UP,UPUP,R)
comment:
\spad{divisor(h,{} d,{} g)} returns \spad{gcd} of divisor of zeros of \spad{h} and divisor of zeros of \spad{d}. \spad{d} must be squarefree. All ramified zeros of \spad{d} must be contained in zeros of \spad{g}.


kind: o
name: divisor
exposed: x
type: (R,UP,UP,UP,F)->%
params: cFiniteDivisorCategory(F,UP,UPUP,R)
comment:
\spad{divisor(h,{} d,{} d',{} g,{} r)} returns the sum of all the finite points where \spad{h/d} has residue \spad{r}. \spad{h} must be integral. \spad{d} must be squarefree. \spad{d'} is some derivative of \spad{d} (not necessarily dd/dx). \spad{g = gcd(d,{} discriminant)} contains the ramified zeros of \spad{d}


kind: o
name: divisorCascade
exposed: n
type: (UP,UP)->List(Record(factors:List(UP),error:R))
params: pComplexRootFindingPackage(R,UP)
comment:
\spad{divisorCascade(p,{} tp)} assumes that degree of polynomial {\em tp} is smaller than degree of polynomial \spad{p},{} both monic. A sequence of divisions is calculated using the remainder,{} made monic,{} as divisor for the the next division. The result contains also the error of the factorizations,{} \spadignore{i.e.} the norm of the remainder polynomial.


kind: o
name: divisorCascade
exposed: n
type: (UP,UP,Boolean)->List(Record(factors:List(UP),error:R))
params: pComplexRootFindingPackage(R,UP)
comment:
\spad{divisorCascade(p,{} tp)} assumes that degree of polynomial {\em tp} is smaller than degree of polynomial \spad{p},{} both monic. A sequence of divisions are calculated using the remainder,{} made monic,{} as divisor for the next division. The result contains also the error of the factorizations,{} \spadignore{i.e.} the norm of the remainder polynomial. If {\em info} is {\em true},{} then information messages are issued.


kind: o
name: doFactor
exposed: n
params: pTwoFactorize(F)
type:
(SparseUnivariatePolynomial(SparseUnivariatePolynomial(F)),Integer,Boolean)->Factored(SparseUnivariatePolynomial(SparseUnivariatePolynomial(F)))

comment:
\spad{doFactor(p,{} n,{} ext?)} returns the factorisation of polynomial \spad{p},{} \spad{p} is assumed to be primitive and squarefree,{} \spad{n} is degree in auxiliary variable,{} ext? if \spad{false} inhibits use of extension field.


kind: o
name: dom
exposed: x
type: (%)->SExpression
params: dAny
comment:
\spad{dom(a)} returns a \spadgloss{LISP} form of the type of the original object that was converted to \spadtype{Any}.


kind: o
name: domainOf
exposed: x
type: (%)->OutputForm
params: dAny
comment:
\spad{domainOf(a)} returns a printable form of the type of the original object that was converted to \spadtype{Any}.


kind: o
name: dominantTerm
exposed: n
params: dUnivariatePuiseuxSeriesWithExponentialSingularity(R,FE,var,cen)
type:
(%)->Union(Record(%term:Record(%coef:UnivariatePuiseuxSeries(FE,var,cen),%expon:ExponentialOfUnivariatePuiseuxSeries(FE,var,cen),%expTerms:List(Record(k:Fraction(Integer),c:FE))),%type:String),failed)

comment:
\spad{dominantTerm(f(var))} returns the term that dominates the limiting behavior of \spad{f(var)} as \spad{var -> cen+} together with a \spadtype{String} which briefly describes that behavior. The value of the \spadtype{String} will be \spad{zero} (resp. \spad{infinity}) if the term tends to zero (resp. infinity) exponentially and will \spad{series} if the term is a Puiseux series.


kind: o
name: do_modular_solve
exposed: n
params: pInnerModularHermitePade
type:
(Vector(U32Vector),Vector(Integer),NonNegativeInteger,U32Vector,Integer,Symbol)->Union(Record(basis:TwoDimensionalArray(U32Vector),defects:Vector(Integer),cinds:Vector(Integer)),no_solution)


kind: o
name: do_param_RDE
exposed: n
type: (F,F,List(F),Symbol,List(Kernel(F)))->Union(Record(ratpart:F,coeffs:Vector(F)),failed)
params: pElementaryRischDEX2(R,F)
comment:
\spad{do_param_RDE(f,{} h,{} lg,{} x,{} lk)} solves parametric Risch differential equation,{} that is returns \spad{[y,{} [c1,{} ...,{} ck]]} such that dy/dx + \spad{n} df/dx \spad{y} + \spad{c1} \spad{g1} + ... \spad{cn} \spad{gn} = \spad{h} where \spad{y} is in the is in field generated by \spad{lk} and \spad{ci} are constants or failed if there is no solution.


kind: o
name: do_poly_integer
exposed: n
params: pInnerModularHermitePade
type:
(List(Symbol),List(PrimitiveArray(Fraction(Polynomial(Integer)))),Vector(Integer),NonNegativeInteger,U32Vector,Symbol,Symbol,(List(U32Vector),Integer,Integer)->Vector(U32Vector))->Union(Record(defects:Vector(Integer),cinds:Vector(Integer),rowlen:Integer,offsetdata:Vector(Integer),expdata:SortedExponentVector,coeffdata:PrimitiveArray(Integer)),no_solution)


kind: o
name: do_risch_DE
exposed: n
type: (F,F,Symbol,List(Kernel(F)))->Record(ans:F,right:F,primpart:F,sol?:Boolean)
params: pElementaryRischDEX2(R,F)
comment:
\spad{do_risch_DE(f,{} g,{} x,{} lk)} returns \spad{[y,{} h,{} 0,{} b]} such that \spad{dy/dx + df/dx y = h} and \spad{b := h = g}. The equation \spad{dy/dx + df/dx y = g} has no solution in the field generated by \spad{lk} if \spad{h \~~= g} (\spad{y} is a partial solution in that case).


kind: o
name: dot
exposed: n
type: (Point(DoubleFloat),Point(DoubleFloat))->DoubleFloat
params: pTubePlotTools
comment:
\spad{dot(p,{} q)} computes the dot product of the two points \spad{p} and \spad{q} using only the first three coordinates,{} and returns the resulting \spadtype{DoubleFloat}.


kind: o
name: dot
exposed: x
type: (%,%)->R
params: cVectorCategory(R)
abbrev: AND(has(R,AbelianMonoid),has(R,SemiRng))
comment:
\spad{dot(x,{} y)} computes the inner product of the two vectors \spad{x} and \spad{y}. Error: if \spad{x} and \spad{y} are not of the same length.


kind: o
name: doubleComplex?
exposed: n
type: (%)->Boolean
params: dFortranScalarType
comment:
\spad{doubleComplex?(t)} tests whether \spad{t} is equivalent to the (non-standard) FORTRAN type DOUBLE COMPLEX.


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


kind: o
name: doubleResultant
exposed: n
type: (R,(UP)->UP)->UP
params: pDoubleResultantPackage(F,UP,UPUP,R)
comment:
\spad{doubleResultant(f,{} ')} returns \spad{p}(\spad{x}) whose roots are rational multiples of the residues of \spad{f} at all its finite poles. Argument ' is the derivation to use.


kind: o
name: doublyTransitive?
exposed: x
type: (UP)->Boolean
params: pAlgFactor(UP)
comment:
\spad{doublyTransitive?(p)} is \spad{true} if \spad{p} is irreducible over over the field \spad{K} generated by its coefficients,{} and if \spad{p(X) / (X - a)} is irreducible over \spad{K(a)} where \spad{p(a) = 0}.


kind: o
name: draw
exposed: x
type: ((DoubleFloat)->DoubleFloat,Segment(Float))->TwoDimensionalViewport
params: pTopLevelDrawFunctionsForCompiledFunctions
comment:
\spad{draw(f,{} a..b)} draws the graph of \spad{y = f(x)} as \spad{x} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)}.


kind: o
name: draw
exposed: x
type: ((DoubleFloat)->Point(DoubleFloat),Segment(Float))->ThreeDimensionalViewport
params: pTopLevelDrawFunctionsForCompiledFunctions
comment:
\spad{draw(f,{} a..b,{} l)} draws the graph of the parametric curve \spad{f} as \spad{t} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)}.


kind: o
name: draw
exposed: x
type: (Ex,SegmentBinding(Float))->TwoDimensionalViewport
params: pTopLevelDrawFunctions(Ex)
comment:
\spad{draw(f(x),{} x = a..b)} draws the graph of \spad{y = f(x)} as \spad{x} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)}; \spad{f(x)} appears in the title bar.


kind: o
name: draw
exposed: x
type: (List(DoubleFloat),List(DoubleFloat))->TwoDimensionalViewport
params: pTopLevelDrawFunctionsForPoints
comment:
\spad{draw(lx,{} ly)} plots the curve constructed of points (\spad{x},{} \spad{y}) for \spad{x} in \spad{lx} for \spad{y} in \spad{ly}.


kind: o
name: draw
exposed: x
type: (List(Point(DoubleFloat)),List(DrawOption))->TwoDimensionalViewport
params: pTopLevelDrawFunctionsForPoints
comment:
\spad{draw(lp,{} l)} plots the curve constructed from the list of points \spad{lp}. The options contained in the list \spad{l} of the domain \spad{DrawOption} are applied.


kind: o
name: draw
exposed: x
type: (ParametricPlaneCurve((DoubleFloat)->DoubleFloat),Segment(Float))->TwoDimensionalViewport
params: pTopLevelDrawFunctionsForCompiledFunctions
comment:
\spad{draw(curve(f,{} g),{} a..b)} draws 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)}.


kind: o
name: draw
exposed: x
type: (ParametricPlaneCurve(Ex),SegmentBinding(Float))->TwoDimensionalViewport
params: pTopLevelDrawFunctions(Ex)
comment:
\spad{draw(curve(f(t),{} g(t)),{} t = a..b)} draws 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)}; \spad{(f(t),{} g(t))} appears in the title bar.


kind: o
name: draw
exposed: x
type: (ParametricSpaceCurve((DoubleFloat)->DoubleFloat),Segment(Float))->ThreeDimensionalViewport
params: pTopLevelDrawFunctionsForCompiledFunctions
comment:
\spad{draw(curve(f,{} g,{} h),{} a..b,{} l)} draws 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: draw
exposed: x
type: (ParametricSpaceCurve(Ex),SegmentBinding(Float))->ThreeDimensionalViewport
params: pTopLevelDrawFunctions(Ex)
comment:
\spad{draw(curve(f(t),{} g(t),{} h(t)),{} t = a..b)} draws 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: draw
exposed: x
type: ((DoubleFloat,DoubleFloat)->DoubleFloat,Segment(Float),Segment(Float))->ThreeDimensionalViewport
params: pTopLevelDrawFunctionsForCompiledFunctions
comment:
\spad{draw(f,{} a..b,{} c..d)} draws 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: draw
exposed: x
params: pTopLevelDrawFunctionsForCompiledFunctions
type:
((DoubleFloat,DoubleFloat)->Point(DoubleFloat),Segment(Float),Segment(Float))->ThreeDimensionalViewport

comment:
\spad{draw(f,{} a..b,{} c..d)} draws 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: draw
exposed: x
type: ((DoubleFloat)->DoubleFloat,Segment(Float),List(DrawOption))->TwoDimensionalViewport
params: pTopLevelDrawFunctionsForCompiledFunctions
comment:
\spad{draw(f,{} a..b,{} l)} draws 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: draw
exposed: x
type: ((DoubleFloat)->Point(DoubleFloat),Segment(Float),List(DrawOption))->ThreeDimensionalViewport
params: pTopLevelDrawFunctionsForCompiledFunctions
comment:
\spad{draw(f,{} a..b,{} l)} draws the graph of the parametric curve \spad{f} 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: draw
exposed: x
type: (Ex,SegmentBinding(Float),List(DrawOption))->TwoDimensionalViewport
params: pTopLevelDrawFunctions(Ex)
comment:
\spad{draw(f(x),{} x = a..b,{} l)} draws the graph of \spad{y = f(x)} as \spad{x} ranges from \spad{min(a,{} b)} to \spad{max(a,{} b)}; \spad{f(x)} is the default title,{} and the options contained in the list \spad{l} of the domain \spad{DrawOption} are applied.


kind: o
name: draw
exposed: x
type: (Ex,SegmentBinding(Float),SegmentBinding(Float))->ThreeDimensionalViewport
params: pTopLevelDrawFunctions(Ex)
comment:
\spad{draw(f(x,{} y),{} x = a..b,{} y = c..d)} draws 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 in the title bar.


kind: o
name: draw
exposed: x
type: (List(DoubleFloat),List(DoubleFloat),List(DoubleFloat))->ThreeDimensionalViewport
params: pTopLevelDrawFunctionsForPoints
comment:
\spad{draw(lx,{} ly,{} lz)} draws the surface constructed by projecting the values in the \spad{lz} list onto the rectangular grid formed by the \spad{lx X ly}.


kind: o
name: draw
exposed: x
type: (List(DoubleFloat),List(DoubleFloat),List(DrawOption))->TwoDimensionalViewport
params: pTopLevelDrawFunctionsForPoints
comment:
\spad{draw(lx,{} ly,{} l)} plots the curve constructed of points (\spad{x},{} \spad{y}) for \spad{x} in \spad{lx} for \spad{y} in \spad{ly}. The options contained in the list \spad{l} of the domain \spad{DrawOption} are applied.


kind: o
name: draw
exposed: x
params: pTopLevelDrawFunctionsForCompiledFunctions
type:
(ParametricPlaneCurve((DoubleFloat)->DoubleFloat),Segment(Float),List(DrawOption))->TwoDimensionalViewport

comment:
\spad{draw(curve(f,{} g),{} a..b,{} l)} draws 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: draw
exposed: x
type: (ParametricPlaneCurve(Ex),SegmentBinding(Float),List(DrawOption))->TwoDimensionalViewport
params: pTopLevelDrawFunctions(Ex)
comment:
\spad{draw(curve(f(t),{} g(t)),{} t = a..b,{} l)} draws 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)}; \spad{(f(t),{} g(t))} is the default title,{} and the options contained in the list \spad{l} of the domain \spad{DrawOption} are applied.


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

comment:
\spad{draw(curve(f,{} g,{} h),{} a..b,{} l)} draws 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: draw
exposed: x
type: (ParametricSpaceCurve(Ex),SegmentBinding(Float),List(DrawOption))->ThreeDimensionalViewport
params: pTopLevelDrawFunctions(Ex)
comment:
\spad{draw(curve(f(t),{} g(t),{} h(t)),{} t = a..b,{} l)} draws 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: draw
exposed: x
params: pTopLevelDrawFunctionsForCompiledFunctions
type:
(ParametricSurface((DoubleFloat,DoubleFloat)->DoubleFloat),Segment(Float),Segment(Float))->ThreeDimensionalViewport

comment:
\spad{draw(surface(f,{} g,{} h),{} a..b,{} c..d)} draws 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: draw
exposed: x
type: (ParametricSurface(Ex),SegmentBinding(Float),SegmentBinding(Float))->ThreeDimensionalViewport
params: pTopLevelDrawFunctions(Ex)
comment:
\spad{draw(surface(f(u,{} v),{} g(u,{} v),{} h(u,{} v)),{} u = a..b,{} v = c..d)} draws 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: draw
exposed: x
params: pTopLevelDrawFunctionsForCompiledFunctions
type:
((DoubleFloat,DoubleFloat)->DoubleFloat,Segment(Float),Segment(Float),List(DrawOption))->ThreeDimensionalViewport

comment:
\spad{draw(f,{} a..b,{} c..d,{} l)} draws 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: draw
exposed: x
params: pTopLevelDrawFunctionsForCompiledFunctions
type:
((DoubleFloat,DoubleFloat)->Point(DoubleFloat),Segment(Float),Segment(Float),List(DrawOption))->ThreeDimensionalViewport

comment:
\spad{draw(f,{} a..b,{} c..d)} draws 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: draw
exposed: x
type: (Equation(Ex),Symbol,Symbol,List(DrawOption))->TwoDimensionalViewport
params: pTopLevelDrawFunctionsForAlgebraicCurves(R,Ex)
comment:
\spad{draw(f(x,{} y) = g(x,{} y),{} x,{} y,{} l)} draws 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: draw
exposed: x
type: (Ex,SegmentBinding(Float),SegmentBinding(Float),List(DrawOption))->ThreeDimensionalViewport
params: pTopLevelDrawFunctions(Ex)
comment:
\spad{draw(f(x,{} y),{} x = a..b,{} y = c..d,{} l)} draws 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: draw
exposed: x
type: (List(DoubleFloat),List(DoubleFloat),List(DoubleFloat),List(DrawOption))->ThreeDimensionalViewport
params: pTopLevelDrawFunctionsForPoints
comment:
\spad{draw(lx,{} ly,{} lz,{} l)} draws the surface constructed by projecting the values in the \spad{lz} list onto the rectangular grid formed by the The options contained in the list \spad{l} of the domain \spad{DrawOption} are applied.


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

comment:
\spad{draw(surface(f,{} g,{} h),{} a..b,{} c..d)} draws 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: draw
exposed: x
params: pTopLevelDrawFunctions(Ex)
type:
(ParametricSurface(Ex),SegmentBinding(Float),SegmentBinding(Float),List(DrawOption))->ThreeDimensionalViewport

comment:
\spad{draw(surface(f(u,{} v),{} g(u,{} v),{} h(u,{} v)),{} u = a..b,{} v = c..d,{} l)} draws 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: drawComplex
exposed: x
params: pDrawComplex
type:
((Complex(DoubleFloat))->Complex(DoubleFloat),Segment(DoubleFloat),Segment(DoubleFloat),Boolean)->ThreeDimensionalViewport

comment:
\spad{drawComplex(f,{} rRange,{} iRange,{} arrows?)} draws a complex function as a height field. It uses the complex norm as the height and the complex argument as the color. It will optionally draw arrows on the surface indicating the direction of the complex value.\newline Sample call: \indented{2}{\spad{f z == exp(1/z)}} \indented{2}{\spad{drawComplex(f,{} 0.3..3,{} 0..2*\%\spad{pi},{} false)}} Parameter descriptions: \indented{2}{\spad{f:}\space{2}the function to draw} \indented{2}{\spad{rRange} : the range of the real values} \indented{2}{\spad{iRange} : the range of imaginary values} \indented{2}{arrows? : a flag indicating whether to draw the phase arrows for \spad{f}} Call the functions \spadfunFrom{setRealSteps}{DrawComplex} and \spadfunFrom{setImagSteps}{DrawComplex} to change the number of steps used in each direction.


kind: o
name: drawComplexVectorField
exposed: x
params: pDrawComplex
type:
((Complex(DoubleFloat))->Complex(DoubleFloat),Segment(DoubleFloat),Segment(DoubleFloat))->ThreeDimensionalViewport

comment:
\spad{drawComplexVectorField(f,{} rRange,{} iRange)} draws a complex vector field using arrows on the \spad{x--y} plane. These vector fields should be viewed from the top by pressing the XY translate button on the 3-\spad{d} viewport control panel.\newline Sample call: \indented{3}{\spad{f z == sin z}} \indented{3}{\spad{drawComplexVectorField(f,{} -2..2,{} -2..2)}} Parameter descriptions: \indented{2}{\spad{f} : the function to draw} \indented{2}{\spad{rRange} : the range of the real values} \indented{2}{iRange : the range of the imaginary values} Call the functions \spadfunFrom{setRealSteps}{DrawComplex} and \spadfunFrom{setImagSteps}{DrawComplex} to change the number of steps used in each direction.


kind: o
name: drawCurves
exposed: n
type: (List(List(Point(DoubleFloat))),List(DrawOption))->TwoDimensionalViewport
params: pViewportPackage
comment:
\spad{drawCurves([[p0],{} [p1],{} ...,{} [pn]],{} [options])} creates a \spadtype{TwoDimensionalViewport} from the list of lists of points,{} \spad{p0} through \spad{pn},{} using the options specified in the list \spad{options}.


kind: o
name: drawCurves
exposed: n
params: pViewportPackage
type:
(List(List(Point(DoubleFloat))),Palette,Palette,PositiveInteger,List(DrawOption))->TwoDimensionalViewport

comment:
\spad{drawCurves([[p0],{} [p1],{} ...,{} [pn]],{} ptColor,{} lineColor,{} ptSize,{} [options])} creates a \spadtype{TwoDimensionalViewport} from the list of lists of points,{} \spad{p0} through \spad{pn},{} using the options specified in the list \spad{options}. The point color is specified by \spad{ptColor},{} the line color is specified by \spad{lineColor},{} and the point size is specified by \spad{ptSize}.


kind: o
name: drawStyle
exposed: x
type: (%,String)->Void
params: dThreeDimensionalViewport
comment:
\spad{drawStyle(v,{} s)} displays the surface for the given three-dimensional viewport \spad{v} which is of domain \spadtype{ThreeDimensionalViewport} in the style of drawing indicated by \spad{s}. If \spad{s} is not a valid drawing style the style is wireframe by default. Possible styles are \spad{shade},{} \spad{solid} or \spad{opaque},{} \spad{smooth},{} and \spad{wireMesh}.


kind: o
name: drawToScale
exposed: x
type: (Boolean)->Boolean
params: pGraphicsDefaults
comment:
\spad{drawToScale(true)} causes plots to be drawn to scale. \spad{drawToScale(false)} causes plots to be drawn so that they fill up the viewport window. The default setting is \spad{false}.


kind: o
name: dSubst
exposed: n
type: (%,JB,%)->%
params: cJetBundleFunctionCategory(JB)
comment:
\spad{dSubst(f,{} jv,{} exp)} is like \spad{subst(f,{} jv,{} exp)}. But additionally for all derivatives of \spad{jv} the corresponding substitutions are performed.


kind: o
name: e
exposed: x
type: (PositiveInteger)->%
params: dCliffordAlgebra(n,K,bLin)
comment:
\spad{e(n)} produces phi(e_i) where e_i is \spad{i}-th basis vector in \spad{K^n} and phi is canonical embedding of \spad{K^n} into Clifford algebra.


kind: o
name: eFromBinaryMap
exposed: x
type: (NonNegativeInteger)->%
params: dCliffordAlgebra(n,K,bLin)
comment:
\spad{eFromBinaryMap(n)} sets the appropriate Grassmann basis,{} for example: eFromBinaryMap(0) = 1 (scalar) eFromBinaryMap(1) = \spad{e1} eFromBinaryMap(2) = \spad{e2} eFromBinaryMap(3) = e1/\e2


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


kind: o
name: eigenMatrix
exposed: x
type: (Matrix(Fraction(Polynomial(Integer))))->Union(Matrix(Expression(Integer)),failed)
params: pRadicalEigenPackage
comment:
\spad{eigenMatrix(m)} returns the matrix \spad{b} such that \spad{b*m*(inverse b)} is diagonal,{} or failed if no such \spad{b} exists.


kind: o
name: eigenvalues
exposed: x
params: pEigenPackage(R)
abbrev: has(R,PolynomialFactorizationExplicit)
comment: \spad{eigenvalues(m)} returns the eigenvalues of the matrix \spad{m}.
type:
(Matrix(Fraction(Polynomial(R))))->List(Union(Fraction(Polynomial(R)),SuchThat(Symbol,Polynomial(R))))


kind: o
name: eigenvalues
exposed: n
params: pInnerEigenPackage(F)
type:
(Matrix(F),(SparseUnivariatePolynomial(F))->Factored(SparseUnivariatePolynomial(F)))->List(Union(F,SparseUnivariatePolynomial(F)))

comment:
\spad{eigenvalues(m,{} fac)} returns the eigenvalues of the matrix \spad{m}. Eigenvalues in base field are given explicitly,{} other are represented by minimal polynomial. fac is a factorizer for polynomials over \spad{F}.


kind: o
name: eigenvector
exposed: n
type: (Union(F,SparseUnivariatePolynomial(F)),Matrix(F))->List(Vector(SparseUnivariatePolynomial(F)))
params: pInnerEigenPackage(F)
comment:
\spad{eigenvector(eigval,{} m)} returns the eigenvectors belonging to the eigenvalue \spad{eigval} for the matrix \spad{m}.


kind: o
name: eigenvector
exposed: x
params: pEigenPackage(R)
type:
(Union(Fraction(Polynomial(R)),SuchThat(Symbol,Polynomial(R))),Matrix(Fraction(Polynomial(R))))->List(Matrix(Fraction(Polynomial(R))))

comment:
\spad{eigenvector(eigval,{} m)} returns the eigenvectors belonging to the eigenvalue \spad{eigval} for the matrix \spad{m}.


kind: o
name: eigenvectors
exposed: n
params: pInnerEigenPackage(F)
abbrev: has(F,PolynomialFactorizationExplicit)
type:
(Matrix(F))->List(Record(eigval:Union(F,SparseUnivariatePolynomial(F)),eigmult:NonNegativeInteger,eigvec:List(Vector(SparseUnivariatePolynomial(F)))))

comment:
\spad{eigenvectors(m)} returns the eigenvalues and eigenvectors for the matrix \spad{m}. The eigenvalues in base field and corresponding eigenvectors are explicitly computed,{} while the non rational ones are given via their minimal polynomial and the corresponding eigenvectors are expressed in terms of a generic root of such a polynomial.


kind: o
name: eigenvectors
exposed: x
params: pEigenPackage(R)
abbrev: has(R,PolynomialFactorizationExplicit)
type:
(Matrix(Fraction(Polynomial(R))))->List(Record(eigval:Union(Fraction(Polynomial(R)),SuchThat(Symbol,Polynomial(R))),eigmult:NonNegativeInteger,eigvec:List(Matrix(Fraction(Polynomial(R))))))

comment:
\spad{eigenvectors(m)} returns the eigenvalues and eigenvectors for the matrix \spad{m}. The eigenvalues in base field and the corresponding eigenvectors are explicitly computed,{} while the other ones are given via their minimal polynomial and the corresponding eigenvectors are expressed in terms of a generic root of such a polynomial.


kind: o
name: eigenvectors
exposed: n
params: pInnerEigenPackage(F)
type:
(Matrix(F),(SparseUnivariatePolynomial(F))->Factored(SparseUnivariatePolynomial(F)))->List(Record(eigval:Union(F,SparseUnivariatePolynomial(F)),eigmult:NonNegativeInteger,eigvec:List(Vector(SparseUnivariatePolynomial(F)))))

comment:
\spad{eigenvectors(m,{} fac)} returns the eigenvalues and eigenvectors for the matrix \spad{m}. The eigenvalues in base field and corresponding eigenvectors are explicitly computed,{} while the other eigenvalues are given via their minimal polynomial and the corresponding eigenvectors are expressed in terms of a generic root of such a polynomial. fac is a factorizer for polynomials over \spad{F}.


kind: o
name: ei_int
exposed: n
type: (Integer,F,F,Symbol)->Record(ans:F,right:F,primpart:F,sol?:Boolean)
params: pElementaryRischDEX(R,F)
comment:
\spad{ei_int(n,{} f,{} g,{} x)} returns \spad{[h,{} u,{} t,{} s]} such that \spad{u*exp(n*f) = (h*exp(n*f))' + t'} where \spad{t} involves special functions. When \spad{s} is \spad{true} then \spad{g = u},{} otherwise ei_int returns partial answer,{}


kind: o
name: eisensteinIrreducible?
exposed: n
type: (UP)->Boolean
params: pGaloisGroupFactorizer(UP)
comment:
\spad{eisensteinIrreducible?(p)} returns \spad{true} if \spad{p} can be shown to be irreducible by Eisenstein\spad{'s} criterion,{} \spad{false} is inconclusive.


kind: o
name: elColumn2!
exposed: x
type: (M,R,Integer,Integer)->M
params: pMatrixLinearAlgebraFunctions(R,Row,Col,M)
comment:
\spad{elColumn2!(m,{} a,{} i,{} j)} adds to column \spad{i} a*column(\spad{m},{} \spad{j}) : elementary operation of second kind. (\spad{i} \spad{~=j})


kind: o
name: element
exposed: n
type: (M,Integer,Integer)->M
params: pMatrixManipulation(R,Row,Col,M)
comment:
\spad{element} returns a single element out of a matrix. The element is put into a one by one matrix.


kind: o
name: elementary
exposed: x
type: (Integer)->SymmetricPolynomial(Fraction(Integer))
params: pCycleIndicators
comment:
\spad{elementary n} is the \spad{n} th elementary symmetric \indented{1}{function expressed in terms of power sums.}


kind: o
name: eliminationEquations
exposed: n
params: dLinearMultivariateMatrixPencil(R)
abbrev: has(R,Field)
type:
(%,List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger))->List(Matrix(Polynomial(R)))

comment:
\spad{eliminationEquations(p,{} row_P,{} col_P,{} row_Q,{} col_Q,{} rdst,{} cdst,{} rex1,{} cex1,{} rex2,{} cex2)} returns a list of matrices with equations to eliminate the entries in rows/columns rdst/cdst,{} \spad{rex1/cex1} and \spad{rex2/cex2}.


kind: o
name: eliminationEquations
exposed: n
params: dLinearMultivariateMatrixPencil(R)
abbrev: has(R,Field)
type:
(%,List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger))->List(Polynomial(R))

comment:
\spad{eliminationEquations(p,{} row_P,{} col_P,{} row_Q,{} col_Q,{} rdst,{} cdst,{} rex1,{} cex1,{} rex2,{} cex2)} returns a list of equations with equations to eliminate the entries in rows/columns rdst/cdst,{} \spad{rex1/cex1} and \spad{rex2/cex2},{} including det(\spad{P})\spad{-1} and det(\spad{Q})\spad{-1}.


kind: o
name: eliminationEquations
exposed: n
params: dLinearMultivariateMatrixPencil(R)
abbrev: has(R,Field)
type:
(%,List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger))->List(Matrix(Polynomial(R)))

comment:
\spad{eliminationEquations(p,{} row_P,{} col_P,{} row_Q,{} col_Q,{} rdst,{} cdst)} returns a list of matrices with equations to eliminate the entries in rows/columns rdst/cdst.


kind: o
name: eliminationGroebner
exposed: n
params: dLinearMultivariateMatrixPencil(R)
abbrev: has(R,Field)
type:
(%,List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger))->List(Polynomial(R))

comment:
\spad{eliminationGroebner(p,{} row_P,{} col_P,{} row_Q,{} col_Q,{} rdst,{} cdst,{} rex1,{} cex1,{} rex2,{} cex2)} computes a Groebner--Shirshov basis for the ideal generated by the equations from eliminationEquations(...) using the domain DistributedMultivariatePolynomial.


kind: o
name: eliminationSolve
exposed: n
type: (Polynomial(R),List(R))->List(List(Equation(Polynomial(R))))
params: dLinearMultivariateMatrixPencil(R)
abbrev: has(R,Field)
comment:
\spad{eliminationSolve(eqn,{} lst_val)} computes all solutions of equation \spad{eqn} by trying the values of lst_val for undetermined variables.


kind: o
name: eliminationSolve
exposed: n
params: dLinearMultivariateMatrixPencil(R)
abbrev: has(R,Field)
type:
(List(Polynomial(R)),List(R),List(List(Equation(Polynomial(R)))))->List(List(Equation(Polynomial(R))))

comment:
\spad{eliminationSolve(lst_eqn,{} lst_val,{} lst_sub)} computes all solutions of the first equation of \spad{lst_eqn} by trying the values of \spad{lst_val} for undetermined variables with respect to given subsolutions lst_sub and return those which fulfill all other equations in \spad{lst_eqn}.


kind: o
name: eliminationSolve
exposed: n
type: (Polynomial(R),List(R),List(Equation(Polynomial(R))))->List(List(Equation(Polynomial(R))))
params: dLinearMultivariateMatrixPencil(R)
abbrev: has(R,Field)
comment:
\spad{eliminationSolve(eqn,{} lst_val,{} sub)} computes all solutions of equation \spad{eqn} by trying the values of \spad{lst_val} for undetermined variables with respect to given subsolution sub.


kind: o
name: eliminationSolve
exposed: n
type: (Polynomial(R),List(R),List(List(Equation(Polynomial(R)))))->List(List(Equation(Polynomial(R))))
params: dLinearMultivariateMatrixPencil(R)
abbrev: has(R,Field)
comment:
\spad{eliminationSolve(eqn,{} lst_val,{} lst_sub)} computes all solutions of equation \spad{eqn} by trying the values of \spad{lst_val} for undetermined variables with respect to given subsolutions lst_sub.


kind: o
name: eliminationTransformations
exposed: n
params: dLinearMultivariateMatrixPencil(R)
abbrev: has(R,Field)
type:
(%,List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger))->List(Matrix(Polynomial(R)))

comment:
\spad{eliminationTransformations(p,{} row_P,{} col_P,{} row_Q,{} col_Q)} returns a pair of transformation matrices with commutative variables 'a[\spad{i}] in rows/columns row_P/col_P respectively \spad{'b}[\spad{i}] in rows/columns row_Q/col_Q.


kind: o
name: eliminationTransformations
exposed: n
params: dLinearMultivariateMatrixPencil(R)
abbrev: has(R,Field)
type:
(%,List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(Equation(Polynomial(R))))->List(Matrix(R))

comment:
\spad{eliminationTransformations(p,{} row_P,{} col_P,{} row_Q,{} col_Q,{} sol)} Uses eval to set the values in sol into the variables in the transformation matrices.


kind: o
name: eliminationTransformations
exposed: n
params: dLinearMultivariateMatrixPencil(R)
abbrev: has(R,Field)
type:
(%,List(NonNegativeInteger),List(NonNegativeInteger),Symbol,List(NonNegativeInteger),List(NonNegativeInteger),Symbol)->List(Matrix(Polynomial(R)))

comment:
\spad{eliminationTransformations(p,{} row_P,{} col_P,{} sym_P,{} row_Q,{} col_Q,{} sym_Q)} returns a pair of transformation matrices with commutative variables \spad{sym_P}[\spad{i}] in rows/columns row_P/col_P respectively sym_Q[\spad{i}] in rows/columns row_Q/col_Q.


kind: o
name: elimZeroCols!
exposed: n
type: (%)->Void
params: dSparseEchelonMatrix(C,D)
comment:
\spad{elimZeroCols!(A)} removes columns which contain only zeros. This affects basically only the value of \spad{allIndices(A)}.


kind: o
name: ellipseBoundary
exposed: n
type: (PT,PT)->%
params: dSBoundary(PT)
comment:
\spad{ellipseBoundary(c1,{} c2)} constructs an ellipse boundary \spad{n}-dimensional axis-aligned ellipoid with given parameters \spad{c1:} \spad{PT} holds centre point \spad{c2:} \spad{PT} holds extent (radius for each coordinate)


kind: o
name: elliptic
exposed: n
type: ()->Union(UP,failed)
params: xFunctionFieldCategory&(S,F,UP,UPUP)
comment:
\spad{elliptic()} returns \spad{p(x)} if the curve is the elliptic defined by \spad{y^2 = p(x)},{} failed otherwise.


kind: o
name: elliptic
exposed: x
type: (R)->(Point(R))->Point(R)
params: pCoordinateSystems(R)
comment:
\spad{elliptic(a)} transforms from elliptic coordinates to Cartesian coordinates: \spad{elliptic(a)} is a function which will map the point \spad{(u,{} v)} to \spad{x = a*cosh(u)*cos(v)},{} \spad{y = a*sinh(u)*sin(v)}.


kind: o
name: ellipticCylindrical
exposed: x
type: (R)->(Point(R))->Point(R)
params: pCoordinateSystems(R)
comment:
\spad{ellipticCylindrical(a)} transforms from elliptic cylindrical coordinates to Cartesian coordinates: \spad{ellipticCylindrical(a)} is a function which will map the point \spad{(u,{} v,{} z)} to \spad{x = a*cosh(u)*cos(v)},{} \spad{y = a*sinh(u)*sin(v)},{} \spad{z}.


kind: o
name: ellipticE
exposed: n
type: (F)->F
params: pFunctionalSpecialFunction(R,F)
comment:
\spad{ellipticE(m)} is the complete elliptic integral of the second kind: \spad{ellipticE(m) = integrate(sqrt(1-m*t^2)/sqrt(1-t^2),{} t = 0..1)}.


kind: o
name: ellipticE
exposed: n
type: (F,F)->F
params: pFunctionalSpecialFunction(R,F)
comment:
\spad{ellipticE(z,{} m)} is the incomplete elliptic integral of the second kind: \spad{ellipticE(z,{} m) = integrate(sqrt(1-m*t^2)/sqrt(1-t^2),{} t = 0..z)}.


kind: o
name: ellipticF
exposed: n
type: (F,F)->F
params: pFunctionalSpecialFunction(R,F)
comment:
\spad{ellipticF(z,{} m)} is the incomplete elliptic integral of the first kind : \spad{ellipticF(z,{} m) = integrate(1/sqrt((1-t^2)*(1-m*t^2)),{} t = 0..z)}.


kind: o
name: ellipticK
exposed: n
type: (F)->F
params: pFunctionalSpecialFunction(R,F)
comment:
\spad{ellipticK(m)} is the complete elliptic integral of the first kind: \spad{ellipticK(m) = integrate(1/sqrt((1-t^2)*(1-m*t^2)),{} t = 0..1)}.


kind: o
name: ellipticPi
exposed: n
type: (F,F,F)->F
params: pFunctionalSpecialFunction(R,F)
comment:
\spad{ellipticPi(z,{} n,{} m)} is the incomplete elliptic integral of the third kind: \spad{ellipticPi(z,{} n,{} m) = integrate(1/((1-n*t^2)*sqrt((1-t^2)*(1-m*t^2))),{} t = 0..z)}.


kind: o
name: ellipticPi
exposed: n
type: (UTS,Coef,Coef)->UTS
params: pEllipticFunctionsUnivariateTaylorSeries(Coef,UTS)
abbrev: has(Coef,Algebra(Fraction(Integer)))
comment:
\spad{ellipticPi(z,{} n,{} m)} expands the elliptic integral \spad{Pi} as a Taylor series in \spad{z}.


kind: o
name: ellipticRC
exposed: x
type: (Complex(DoubleFloat),Complex(DoubleFloat))->Complex(DoubleFloat)
params: pDoubleFloatEllipticIntegrals
comment:
\spad{ellipticRC(x,{} y)} computes integral from 0 to infinity of \spad{(1/2)*(t+x)^(-1/2)*(t+y)^(-1)dt}.


kind: o
name: ellipticRD
exposed: x
type: (Complex(DoubleFloat),Complex(DoubleFloat),Complex(DoubleFloat))->Complex(DoubleFloat)
params: pDoubleFloatEllipticIntegrals
comment:
\spad{ellipticRD(x,{} y,{} z)} computes integral from 0 to infinity of \spad{(3/2)*(t+x)^(-1/2)*(t+y)^(-1/2)*(t+Z)^(-3/2)dt}.


kind: o
name: ellipticRF
exposed: x
type: (Complex(DoubleFloat),Complex(DoubleFloat),Complex(DoubleFloat))->Complex(DoubleFloat)
params: pDoubleFloatEllipticIntegrals
comment:
\spad{ellipticRF(x,{} y,{} z)} computes integral from 0 to infinity of \spad{(1/2)*(t+x)^(-1/2)*(t+y)^(-1/2)*(t+Z)^(-1/2)dt}.


kind: o
name: ellipticRJ
exposed: x
params: pDoubleFloatEllipticIntegrals
type:
(Complex(DoubleFloat),Complex(DoubleFloat),Complex(DoubleFloat),Complex(DoubleFloat))->Complex(DoubleFloat)

comment:
ellipticRF(\spad{x},{} \spad{y},{} \spad{z},{} \spad{p}) computes integral from 0 to infinity of \spad{(3/2)*(t+x)^(-1/2)*(t+y)^(-1/2)*(t+Z)^(-1/2)*(t+p)^(-1)dt}.


kind: o
name: ellipticRJ
exposed: x
type: (DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat)->DoubleFloat
params: pDoubleFloatEllipticIntegrals
comment:
\spad{ellipticRJ(x,{} y,{} z,{} p)} computes integral from 0 to infinity of \spad{(3/2)*(t+x)^(-1/2)*(t+y)^(-1/2)*(t+Z)^(-1/2)*(t+p)^(-1)dt}.


kind: o
name: elRow1!
exposed: x
type: (M,Integer,Integer)->M
params: pMatrixLinearAlgebraFunctions(R,Row,Col,M)
comment:
\spad{elRow1!(m,{} i,{} j)} swaps rows \spad{i} and \spad{j} of matrix \spad{m} : elementary operation of first kind


kind: o
name: elRow2!
exposed: x
type: (M,R,Integer,Integer)->M
params: pMatrixLinearAlgebraFunctions(R,Row,Col,M)
comment:
\spad{elRow2!(m,{} a,{} i,{} j)} adds to row \spad{i} a*row(\spad{m},{} \spad{j}) : elementary operation of second kind. (\spad{i} \spad{~=j})


kind: o
name: elt
exposed: x
type: (BasicOperator,%,%,%,%,%,%,%,%,%)->%
params: cExpressionSpace2(K)
comment:
\spad{elt(op,{} x,{} y,{} z,{} t,{} s,{} r,{} q,{} p,{} o)} applies the 9-ary operator \spad{op} to \spad{x},{} \spad{y},{} \spad{z},{} \spad{t},{} \spad{s},{} \spad{r},{} \spad{q},{} \spad{p} and \spad{o}


kind: o
name: elt
exposed: x
type: (BasicOperator,List(%))->%
params: cExpressionSpace2(K)
comment:
\spad{elt(op,{} [x1,{} ...,{} xn])} or \spad{op}([\spad{x1},{} ...,{} \spad{xn}]) applies the \spad{n}-ary operator \spad{op} to \spad{x1},{} ...,{} \spad{xn}.


kind: o
name: elt
exposed: x
type: (%,%)->%
params: cStringAggregate
comment:
\spad{elt(s,{} t)} returns the concatenation of \spad{s} and \spad{t}. It is provided to allow juxtaposition of strings to work as concatenation. For example,{} \spad{smoo shed} returns \spad{smooshed}.


kind: o
name: elt
exposed: x
type: (%,D)->I
params: cEltable(D,I)
comment:
\spad{elt(u,{} i)} (also written: \spad{u}.\spad{i}) returns the element of \spad{u} indexed by \spad{i}. Error: if \spad{i} is not an index of \spad{u}.


kind: o
name: elt
exposed: x
type: (%,DirectProduct(n,K))->K
params: dQuadraticForm(n,K)
comment:
\spad{elt(qf,{} v)} evaluates the quadratic form \spad{qf} on the vector \spad{v},{} producing a scalar.


kind: o
name: elt
exposed: x
type: (%,Expon)->Coef
params: cUnivariatePowerSeriesCategory(Coef,Expon)
comment:
\spad{elt(f(x),{} r)} returns the coefficient of the term of degree \spad{r} in \spad{f(x)}. This is the same as the function \spadfun{coefficient}.


kind: o
name: elt
exposed: x
type: (Fraction(%),Fraction(%))->Fraction(%)
params: cUnivariatePolynomialCategory(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{elt(a,{} b)} evaluates the fraction of univariate polynomials \spad{a} with the distinguished variable replaced by \spad{b}.


kind: o
name: elt
exposed: x
type: (Fraction(%),R)->R
params: cUnivariatePolynomialCategory(R)
abbrev: has(R,Field)
comment:
\spad{elt(a,{} r)} evaluates the fraction of univariate polynomials \spad{a} with the distinguished variable replaced by the constant \spad{r}.


kind: o
name: elt
exposed: x
type: (%,Integer)->R
params: cFramedNonAssociativeAlgebra(R)
comment:
\spad{elt(a,{} i)} returns the \spad{i}-th coefficient of \spad{a} with respect to the fixed \spad{R}-module basis.


kind: o
name: elt
exposed: x
type: (%,List(Integer))->%
params: cSExpressionCategory(Str,Sym,Int,Flt)
comment:
\spad{elt(s,{} [i1,{} ...,{} im])} recursively selects subexpression,{} that is elt(\spad{s},{} []) is just \spad{s} and elt(\spad{s},{} [\spad{i1},{} ...,{} im]) is the same as elt(elt(\spad{s},{} \spad{i1}),{} [\spad{i2},{} ...,{} im]).


kind: o
name: elt
exposed: x
type: (%,List(OutputForm))->%
params: dSymbol
comment:
\spad{elt(s,{} [a1,{} ...,{} an])} or \spad{s}([\spad{a1},{} ...,{} an]) returns \spad{s} subscripted by \spad{[a1,{} ...,{} an]}.


kind: o
name: elt
exposed: x
type: (%,Symbol)->Any
params: dLibrary
comment:
\spad{elt(lib,{} k)} or \spad{lib}.\spad{k} extracts the value corresponding to the key \spad{k} from the library \spad{lib}.


kind: o
name: elt
exposed: x
type: (%,Symbol)->String
params: dIndexCard
comment:
\spad{elt(ic,{} s)} selects a particular field from \spad{ic}. Valid fields are \spad{name,{} nargs,{} exposed,{} type,{} abbreviation,{} kind,{} origin,{} params,{} condition,{} doc}.


kind: o
name: elt
exposed: x
type: (%,unique)->%
params: dDataList(S)
comment:
\spad{l.unique} returns \spad{l} with duplicates removed. Note: \spad{l.unique = removeDuplicates(l)}.


kind: o
name: elt
exposed: n
type: (%,Integer,C)->D
params: dSparseEchelonMatrix(C,D)
comment:
\spad{elt(A,{} i,{} c)} returns the entry of the matrix \spad{A} in row \spad{i} and in the column with index \spad{c}.


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


kind: o
name: elt
exposed: x
type: (BasicOperator,%,%)->%
params: cExpressionSpace2(K)
comment:
\spad{elt(op,{} x,{} y)} or \spad{op}(\spad{x},{} \spad{y}) applies the binary operator \spad{op} to \spad{x} and \spad{y}.


kind: o
name: elt
exposed: x
type: (%,Dom,Im)->Im
params: cEltableAggregate(Dom,Im)
comment:
\spad{elt(u,{} x,{} y)} applies \spad{u} to \spad{x} if \spad{x} is in the domain of \spad{u},{} and returns \spad{y} otherwise.


kind: o
name: elt
exposed: x
type: (%,F,F)->F
params: cFunctionFieldCategory(F,UP,UPUP)
comment:
\spad{elt(f,{} a,{} b)} or \spad{f}(a,{} \spad{b}) returns the value of \spad{f} at the point \spad{(x = a,{} y = b)} if it is not singular.


kind: o
name: elt
exposed: x
type: (%,F,PositiveInteger)->F
params: dRewriteRule(Base,R,F)
comment:
\spad{elt(r,{} f,{} n)} or \spad{r}(\spad{f},{} \spad{n}) applies the rule \spad{r} to \spad{f} at most \spad{n} times.


kind: o
name: elt
exposed: x
type: (%,F,PositiveInteger)->F
params: dRuleset(Base,R,F)
comment:
\spad{elt(r,{} f,{} n)} or \spad{r}(\spad{f},{} \spad{n}) applies all the rules of \spad{r} to \spad{f} at most \spad{n} times.


kind: o
name: elt
exposed: x
type: (%,Integer,Integer)->R
params: cRectangularMatrixCategory(m,n,R,Row,Col)
comment:
\spad{elt(m,{} i,{} j)} returns the element in the \spad{i}th row and \spad{j}th column of the matrix \spad{m}. Error: if indices are outside the proper ranges.


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


kind: o
name: elt
exposed: x
type: (%,Integer,List(Integer))->%
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{elt(x,{} row,{} colList)} returns an 1-by-\spad{n} array consisting of elements of \spad{x},{} where \spad{n = \# colList}. If \spad{colList = [j<1>,{} j<2>,{} ...,{} j<n>]},{} then the \spad{(k,{} l)}th entry of \spad{elt(x,{} row,{} colList)} is \spad{x(row,{} j<l>)}.


kind: o
name: elt
exposed: x
type: (%,Integer,List(Segment(Integer)))->%
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{elt(x,{} row,{} ls2)} is equivalent to \spad{elt(x,{} row,{} l2)} where \spad{l2} is obtained appending expansions of elements of \spad{ls2},{} but should be more convenient and more efficient.


kind: o
name: elt
exposed: x
type: (%,List(Integer),Integer)->%
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{elt(x,{} rowList,{} col)} returns an \spad{m}-by-1 array consisting of elements of \spad{x},{} where \spad{m = \# rowList}. If \spad{rowList = [i<1>,{} i<2>,{} ...,{} i<m>]},{} then the \spad{(k,{} l)}th entry of \spad{elt(x,{} rowList,{} col)} is \spad{x(i<k>,{} col)}.


kind: o
name: elt
exposed: x
type: (%,List(Integer),List(Integer))->%
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{elt(x,{} rowList,{} colList)} returns an \spad{m}-by-\spad{n} array consisting of elements of \spad{x},{} where \spad{m = \# rowList} and \spad{n = \# colList}. If \spad{rowList = [i<1>,{} i<2>,{} ...,{} i<m>]} and \spad{colList = [j<1>,{} j<2>,{} ...,{} j<n>]},{} then the \spad{(k,{} l)}th entry of \spad{elt(x,{} rowList,{} colList)} is \spad{x(i<k>,{} j<l>)}.


kind: o
name: elt
exposed: x
type: (%,List(Integer),Segment(Integer))->%
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{elt(x,{} rowList,{} s)} is equivalent to \spad{elt(x,{} rowList,{} expand(s))} but should be more convenient and more efficient.


kind: o
name: elt
exposed: x
type: (%,List(Segment(Integer)),Integer)->%
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{elt(x,{} ls1,{} col)} is equivalent to \spad{elt(x,{} l1,{} col)} where \spad{l1} is obtained appending expansions of elements of \spad{ls1},{} but should be more convenient and more efficient.


kind: o
name: elt
exposed: x
type: (%,List(Segment(Integer)),List(Segment(Integer)))->%
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{elt(x,{} ls1,{} ls2)} is equivalent to \spad{elt(x,{} l1,{} l2)} where \spad{li} is obtained appending expansions of elements of lsi,{} but should be more convenient and more efficient.


kind: o
name: elt
exposed: x
type: (%,List(Segment(Integer)),Segment(Integer))->%
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{elt(x,{} ls1,{} s2)} is equivalent to \spad{elt(x,{} l1,{} l2)} where \spad{li} is obtained appending expansions of elements of lsi,{} but should be more convenient and more efficient.


kind: o
name: elt
exposed: x
type: (%,Segment(Integer),List(Integer))->%
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{elt(x,{} s,{} colList)} is equivalent to \spad{elt(x,{} expand(s),{} colList)} but should be more convenient and more efficient.


kind: o
name: elt
exposed: x
type: (%,Segment(Integer),List(Segment(Integer)))->%
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{elt(x,{} s1,{} ls2)} is equivalent to \spad{elt(x,{} l1,{} l2)} where \spad{li} is obtained appending expansions of elements of lsi,{} but should be more convenient and more efficient.


kind: o
name: elt
exposed: x
type: (%,Segment(Integer),Segment(Integer))->%
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{elt(x,{} s1,{} s2)} is equivalent to \spad{elt(x,{} expand(s1),{} expand(s2))} but should be more convenient and more efficient.


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


kind: o
name: elt
exposed: x
type: (BasicOperator,%,%,%)->%
params: cExpressionSpace2(K)
comment:
\spad{elt(op,{} x,{} y,{} z)} or \spad{op}(\spad{x},{} \spad{y},{} \spad{z}) applies the ternary operator \spad{op} to \spad{x},{} \spad{y} and \spad{z}.


kind: o
name: elt
exposed: x
type: (%,Integer,Integer,R)->R
params: cRectangularMatrixCategory(m,n,R,Row,Col)
comment:
\spad{elt(m,{} i,{} j,{} r)} returns the element in the \spad{i}th row and \spad{j}th column of the matrix \spad{m},{} if \spad{m} has an \spad{i}th row and a \spad{j}th column,{} and returns \spad{r} otherwise.


kind: o
name: elt
exposed: x
type: (%,Integer,Integer,R)->R
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{elt(m,{} i,{} j,{} r)} returns the element in the \spad{i}th row and \spad{j}th column of the array \spad{m},{} if \spad{m} has an \spad{i}th row and a \spad{j}th column,{} and returns \spad{r} otherwise


kind: o
name: elt
exposed: x
type: (BasicOperator,%,%,%,%)->%
params: cExpressionSpace2(K)
comment:
\spad{elt(op,{} x,{} y,{} z,{} t)} or \spad{op}(\spad{x},{} \spad{y},{} \spad{z},{} \spad{t}) applies the 4-ary operator \spad{op} to \spad{x},{} \spad{y},{} \spad{z} and \spad{t}.


kind: o
name: elt
exposed: x
type: (BasicOperator,%,%,%,%,%)->%
params: cExpressionSpace2(K)
comment:
\spad{elt(op,{} x,{} y,{} z,{} t,{} s)} applies the 5-ary operator \spad{op} to \spad{x},{} \spad{y},{} \spad{z},{} \spad{t} and \spad{s}


kind: o
name: elt
exposed: x
type: (BasicOperator,%,%,%,%,%,%)->%
params: cExpressionSpace2(K)
comment:
\spad{elt(op,{} x,{} y,{} z,{} t,{} s,{} r)} applies the 6-ary operator \spad{op} to \spad{x},{} \spad{y},{} \spad{z},{} \spad{t},{} \spad{s} and \spad{r}


kind: o
name: elt
exposed: x
type: (BasicOperator,%,%,%,%,%,%,%)->%
params: cExpressionSpace2(K)
comment:
\spad{elt(op,{} x,{} y,{} z,{} t,{} s,{} r,{} q)} applies the 7-ary operator \spad{op} to \spad{x},{} \spad{y},{} \spad{z},{} \spad{t},{} \spad{s},{} \spad{r} and \spad{q}


kind: o
name: elt
exposed: x
type: (BasicOperator,%,%,%,%,%,%,%,%)->%
params: cExpressionSpace2(K)
comment:
\spad{elt(op,{} x,{} y,{} z,{} t,{} s,{} r,{} q,{} p)} applies the 8-ary operator \spad{op} to \spad{x},{} \spad{y},{} \spad{z},{} \spad{t},{} \spad{s},{} \spad{r},{} \spad{q} and \spad{p}


kind: o
name: empty
exposed: x
type: ()->%
params: cAggregate
comment:
\spad{empty()}\$\spad{D} creates an aggregate of type \spad{D} with 0 elements. Note: The {\em \$D} can be dropped if understood by context,{} \spadignore{e.g.} \spad{u: D := empty()}.


kind: o
name: empty?
exposed: n
type: (%)->Boolean
params: dQuasiAlgebraicSet(R,Var,Expon,Dpoly)
comment:
\spad{empty?(s)} returns \spad{true} if the quasialgebraic set \spad{s} has no points,{} and \spad{false} otherwise.


kind: o
name: endOfFile?
exposed: x
type: (%)->Boolean
params: dTextFile
comment:
\spad{endOfFile?(f)} tests whether the file \spad{f} is positioned after the end of all text. If the file is open for output,{} then this test is always \spad{true}.


kind: o
name: enterInCache
exposed: n
type: (S,(S)->Boolean)->S
params: pSortedCache(S)
comment:
\spad{enterInCache(x,{} f)} enters \spad{x} in the cache,{} calling \spad{f(y)} to determine whether \spad{x} is equal to \spad{y}. It returns \spad{x} with an integer associated with it.


kind: o
name: enterInCache
exposed: n
type: (S,(S,S)->Integer)->S
params: pSortedCache(S)
comment:
\spad{enterInCache(x,{} f)} enters \spad{x} in the cache,{} calling \spad{f(x,{} y)} to determine whether \spad{x < y (f(x,{} y) < 0),{} x = y (f(x,{} y) = 0)},{} or \spad{x > y (f(x,{} y) > 0)}. It returns \spad{x} with an integer associated with it.


kind: o
name: enterPointData
exposed: x
type: (%,List(Point(R)))->NonNegativeInteger
params: cThreeSpaceCategory(R)
comment:
\spad{enterPointData(s,{} [p0,{} p1,{} ...,{} pn])} adds a list of points from \spad{p0} through \spad{pn} to the \spadtype{ThreeSpace},{} \spad{s},{} and returns the index,{} to the starting point of the list.


kind: o
name: environment
exposed: n
type: (String,String,String,(Integer,List(OutputForm))->OutputBox)->(Integer,List(OutputForm))->OutputBox
params: dFormatLaTeX
comment:
\spad{environmnt(env,{} x,{} sep)} returns a handler that typesets its arguments (without parentheses) in a \LaTeX{} environment with name \spad{env}. The string \spad{x} is put right after the start of the environment. The arguments are separated by the string \spad{sep}.


kind: o
name: epilogue
exposed: n
type: (%)->OutputBox
params: dFormatter(F)
comment:
\spad{epilogue(t)} extracts the epilogue section of the form \spad{t}. This is a function \spad{f} such that \spad{f}(\spad{l}) returns a box with label \spad{l}.


kind: o
name: eqRep?
exposed: n
type: (%,%)->Boolean
params: dJetLazyFunction(JB,D)
comment:
\spad{eqRep?(x,{} y)} compares the representations of \spad{x} and \spad{y} without any evaluation. Thus it is much weaker than \spad{=} and cannot decide equality of the evaluated expressions.


kind: o
name: equal?
exposed: n
type: (%,List(NonNegativeInteger),%,List(NonNegativeInteger))->Boolean
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{equal?(p,{} pos_p,{} q,{} pos_q)} checks,{} if the matrices \spad{pos_p} in \spad{p} are equal to the pos_q in \spad{q}. Not specified matrices have to be zero.


kind: o
name: equality
exposed: x
type: (%,(%,%)->Boolean)->%
params: dBasicOperator
comment:
\spad{equality(op,{} foo?)} attaches foo? as the \%equal? property to \spad{op}. If \spad{op1} and \spad{op2} have the same name,{} and one of them has an \%equal? property \spad{f},{} then \spad{f(op1,{} op2)} is called to decide whether \spad{op1} and \spad{op2} should be considered equal.


kind: o
name: equation
exposed: x
type: (Symbol,Segment(S))->%
params: dSegmentBinding(S)
comment:
\spad{equation(v,{} a..b)} creates a segment binding value with variable \spad{v} and segment \spad{a..b}. Note that the interpreter parses \spad{v=a..b} to this form.


kind: o
name: erf
exposed: x
type: (%)->%
params: cLiouvillianFunctionCategory
comment:
\spad{erf(x)} returns the error function of \spad{x},{} \spadignore{i.e.} \spad{2 / sqrt(\%\spad{pi})} times the integral of \spad{exp(-x^2) dx}.


kind: o
name: error
exposed: x
type: (String,List(String))->Exit
params: pErrorFunctions
comment:
\spad{error(nam,{} lmsg)} displays error messages lmsg preceded by a message containing the name \spad{nam} of the function in which the error is contained.


kind: o
name: error
exposed: x
type: (String,String)->Exit
params: pErrorFunctions
comment:
\spad{error(nam,{} msg)} displays error message \spad{msg} preceded by a message containing the name \spad{nam} of the function in which the error is contained.


kind: o
name: euclideanGroebner
exposed: x
type: (List(Dpol))->List(Dpol)
params: pEuclideanGroebnerBasisPackage(Dom,Expon,VarSet,Dpol)
comment:
\spad{euclideanGroebner(lp)} computes a groebner basis for a polynomial ideal over a euclidean domain generated by the list of polynomials \spad{lp}.


kind: o
name: euclideanGroebner
exposed: x
type: (List(Dpol),String)->List(Dpol)
params: pEuclideanGroebnerBasisPackage(Dom,Expon,VarSet,Dpol)
comment:
\spad{euclideanGroebner(lp,{} infoflag)} computes a groebner basis for a polynomial ideal over a euclidean domain generated by the list of polynomials \spad{lp}. During computation,{} additional information is printed out if infoflag is given as either info (for summary information) or redcrit (for reduced critical pairs)


kind: o
name: euclideanGroebner
exposed: x
type: (List(Dpol),String,String)->List(Dpol)
params: pEuclideanGroebnerBasisPackage(Dom,Expon,VarSet,Dpol)
comment:
\spad{euclideanGroebner(lp,{} info,{} redcrit)} computes a groebner basis for a polynomial ideal generated by the list of polynomials \spad{lp}. If the second argument is \spad{info},{} a summary is given of the critical pairs. If the third argument is redcrit,{} critical pairs are printed.


kind: o
name: euclideanNormalForm
exposed: x
type: (Dpol,List(Dpol))->Dpol
params: pEuclideanGroebnerBasisPackage(Dom,Expon,VarSet,Dpol)
comment:
\spad{euclideanNormalForm(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: euclideanSize
exposed: x
type: (%)->NonNegativeInteger
params: cEuclideanDomain
comment:
\spad{euclideanSize(x)} returns the euclidean size of the element \spad{x}. Error: if \spad{x} is zero.


kind: o
name: euler
exposed: n
type: (Integer)->SparseUnivariatePolynomial(Fraction(Integer))
params: pPolynomialNumberTheoryFunctions
comment:
\spad{euler(n)} returns the \spad{n}th Euler polynomial \spad{E[n](x)}. Note: Euler polynomials denoted \spad{E(n,{} x)} are computed by solving the differential equation \spad{differentiate(E(n,{} x),{} x) = n E(n-1,{} x)} where \spad{E(0,{} x) = 1} and initial condition comes from \spad{E(n) = 2^n E(n,{} 1/2)}.


kind: o
name: euler
exposed: x
type: (Integer)->Integer
params: pIntegerNumberTheoryFunctions
comment:
\spad{euler(n)} returns the \spad{n}th Euler number. This is \spad{2^n E(n,{} 1/2)},{} where \spad{E(n,{} x)} is the \spad{n}th Euler polynomial.


kind: o
name: eulerPhi
exposed: x
type: (Integer)->Integer
params: pIntegerNumberTheoryFunctions
comment:
\spad{eulerPhi(n)} returns the number of integers between 1 and \spad{n} (including 1) which are relatively prime to \spad{n}. This is the Euler phi function \spad{phi(n)} is also called the totient function.


kind: o
name: eval1
exposed: n
type: (%)->%
params: dJetLazyFunction(JB,D)
comment:
\spad{eval1(exp)} explicitly evaluates the next term in \spad{exp}. \spad{exp} is destructively altered.


kind: o
name: eval1
exposed: n
params: cModularEvaluationCategory(PT,MP)
type:
(MP,Symbol,Integer,Record(prime:Integer,eval1coeffbuf:U32Vector,eval1expbuf:SortedExponentVector))->Union(MP,failed)

comment:
\spad{eval1(p,{} v,{} r,{} pss)} evaluates \spad{p} with respect to single variable \spad{v} at \spad{r}. \spad{pss} is global state.


kind: o
name: eval1
exposed: n
params: pPolynomialEvaluationUtilities
type:
(Polynomial(Integer),Symbol,Integer,Record(prime:Integer,eval1coeffbuf:U32Vector,eval1expbuf:SortedExponentVector))->Polynomial(Integer)

comment:
\spad{eval1(pol,{} v,{} pt,{} pss)} evaluates \spad{pol} in variable \spad{v} at \spad{pt},{} using global state form \spad{pss}. Computations are done modulo a prime contained in \spad{pss}.


kind: o
name: eval1
exposed: n
params: pPolynomialEvaluationUtilities
type:
(Record(numer:Polynomial(Integer),denom:Polynomial(Integer)),Symbol,Integer,Record(prime:Integer,eval1coeffbuf:U32Vector,eval1expbuf:SortedExponentVector))->Union(Record(numer:Polynomial(Integer),denom:Polynomial(Integer)),failed)

comment:
\spad{eval1(pq,{} v,{} pt,{} pss)} evaluates fraction of polynomial \spad{pq} in variable \spad{v} at \spad{pt},{} using global state form \spad{pss}. Computations are done modulo a prime contained in \spad{pss}.


kind: o
name: eval1a
exposed: n
params: pPolynomialEvaluationUtilities
type:
(Polynomial(Integer),Integer,Record(prime:Integer,eval1coeffbuf:U32Vector,eval1expbuf:SortedExponentVector))->Integer

comment:
\spad{eval1a(pol,{} pt,{} pss)} evaluates polynomial \spad{pol} at point \spad{pt} using global state form \spad{pss}. Computations are done modulo a prime contained in \spad{pss}. Note: \spad{pol} must have at most one variable.


kind: o
name: eval
exposed: n
type: (%,F)->F
params: dMoebiusTransform(F)
comment:
\spad{eval(m,{} x)} returns \spad{(a*x + b)/(c*x + d)} where \spad{m = moebius(a,{} b,{} c,{} d)} (see \spadfunFrom{moebius}{MoebiusTransform}).


kind: o
name: eval
exposed: n
type: ((Integer)->F,SymmetricPolynomial(Fraction(Integer)))->F
params: pEvaluateCycleIndicators(F)
comment:
\spad{eval(f,{} s)} evaluates the cycle index \spad{s} by applying \indented{1}{the function \spad{f} to each integer in a monomial partition,{}} \indented{1}{forms their product and sums the results over all monomials.}


kind: o
name: eval
exposed: n
type: (Stream(A),A)->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{eval(a,{} r)} returns a stream of partial sums of the power series \spad{a} evaluated at the power series variable equal to \spad{r}.


kind: o
name: eval
exposed: x
type: (%,Coef)->Stream(Coef)
params: cUnivariatePowerSeriesCategory(Coef,Expon)
abbrev: has(Coef,SIGNATURE(^,Coef(Coef,Expon)))
comment:
\spad{eval(f,{} a)} evaluates a power series at a value in the ground ring by returning a stream of partial sums.


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


kind: o
name: eval
exposed: x
type: (Fraction(Polynomial(R)),Equation(Fraction(Polynomial(R))))->Fraction(Polynomial(R))
params: pRationalFunction(R)
comment:
\spad{eval(f,{} v = g)} returns \spad{f} with \spad{v} replaced by \spad{g}. Error: if \spad{v} is not a symbol.


kind: o
name: eval
exposed: x
type: (Fraction(Polynomial(R)),List(Equation(Fraction(Polynomial(R)))))->Fraction(Polynomial(R))
params: pRationalFunction(R)
comment:
\spad{eval(f,{} [v1 = g1,{} ...,{} vn = gn])} returns \spad{f} with each \spad{vi} replaced by \spad{gi} in parallel,{} \spadignore{i.e.} \spad{vi}\spad{'s} appearing inside the \spad{gi}\spad{'s} are not replaced. Error: if any \spad{vi} is not a symbol.


kind: o
name: eval
exposed: x
type: (%,BasicOperator,(List(%))->%)->%
params: cExpressionSpace2(K)
comment:
\spad{eval(x,{} s,{} f)} replaces every \spad{s(a1,{} ..,{} am)} in \spad{x} by \spad{f(a1,{} ..,{} am)} for any \spad{a1},{} ...,{} \spad{am}.


kind: o
name: eval
exposed: x
type: (Fraction(Polynomial(R)),List(Symbol),List(Fraction(Polynomial(R))))->Fraction(Polynomial(R))
params: pRationalFunction(R)
comment:
\spad{eval(f,{} [v1,{} ...,{} vn],{} [g1,{} ...,{} gn])} returns \spad{f} with each \spad{vi} replaced by \spad{gi} in parallel,{} \spadignore{i.e.} \spad{vi}\spad{'s} appearing inside the \spad{gi}\spad{'s} are not replaced.


kind: o
name: eval
exposed: x
type: (%,List(A),List(B))->%
params: cInnerEvalable(A,B)
comment:
\spad{eval(f,{} [x1,{} ...,{} xn],{} [v1,{} ...,{} vn])} replaces \spad{xi} by \spad{vi} in \spad{f}.


kind: o
name: eval
exposed: x
type: (%,List(BasicOperator),List((%)->%))->%
params: cExpressionSpace2(K)
comment:
\spad{eval(x,{} [s1,{} ...,{} sm],{} [f1,{} ...,{} fm])} replaces every \spad{\spad{si}(a)} in \spad{x} by \spad{\spad{fi}(a)} for any \spad{a}.


kind: o
name: eval
exposed: x
type: (%,List(BasicOperator),List((List(%))->%))->%
params: cExpressionSpace2(K)
comment:
\spad{eval(x,{} [s1,{} ...,{} sm],{} [f1,{} ...,{} fm])} replaces every \spad{\spad{si}(a1,{} ...,{} an)} in \spad{x} by \spad{\spad{fi}(a1,{} ...,{} an)} for any \spad{a1},{} ...,{} \spad{an}.


kind: o
name: eval
exposed: x
type: (%,List(VarSet),List(%))->%
params: cFreeLieAlgebra(VarSet,R)
comment:
\spad{eval(p,{} [x1,{} ...,{} xn],{} [v1,{} ...,{} vn])} replaces \spad{\spad{xi}} by \spad{\spad{vi}} in \spad{p}.


kind: o
name: eval
exposed: x
type: (%,BasicOperator,%,Symbol)->%
params: cFunctionSpace2(R,K)
abbrev: has(R,ConvertibleTo(InputForm))
comment:
\spad{eval(x,{} s,{} f,{} y)} replaces every \spad{s(a)} in \spad{x} by \spad{f(y)} with \spad{y} replaced by \spad{a} for any \spad{a}.


kind: o
name: eval
exposed: x
type: (%,List(BasicOperator),List(%),Symbol)->%
params: cFunctionSpace2(R,K)
abbrev: has(R,ConvertibleTo(InputForm))
comment:
\spad{eval(x,{} [s1,{} ...,{} sm],{} [f1,{} ...,{} fm],{} y)} replaces every \spad{\spad{si}(a)} in \spad{x} by \spad{\spad{fi}(y)} with \spad{y} replaced by \spad{a} for any \spad{a}.


kind: o
name: eval
exposed: x
type: (%,List(Symbol),List(NonNegativeInteger),List((%)->%))->%
params: cFunctionSpace2(R,K)
abbrev: has(R,Ring)
comment:
\spad{eval(x,{} [s1,{} ...,{} sm],{} [n1,{} ...,{} nm],{} [f1,{} ...,{} fm])} replaces every \spad{\spad{si}(a)^ni} in \spad{x} by \spad{\spad{fi}(a)} for any \spad{a}.


kind: o
name: eval
exposed: x
type: (%,List(Symbol),List(NonNegativeInteger),List((List(%))->%))->%
params: cFunctionSpace2(R,K)
abbrev: has(R,Ring)
comment:
\spad{eval(x,{} [s1,{} ...,{} sm],{} [n1,{} ...,{} nm],{} [f1,{} ...,{} fm])} replaces every \spad{\spad{si}(a1,{} ...,{} an)^ni} in \spad{x} by \spad{\spad{fi}(a1,{} ...,{} an)} for any \spad{a1},{} ...,{} am.


kind: o
name: eval
exposed: x
type: (%,Symbol,NonNegativeInteger,(%)->%)->%
params: cFunctionSpace2(R,K)
abbrev: has(R,Ring)
comment:
\spad{eval(x,{} s,{} n,{} f)} replaces every \spad{s(a)^n} in \spad{x} by \spad{f(a)} for any \spad{a}.


kind: o
name: eval
exposed: x
type: (%,Symbol,NonNegativeInteger,(List(%))->%)->%
params: cFunctionSpace2(R,K)
abbrev: has(R,Ring)
comment:
\spad{eval(x,{} s,{} n,{} f)} replaces every \spad{s(a1,{} ...,{} am)^n} in \spad{x} by \spad{f(a1,{} ...,{} am)} for any \spad{a1},{} ...,{} am.


kind: o
name: eval_at
exposed: n
type: (U32Vector,Integer,Integer,Integer)->Integer
params: pU32VectorPolynomialOperations
comment:
\spad{eval_at(v,{} deg,{} pt,{} p)} treats \spad{v} as coefficients of polynomial of degree \spad{deg} and evaluates the polynomial at point \spad{pt} modulo \spad{p}


kind: o
name: evaluate
exposed: x
type: (BasicOperator)->Union((List(A))->A,failed)
params: pBasicOperatorFunctions1(A)
comment:
\spad{evaluate(op)} returns the value of the \%eval property of \spad{op} if it has one,{} and failed otherwise.


kind: o
name: evaluate
exposed: x
type: (BasicOperator,(A)->A)->BasicOperator
params: pBasicOperatorFunctions1(A)
comment:
\spad{evaluate(op,{} foo)} attaches foo as the \%eval property of \spad{op}. If \spad{op} has an \%eval property \spad{f},{} then applying \spad{op} to a returns the result of \spad{f(a)}. Argument \spad{op} must be unary.


kind: o
name: evaluate
exposed: x
type: (BasicOperator,(List(A))->A)->BasicOperator
params: pBasicOperatorFunctions1(A)
comment:
\spad{evaluate(op,{} foo)} attaches foo as the \%eval property of \spad{op}. If \spad{op} has an \%eval property \spad{f},{} then applying \spad{op} to \spad{(a1,{} ...,{} an)} returns the result of \spad{f(a1,{} ...,{} an)}.


kind: o
name: evaluate
exposed: x
type: (BasicOperator,List(A))->Union(A,failed)
params: pBasicOperatorFunctions1(A)
comment:
\spad{evaluate(op,{} [a1,{}...,{}an])} checks if \spad{op} has an \%eval property \spad{f}. If it has,{} then \spad{f(a1,{} ...,{} an)} is returned,{} and failed otherwise.


kind: o
name: evaluate
exposed: x
type: (%,(M)->M)->%
params: dModuleOperator(R,M)
comment:
\spad{evaluate(f,{} u +-> g u)} attaches the map \spad{g} to \spad{f}. \spad{f} must be a basic operator \spad{g} MUST be additive,{} \spadignore{i.e.} \spad{g(a + b) = g(a) + g(b)} for any \spad{a},{} \spad{b} in \spad{M}. This implies that \spad{g(n a) = n g(a)} for any \spad{a} in \spad{M} and integer \spad{n > 0}.


kind: o
name: eval_with_timeout
exposed: n
type: (()->S,Integer)->Union(S,failed)
params: pTimeoutPackage(S)
comment:
\spad{eval_with_timeout(f,{} t)} calls \spad{f} with timeout of \spad{t} seconds. Returns value computed by \spad{f} or failed if \spad{f} did not finish within \spad{t} seconds.


kind: o
name: even?
exposed: x
type: (%)->Boolean
params: dPermutation(S)
comment:
\spad{even?(p)} returns \spad{true} if and only if \spad{p} is an even permutation,{} \spadignore{i.e.} {\em sign(p)} is 1.


kind: o
name: evenInfiniteProduct
exposed: x
type: (UTS)->UTS
params: pInfiniteLambertProduct(Coef,UTS)
comment:
\spad{evenInfiniteProduct(f(x))} computes \spad{product(n=2,{} 4,{} 6...,{} f(x^n))}. The series \spad{f(x)} should have constant coefficient 1.


kind: o
name: evenlambert
exposed: n
type: (%)->%
params: dUnivariateTaylorSeries(Coef,var,cen)
comment:
\spad{evenlambert(f(x))} returns \spad{f(x^2) + f(x^4) + f(x^6) + ...}. \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))) = exp(evenlambert(log(f(x))))}.}


kind: o
name: evenlambert
exposed: n
type: (Stream(A))->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{evenlambert(st)} computes \spad{f(x^2) + f(x^4) + f(x^6) + ...} 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^(2*n)),{} n=1..infinity) = exp(evenlambert(log(f(x))))}.


kind: o
name: every?
exposed: x
type: ((S)->Boolean,%)->Boolean
params: cHomogeneousAggregate(S)
abbrev: has(%,finiteAggregate)
comment:
\spad{every?(p,{} u)} tests if \spad{p}(\spad{x}) is \spad{true} for all elements \spad{x} of \spad{u}. Note: for collections,{} \spad{every?(p,{} u) = reduce(and,{} map(p,{} u),{} true,{} false)}. However,{} \spad{every?(p,{} u)} returns as soon as it finds an element for which \spad{p} gives \spad{false}.


kind: o
name: exactQuotient
exposed: x
type: (%,%)->%
params: cRecursivePolynomialCategory(R,E,V)
abbrev: has(R,IntegralDomain)
comment:
\spad{exactQuotient(a,{} b)} computes the exact quotient of \spad{a} by \spad{b},{} which is assumed to be a divisor of \spad{a}. No error is returned if this exact quotient fails!


kind: o
name: exactQuotient
exposed: x
type: (%,R)->%
params: cRecursivePolynomialCategory(R,E,V)
abbrev: has(R,IntegralDomain)
comment:
\spad{exactQuotient(p,{} r)} computes the exact quotient of \spad{p} by \spad{r},{} which is assumed to be a divisor of \spad{p}. No error is returned if this exact quotient fails!


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


kind: o
name: exp
exposed: n
params: pFloatElementaryFunctions
comment: \spad{exp(x,{} b)} computes approximation to exp(\spad{x}) accurate to at least \spad{b} bits.
type:
(Record(mantissa:Integer,exponent:Integer),PositiveInteger)->Record(mantissa:Integer,exponent:Integer)


kind: o
name: expand
exposed: x
type: (F)->F
params: pTranscendentalManipulations(R,F)
comment:
\spad{expand(f)} performs the following expansions on \spad{f:} \begin{items} \item 1. logs of products are expanded into sums of logs. \item 2. trigonometric and hyperbolic trigonometric functions of sums are expanded into sums of products of trigonometric and hyperbolic trigonometric functions. \item 3. formal powers of the form \spad{(a/b)^c} are expanded into \spad{a^c * b^(-c)}. \end{items}


kind: o
name: expand
exposed: x
type: (%)->L
params: cSegmentExpansionCategory(S,L)
comment:
\spad{expand(l..h by k)} creates value of type \spad{L} with elements \spad{l,{} l+k,{} ... lN} where \spad{lN <= h < lN+k}. For example,{} \spad{expand(1..5 by 2) = [1,{} 3,{} 5]}.


kind: o
name: expand
exposed: x
type: (List(%))->L
params: cSegmentExpansionCategory(S,L)
comment:
\spad{expand(l)} creates a new value of type \spad{L} in which each segment \spad{l..h by k} is replaced with \spad{l,{} l+k,{} ... lN},{} where \spad{lN <= h < lN+k}. For example,{} \spad{expand [1..4,{} 7..9] = [1,{} 2,{} 3,{} 4,{} 7,{} 8,{} 9]}.


kind: o
name: expand
exposed: x
type: (%)->R
params: dFactored(R)
comment:
\spad{expand(f)} multiplies the unit and factors together,{} yielding an unfactored object. Note: this is purposely not called \spadfun{coerce} which would cause the interpreter to do this automatically.


kind: o
name: expand
exposed: x
type: (IntegrationResult(Fraction(Polynomial(R))),Symbol)->List(Expression(R))
params: pIntegrationResultRFToFunction(R)
comment:
\spad{expand(i,{} x)} returns the list of possible real functions of \spad{x} corresponding to \spad{i}.


kind: o
name: expandLog
exposed: x
type: (F)->F
params: pTranscendentalManipulations(R,F)
comment:
\spad{expandLog(f)} converts every \spad{log(a/b)} appearing in \spad{f} into \spad{log(a) - log(b)},{} and every \spad{log(a*b)} into \spad{log(a) + log(b)}.


kind: o
name: expandPower
exposed: x
type: (F)->F
params: pTranscendentalManipulations(R,F)
comment:
\spad{expandPower(f)} converts every power \spad{(a/b)^c} appearing in \spad{f} into \spad{a^c * b^(-c)}.


kind: o
name: expandTrigProducts
exposed: x
type: (F)->F
params: pTranscendentalManipulations(R,F)
abbrev:
AND(has(R,ConvertibleTo(Pattern(R))),has(R,PatternMatchable(R)),has(F,ConvertibleTo(Pattern(R))),has(F,PatternMatchable(R)))

comment:
\spad{expandTrigProducts(e)} replaces \spad{sin(x)*sin(y)} by \spad{(cos(x-y)-cos(x+y))/2},{} \spad{cos(x)*cos(y)} by \spad{(cos(x-y)+cos(x+y))/2},{} and \spad{sin(x)*cos(y)} by \spad{(sin(x-y)+sin(x+y))/2}. Note: this operation uses pattern matcher,{} so it is relatively expensive. To avoid getting into an infinite loop the transformations are applied at most ten times.


kind: o
name: expextint
exposed: n
params: pParametricTranscendentalIntegration(F,UP)
type:
((UP)->UP,(Integer,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{expextint(',{} rde,{} csolve,{} [g1,{} ...,{} gn])} returns a basis of solution of the homogeneous system \spad{h' + c1*g1 + ... + cn*gn = 0} Argument foo is an parametric \spad{rde} solver on \spad{F}. \spad{csolve} is solver over constants.


kind: o
name: expintegrate
exposed: n
params: pTranscendentalIntegration(F,UP)
type:
(Fraction(UP),(UP)->UP,(Fraction(UP))->Record(answer:Fraction(UP),logpart:Fraction(UP),ir:IntegrationResult(Fraction(UP))),(Integer,F)->Record(ans:F,right:F,primpart:F,sol?:Boolean))->Record(answer:IntegrationResult(Fraction(UP)),a0:F)

comment:
\spad{expintegrate(f,{} ',{} foo)} returns \spad{[g,{} a]} such that \spad{f = g' + a},{} and \spad{a = 0} or \spad{a} has no integral in \spad{F}; Argument foo is a Risch differential equation solver on \spad{F}.


kind: o
name: explicitEntries?
exposed: x
type: (%)->Boolean
params: cLazyStreamAggregate(S)
comment:
\spad{explicitEntries?(s)} returns \spad{true} if the stream \spad{s} has explicitly computed entries,{} and \spad{false} otherwise.


kind: o
name: explicitlyEmpty?
exposed: x
type: (%)->Boolean
params: cLazyStreamAggregate(S)
comment:
\spad{explicitlyEmpty?(s)} returns \spad{true} if the stream is an (explicitly) empty stream. Note: this is a null test which will not cause lazy evaluation.


kind: o
name: explicitlyFinite?
exposed: x
type: (%)->Boolean
params: cStreamAggregate(S)
comment:
\spad{explicitlyFinite?(s)} tests if the stream has a finite number of elements,{} and \spad{false} otherwise. Note: for many datatypes,{} \spad{explicitlyFinite?(s) = not possiblyInfinite?(s)}.


kind: o
name: explogs2trigs
exposed: n
type: (FG)->Complex(F)
params: pInnerTrigonometricManipulations(R,F,FG)
comment:
\spad{explogs2trigs(f)} rewrites all the complex logs and exponentials appearing in \spad{f} in terms of trigonometric functions.


kind: o
name: exp_lower_bound
exposed: n
params: pParametricRischDE(R,F)
type:
(SparseUnivariatePolynomial(F),LaurentPolynomial(F,SparseUnivariatePolynomial(F)),Integer,Integer,List(Kernel(F)),F,(List(Kernel(F)),List(F))->Record(logands:List(F),basis:List(Vector(Fraction(Integer)))))->Integer

comment:
\spad{exp_lower_bound(a,{} b,{} ob,{} nc0,{} lk,{} eta,{} logi)} computes lower degree bound for solution of \spad{a*D(y) + b*y = c} in exponential case. \spad{ob} is order of \spad{b},{} \spad{nc0} is lower bound on order of \spad{c},{} \spad{eta} is derivative of the argument of exponential.


kind: o
name: exponent
exposed: n
type: (%)->NonNegativeInteger
params: dIntegerLocalizedAtPrime(p)
comment:
Each element \spad{x} can be written as x=p^n*a/b with \spad{gcd}(\spad{p},{}a)=gcd(\spad{p},{}\spad{b})\spad{=1}. exponent(\spad{x}) returns \spad{n}.


kind: o
name: exponenta
exposed: n
type: (%)->Integer
params: dDihedralGroup(n,a,b)
comment:
\spad{exponenta(x)} returns the exponent of the rotation a in the normal form of \spad{x} as integer


kind: o
name: exponentb
exposed: n
type: (%)->Integer
params: dDihedralGroup(n,a,b)
comment:
\spad{exponentb(x)} returns the exponent of the reflection \spad{b} in the normal form of \spad{x} as integer


kind: o
name: exponential
exposed: n
type: (UnivariatePuiseuxSeries(FE,var,cen))->%
params: dExponentialOfUnivariatePuiseuxSeries(FE,var,cen)
comment:
\spad{exponential(f(x))} returns \spad{exp(f(x))}. Note: the function does NOT check that \spad{f(x)} has no non-negative terms.


kind: o
name: exponentialOrder
exposed: n
type: (%)->Fraction(Integer)
params: dExponentialOfUnivariatePuiseuxSeries(FE,var,cen)
comment:
\spad{exponentialOrder(exp(c * x ^(-n) + ...))} returns \spad{-n}. exponentialOrder(0) returns \spad{0}.


kind: o
name: exponents
exposed: n
type: (%)->List(Integer)
params: dExtAlgBasis
comment:
\spad{exponents(x)} converts a domain element into a list of zeros and ones corresponding to the exponents in the basis element that \spad{x} represents.


kind: o
name: expPot
exposed: n
type: (Vector(GF),SingleInteger,SingleInteger)->Vector(GF)
params: pInnerNormalBasisFieldFunctions(GF)
comment:
\spad{expPot(v,{} e,{} d)} returns the sum from \spad{i = 0} to \spad{e - 1} of \spad{v^(q^i*d)},{} interpreting \spad{v} as an element of a normal basis field and where \spad{q} is the size of the ground field. Note: for a description of the algorithm,{} see \spad{T}.Itoh and \spad{S}.Tsujii,{} A fast algorithm for computing multiplicative inverses in \spad{GF}(2^m) using normal bases,{} Information and Computation 78,{} \spad{pp}.171-177,{} 1988.


kind: o
name: expressIdealMember
exposed: x
type: (List(%),%)->Union(List(%),failed)
params: cPrincipalIdealDomain
comment:
\spad{expressIdealMember([f1,{} ...,{} fn],{} h)} returns a representation of \spad{h} as a linear combination of the \spad{fi} or failed if \spad{h} is not in the ideal generated by the \spad{fi}.


kind: o
name: exprToGenUPS
exposed: n
params: pFunctionSpaceToUnivariatePowerSeries2(R,FE,Expon,UPS,TRAN,UTS,TEXP,coerce_Ex,x)
type:
(FE,Boolean,Union(complex,real: two sides,real: left side,real: right side,just do it))->Union(%series:UPS,%problem:Record(func:String,prob:String))

comment:
\spad{exprToGenUPS(fcn,{} posCheck?,{} atanFlag)} converts the expression \spad{fcn} to a generalized power series. If \spad{posCheck?} is \spad{true},{} log\spad{'s} of negative numbers are not allowed nor are \spad{n}th roots of negative numbers with \spad{n} even. If \spad{posCheck?} is \spad{false},{} these are allowed. \spad{atanFlag} determines how the case \spad{atan(f(x))},{} where \spad{f(x)} has a pole,{} will be treated. The possible values of \spad{atanFlag} are \spad{complex},{} \spad{real: two sides},{} \spad{real: left side},{} \spad{real: right side},{} and \spad{just do it}. If \spad{atanFlag} is \spad{complex},{} then no series expansion will be computed because,{} viewed as a function of a complex variable,{} \spad{atan(f(x))} has an essential singularity. Otherwise,{} the sign of the leading coefficient of the series expansion of \spad{f(x)} determines the constant coefficient in the series expansion of \spad{atan(f(x))}. If this sign cannot be determined,{} a series expansion is computed only when \spad{atanFlag} is \spad{just do it}. When the leading term in the series expansion of \spad{f(x)} is of odd degree (or is a rational degree with odd numerator),{} then the constant coefficient in the series expansion of \spad{atan(f(x))} for values to the left differs from that for values to the right. If \spad{atanFlag} is \spad{real: two sides},{} no series expansion will be computed. If \spad{atanFlag} is \spad{real: left side} the constant coefficient for values to the left will be used and if \spad{atanFlag} \spad{real: right side} the constant coefficient for values to the right will be used. If there is a problem in converting the function to a power series,{} we return a record containing the name of the function that caused the problem and a brief description of the problem. When expanding the expression into a series it is assumed that the series is centered at 0. For a series centered at a,{} the user should perform the substitution \spad{x -> x + a} before calling this function.


kind: o
name: exprToPS
exposed: n
params: pFunctionSpaceToUnivariatePowerSeries2(R,FE,Expon,UPS,TRAN,UTS,TEXP,coerce_Ex,x)
type:
(FE,Boolean,Union(complex,real: two sides,real: left side,real: right side,just do it),Boolean,FE)->Union(%series:UPS,%problem:Record(func:String,prob:String))

comment:
\spad{exprToPS(fcn,{} posCheck?,{} atanFlag,{} log_flag,{} log_val)} is like exprToUPS,{} but if \spad{log_flag} is \spad{true} it replaces logarithms of expansion variable by \spad{log_val}


kind: o
name: exprToPS
exposed: n
params: pFunctionSpaceToUnivariatePowerSeries2(R,FE,Expon,UPS,TRAN,UTS,TEXP,coerce_Ex,x)
type:
(FE,Boolean,Union(complex,real: two sides,real: left side,real: right side,just do it),Boolean,FE,(FE)->Boolean,(FE)->Boolean,(FE)->Boolean)->Union(%series:UPS,%problem:Record(func:String,prob:String))

comment:
exprToPS(\spad{fcn},{} posCheck?,{} atanFlag,{} log_flag,{} log_val,{} coef_chk,{} inv_chk,{} zero_chk) is like exprToPS(\spad{fcn},{} posCheck?,{} atanFlag,{} log_flag,{} log_val),{} but fails if \spad{coef_chk} is \spad{false} for some coefficient of \spad{fcn} or if expansion process needs to invert element of \spad{FE} for which \spad{inv_chk} is \spad{false}


kind: o
name: expr_to_series
exposed: n
params: pMrvLimitPackage
comment: \spad{expr_to_series computes} degree and leading coefficinet of series expansion.
type:
(Expression(Integer),Kernel(Expression(Integer)),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: exprToUPS
exposed: n
params: pFunctionSpaceToUnivariatePowerSeries2(R,FE,Expon,UPS,TRAN,UTS,TEXP,coerce_Ex,x)
type:
(FE,Boolean,Union(complex,real: two sides,real: left side,real: right side,just do it))->Union(%series:UPS,%problem:Record(func:String,prob:String))

comment:
\spad{exprToUPS(fcn,{} posCheck?,{} atanFlag)} converts the expression \spad{fcn} to a power series. If \spad{posCheck?} is \spad{true},{} log\spad{'s} of negative numbers are not allowed nor are \spad{n}th roots of negative numbers with \spad{n} even. If \spad{posCheck?} is \spad{false},{} these are allowed. \spad{atanFlag} determines how the case \spad{atan(f(x))},{} where \spad{f(x)} has a pole,{} will be treated. The possible values of \spad{atanFlag} are \spad{complex},{} \spad{real: two sides},{} \spad{real: left side},{} \spad{real: right side},{} and \spad{just do it}. If \spad{atanFlag} is \spad{complex},{} then no series expansion will be computed because,{} viewed as a function of a complex variable,{} \spad{atan(f(x))} has an essential singularity. Otherwise,{} the sign of the leading coefficient of the series expansion of \spad{f(x)} determines the constant coefficient in the series expansion of \spad{atan(f(x))}. If this sign cannot be determined,{} a series expansion is computed only when \spad{atanFlag} is \spad{just do it}. When the leading term in the series expansion of \spad{f(x)} is of odd degree (or is a rational degree with odd numerator),{} then the constant coefficient in the series expansion of \spad{atan(f(x))} for values to the left differs from that for values to the right. If \spad{atanFlag} is \spad{real: two sides},{} no series expansion will be computed. If \spad{atanFlag} is \spad{real: left side} the constant coefficient for values to the left will be used and if \spad{atanFlag} \spad{real: right side} the constant coefficient for values to the right will be used. If there is a problem in converting the function to a power series,{} a record containing the name of the function that caused the problem and a brief description of the problem is returned. When expanding the expression into a series it is assumed that the series is centered at 0. For a series centered at a,{} the user should perform the substitution \spad{x -> x + a} before calling this function.


kind: o
name: exprToXXP
exposed: n
params: pFunctionSpaceToExponentialExpansion(R,FE,x,cen)
type:
(FE,Boolean)->Union(%expansion:ExponentialExpansion(R,FE,x,cen),%problem:Record(func:String,prob:String))

comment:
\spad{exprToXXP(fcn,{} posCheck?)} converts the expression \spad{fcn} to an exponential expansion. If \spad{posCheck?} is \spad{true},{} log\spad{'s} of negative numbers are not allowed nor are \spad{n}th roots of negative numbers with \spad{n} even. If \spad{posCheck?} is \spad{false},{} these are allowed.


kind: o
name: exquo
exposed: n
type: (Stream(A),Stream(A))->Union(Stream(A),failed)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{exquo(a,{} b)} returns the power series quotient of \spad{a} by \spad{b},{} if the quotient exists,{} and failed otherwise


kind: o
name: exquo
exposed: x
type: (%,R)->Union(%,failed)
params: cComplexCategory(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{exquo(x,{} r)} returns the exact quotient of \spad{x} by \spad{r},{} or failed if \spad{r} does not divide \spad{x} exactly.


kind: o
name: exquo
exposed: x
type: (%,R)->Union(%,failed)
params: cFiniteAbelianMonoidRing(R,E)
abbrev: has(R,EntireRing)
comment:
\spad{exquo(p,{}r)} returns the exact quotient of polynomial \spad{p} by \spad{r},{} or failed if none exists.


kind: o
name: exquo
exposed: x
type: (%,R)->Union(%,failed)
params: cMatrixCategory(R,Row,Col)
abbrev: has(R,IntegralDomain)
comment:
\spad{exquo(m,{} r)} computes the exact quotient of the elements of \spad{m} by \spad{r},{} returning \spad{failed} if this is not possible.


kind: o
name: exquo
exposed: x
type: (%,R)->Union(%,failed)
params: cUnivariateSkewPolynomialCategory(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{exquo(l,{} a)} returns the exact quotient of \spad{l} by a,{} returning \spad{failed} if this is not possible.


kind: o
name: exquo
exposed: x
type: (%,%)->Union(%,failed)
params: cEntireRing
comment:
\spad{exquo(a,{} b)} either returns an element \spad{c} such that \spad{c*b=a} or failed if no such element can be found.


kind: o
name: exquo
exposed: x
type: (%,%)->Union(%,failed)
params: dNonNegativeInteger
comment:
\spad{exquo(a,{}b)} returns the quotient of \spad{a} and \spad{b},{} or failed if \spad{b} is zero or \spad{a} rem \spad{b} is zero.


kind: o
name: extend
exposed: x
type: (%,Integer)->%
params: cLazyStreamAggregate(S)
comment:
\spad{extend(st,{} n)} causes entries to be computed,{} if necessary,{} so that 'st' will have at least \spad{'n'} explicit entries or so that all entries of 'st' will be computed if 'st' is finite with length \spad{<=} \spad{n}.


kind: o
name: extend
exposed: x
type: (%,Integer)->%
params: dContinuedFraction(R)
comment:
\spad{extend(x,{} n)} causes the first \spadvar{\spad{n}} entries in the continued fraction \spadvar{\spad{x}} to be computed. Normally entries are only computed as needed.


kind: o
name: extend
exposed: x
type: (List(P),%)->List(%)
params: cRegularTriangularSetCategory(R,E,V,P)
comment:
\spad{extend(lp,{} ts)} returns \spad{ts} if \spad{empty? lp} \spad{extend(p,{} ts)} if \spad{lp = [p]} else \spad{extend(first lp,{} extend(rest lp,{} ts))}


kind: o
name: extend
exposed: x
type: (%,P)->%
params: cTriangularSetCategory(R,E,V,P)
comment:
\spad{extend(ts,{} p)} returns a triangular set which encodes the simple extension by \spad{p} of the extension of the base field defined by \spad{ts},{} according to the properties of triangular sets of the current category If the required properties do not hold an error is returned.


kind: o
name: extend
exposed: x
type: (P,%)->List(%)
params: cRegularTriangularSetCategory(R,E,V,P)
comment:
\spad{extend(p,{} ts)} assumes that \spad{p} is a non-constant polynomial whose main variable is greater than any variable of \spad{ts}. Then it returns a split of Kalkbrener of \spad{ts+p}. This may not be \spad{ts+p} itself,{} if for instance \spad{ts+p} is not a regular triangular set.


kind: o
name: extendedALS
exposed: n
type: (%)->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{extendedALS(f)} returns an extended ALS for \spad{f},{} that is,{} 1*f (with a scalar first row).


kind: o
name: extendedEuclidean
exposed: x
type: (%,%)->Record(coef1:%,coef2:%,generator:%)
params: cEuclideanDomain
comment:
\spad{extendedEuclidean(x,{} y)} returns a record rec where \spad{rec.coef1*x+rec.coef2*y = rec.generator} and rec.generator is a \spad{gcd} of \spad{x} and \spad{y}. The \spad{gcd} is unique only up to associates if \spadtype{canonicalUnitNormal} is not asserted. \spadfun{principalIdeal} provides a version of this operation which accepts an arbitrary length list of arguments.


kind: o
name: extendedEuclidean
exposed: x
type: (%,%,%)->Union(Record(coef1:%,coef2:%),failed)
params: cEuclideanDomain
comment:
\spad{extendedEuclidean(x,{} y,{} z)} either returns a record rec where \spad{rec.coef1*x+rec.coef2*y=z} or returns failed if \spad{z} cannot be expressed as a linear combination of \spad{x} and \spad{y}.


kind: o
name: extended_gcd
exposed: n
type: (U32Vector,U32Vector,Integer)->List(U32Vector)
params: pU32VectorPolynomialOperations
comment:
\spad{extended_gcd(v1,{} v2,{} p)} gives [\spad{g},{} \spad{c1},{} \spad{c2}] such that \spad{g} is \spad{gcd(v1,{} v2,{} p)},{} \spad{g = c1*v1 + c2*v2} and degree(\spad{c1}) < max(degree(\spad{v2}) - degree(\spad{g}),{} 0) and degree(\spad{c2}) < max(degree(\spad{v1}) - degree(\spad{g}),{} 1)


kind: o
name: extendedint
exposed: n
params: pParametricIntegration(R,F)
type:
(F,Symbol,List(F))->Record(particular:Union(Record(ratpart:F,coeffs:Vector(F)),failed),basis:List(Record(ratpart:F,coeffs:Vector(F))))

comment:
\spad{extendedint(f,{} x,{} [g1,{} ...,{} gn])} returns solution of the system \spad{f = dh/dx + c1*g1 + ... + cn*gn} and and a basis of the associated homogeneous system \spad{dh/dx + c1*g1 + ... + cn*gn = 0}. Solutions are in the field generated by kernels of \spad{f} and \spad{g1},{} ...,{} \spad{gn}.


kind: o
name: extendedint
exposed: n
type: (Symbol,List(Kernel(F)),List(F))->List(Record(ratpart:F,coeffs:Vector(F)))
params: pParametricIntegration(R,F)
comment:
\spad{extendedint(x,{} [k1,{} ...,{} kn],{} [g1,{} ...,{} gn])} returns a basis of the homogeneous system \spad{dh/dx + c1*g1 + ... + cn*gn = 0}. Solutions are in the field generated by \spad{k1},{} ...,{} \spad{kn}.


kind: o
name: extendedint
exposed: n
params: pParametricIntegration(R,F)
type:
(F,Symbol,List(Kernel(F)),List(F))->Record(particular:Union(Record(ratpart:F,coeffs:Vector(F)),failed),basis:List(Record(ratpart:F,coeffs:Vector(F))))

comment:
\spad{extendedint(f,{} x,{} [k1,{} ...,{} kn],{} [g1,{} ...,{} gn])} is like extendedint(\spad{f},{} [\spad{k1},{} ...,{} \spad{kn}],{} [\spad{g1},{} ...,{} \spad{gn}]) but looks for solutions in the field generated by \spad{k1},{} ...,{} \spad{kn}.


kind: o
name: extendedLLL
exposed: n
type: (Matrix(Integer))->Record(lll:Matrix(Integer),trf:Matrix(Integer))
params: pLLLReduction
comment:
\spad{extendedLLL(m)} returns the \spad{LLL} reductions of \spad{m} together with the transformation matrix,{} \spadignore{i.e.} if [\spad{l},{} \spad{t}] is returned then it holds \spad{l} = \spad{t*m}.


kind: o
name: extendedLLL!
exposed: n
type: (Matrix(Integer),NonNegativeInteger)->Matrix(Integer)
params: pLLLReduction
comment:
\spad{extendedLLL!(m,{} n)} with 1 \spad{<=} \spad{n} \spad{<=} ncols(\spad{m}) performs the \spad{LLL} reduction of \spad{m} where only the first \spad{n} columns are considered significant. All matrix transformations,{} however,{} will be executed on the full matrix. \spad{m} is destructively modified and will be lost after this call.


kind: o
name: extendedResultant
exposed: n
type: (%,%)->Record(resultant:R,coef1:%,coef2:%)
params: dNewSparseUnivariatePolynomial(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{extendedResultant(a,{} b)} returns \spad{[r,{} ca,{} cb]} such that \spad{r} is the resultant of \spad{a} and \spad{b} and \spad{r = ca * a + cb * b}


kind: o
name: extendedSubResultantGcd
exposed: n
type: (%,%)->Record(gcd:%,coef1:%,coef2:%)
params: dNewSparseUnivariatePolynomial(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{extendedSubResultantGcd(a,{} b)} returns \spad{[g,{} ca,{} cb]} such that \spad{g} is a \spad{gcd} of \spad{a} and \spad{b} in \spad{R^(-1) P} and \spad{g = ca * a + cb * b}


kind: o
name: extendedSubResultantGcd
exposed: x
type: (%,%)->Record(gcd:%,coef1:%,coef2:%)
params: cRecursivePolynomialCategory(R,E,V)
abbrev: has(R,IntegralDomain)
comment:
\spad{extendedSubResultantGcd(a,{} b)} returns \spad{[g,{} ca,{} cb]} such that \spad{g} is \spad{subResultantGcd(a,{} b)} and we have \spad{ca * a + cb * cb = g}.


kind: o
name: extendIfCan
exposed: x
type: (%,P)->Union(%,failed)
params: cTriangularSetCategory(R,E,V,P)
comment:
\spad{extendIfCan(ts,{} p)} returns a triangular set which encodes the simple extension by \spad{p} of the extension of the base field defined by \spad{ts},{} according to the properties of triangular sets of the current domain. If the required properties do not hold then failed is returned. This operation encodes in some sense the properties of the triangular sets of the current category. Is is used to implement the \spad{construct} operation to guarantee that every triangular set build from a list of polynomials has the required properties.


kind: o
name: extendToPoint
exposed: n
type: (%,PT)->%
params: dSBoundary(PT)
comment:
\spad{extendToPoint(n,{} p)} creates a boundary that is the union \indented{2}{of a boundary and a point.} \spad{n} is the boundary \spad{p} is the point


kind: o
name: extensionDegree
exposed: x
type: ()->OnePointCompletion(PositiveInteger)
params: cExtensionField(F)
comment:
\spad{extensionDegree()} returns the degree of the field extension if the extension is algebraic,{} and \spad{infinity} if it is not.


kind: o
name: exteriorDifferential
exposed: n
type: (%)->%
params: dDeRhamComplex(CoefRing,listIndVar)
comment:
\spad{exteriorDifferential(df)} returns the exterior derivative (gradient,{} curl,{} divergence,{} ...) of the differential form \spad{df}.


kind: o
name: extract
exposed: n
type: (%,Integer,Integer)->%
params: dSparseEchelonMatrix(C,D)
comment:
\spad{extract(A,{} i1,{} i2)} extracts the rows \spad{i1} to \spad{i2} and returns them as a new matrix.


kind: o
name: extractBottom!
exposed: x
type: (%)->S
params: cDequeueAggregate(S)
comment:
\spad{extractBottom!(d)} destructively extracts the bottom (back) element from the dequeue \spad{d}. Error: if \spad{d} is empty.


kind: o
name: extractClosed
exposed: n
type: (%)->Boolean
params: dSubSpace(n,R)
comment:
\spad{extractClosed(s)} returns the \spadtype{Boolean} value of the closed property for the indicated 3 dimensional subspace \spad{s}. If the property is closed,{} \spad{True} is returned,{} otherwise \spad{False} is returned.


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


kind: o
name: extractPoint
exposed: n
type: (%)->Point(R)
params: dSubSpace(n,R)
comment:
\spad{extractPoint(s)} returns the point which is given by the current index location into the point data field of the 3 dimensional subspace \spad{s}.


kind: o
name: extractProperty
exposed: n
type: (%)->SubSpaceComponentProperty
params: dSubSpace(n,R)
comment:
\spad{extractProperty(s)} returns the property of domain \spadtype{SubSpaceComponentProperty} of the indicated 3 dimensional subspace \spad{s}.


kind: o
name: extractSplittingLeaf
exposed: n
type: (%)->Union(%,failed)
params: dSplittingTree(V,C)
comment:
\spad{extractSplittingLeaf(a)} returns the left most leaf (as a tree) whose status is \spad{false} if any,{} else failed is returned.


kind: o
name: extractSymbol
exposed: n
type: (%,Boolean)->SparseEchelonMatrix(JB,D)
params: dJetDifferentialEquation(JB,D)
comment:
\spad{extractSymbol(de,{} solved?)} computes the symbol of the differential equation \spad{de}. If \spad{solved?} is \spad{true},{} the row echelon form of the symbol is computed at once.


kind: o
name: extractTop!
exposed: x
type: (%)->S
params: cDequeueAggregate(S)
comment:
\spad{extractTop!(d)} destructively extracts the top (front) element from the dequeue \spad{d}. Error: if \spad{d} is empty.


kind: o
name: eyeDistance
exposed: x
type: (%,Float)->Void
params: dThreeDimensionalViewport
comment:
\spad{eyeDistance(v,{} d)} sets the distance of the observer from the center of the graph to \spad{d},{} for the viewport \spad{v},{} which is of the domain \spadtype{ThreeDimensionalViewport}.


kind: o
name: faceMap
exposed: n
type: (%,NonNegativeInteger)->List(List(Integer))
params: dDeltaComplex(VS)
comment:
returns an individual face map specified by \spad{n}. Where \spad{'n'} is the dimension required,{} so \spad{n=1} returns one dimensional faces (edges),{} \spad{n=2} returns two dimensional faces (triamgles),{} and so on. used by fundamentalGroup.


kind: o
name: factor1
exposed: n
params: pLinearOrdinaryDifferentialOperatorFactorizer(F,UP)
abbrev: has(F,AlgebraicallyClosedField)
type:
(LinearOrdinaryDifferentialOperator1(Fraction(UP)))->List(LinearOrdinaryDifferentialOperator1(Fraction(UP)))

comment:
\spad{factor1(a)} returns the factorisation of a,{} assuming that a has no first-order right factor.


kind: o
name: factor
exposed: n
type: (%)->List(%)
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{factor(f)} factorizes \spad{f} in f=f_1*f_2*...*f_k with atoms (irreducible elements) f_i. Notice that this factorization is unique only with respect to similarity.


kind: o
name: factor
exposed: n
type: (%)->List(%)
params: dILogic
comment:
splits \spad{n} into a list of factors which must be \spad{true} for the whole to be \spad{true}. This assumes that the top level is already a set of factors separated by \spad{/\} otherwise the result will just be a list with one entry: \spad{'n'}. This is used when converting ILogic to types by using the Curry-Howard isomorphism.


kind: o
name: factor
exposed: n
type: (P)->Factored(P)
params: pMRationalFactorize(E,OV,R,P)
comment:
\spad{factor(p)} factors the multivariate polynomial \spad{p} with coefficients which are fractions of elements of \spad{R}.


kind: o
name: factor
exposed: n
type: (UP)->Factored(UP)
params: pComplexRootFindingPackage(R,UP)
comment:
\spad{factor(p)} tries to factor \spad{p} into linear factors with error at most {\em globalEps},{} the internal error bound,{} which can be set by {\em setErrorBound}. An overall error bound {\em eps0} is determined and iterated tree-like calls to {\em pleskenSplit} are used to get the factorization.


kind: o
name: factor
exposed: n
type: (XDistributedPolynomial(vl,F))->List(XDistributedPolynomial(vl,F))
params: pXPolynomialFactor(vl,F)
abbrev: has(F,PolynomialFactorizationExplicit)
comment:
\spad{factor(p)} returns a factorization of \spad{p} into irreducible factors. Note: in general there are finitely many nonequivalent factorizations into irreducible factors,{} this routine returns only one.


kind: o
name: factor
exposed: x
type: (PG)->Factored(PG)
params: pMultFiniteFactorize(OV,E,F,PG)
comment:
\spad{factor(p)} produces the complete factorization of the multivariate polynomial \spad{p} over a finite field.


kind: o
name: factor
exposed: x
type: (SparseUnivariatePolynomial(P))->Factored(SparseUnivariatePolynomial(P))
params: pMultivariateFactorize(OV,E,R,P)
comment:
\spad{factor(p)} factors the multivariate polynomial \spad{p} over its coefficient domain where \spad{p} is represented as a univariate polynomial with multivariate coefficients


kind: o
name: factor
exposed: x
type: (SparseUnivariatePolynomial(PG))->Factored(SparseUnivariatePolynomial(PG))
params: pMultFiniteFactorize(OV,E,F,PG)
comment:
\spad{factor(p)} produces the complete factorization of the multivariate polynomial \spad{p} over a finite field. \spad{p} is represented as a univariate polynomial with multivariate coefficients over a finite field.


kind: o
name: factor
exposed: x
type: (UP)->Factored(UP)
params: pAlgFactor(UP)
comment:
\spad{factor(p)} returns a prime factorisation of \spad{p} over the field generated by its coefficients.


kind: o
name: factor
exposed: n
type: (AlPol,(UP)->Factored(UP))->Factored(AlPol)
params: pInnerAlgFactor(F,UP,AlExt,AlPol)
comment:
\spad{factor(p,{} f)} returns a prime factorisation of \spad{p}; \spad{f} is a factorisation map for elements of UP.


kind: o
name: factor
exposed: n
params: pLinearOrdinaryDifferentialOperatorFactorizer(F,UP)
type:
(LinearOrdinaryDifferentialOperator1(Fraction(UP)),(UP)->List(F))->List(LinearOrdinaryDifferentialOperator1(Fraction(UP)))

comment:
\spad{factor(a,{} zeros)} returns the factorisation of a. \spad{zeros} is a zero finder in \spad{UP}.


kind: o
name: factor
exposed: n
type: (P,(SparseUnivariatePolynomial(R))->Factored(SparseUnivariatePolynomial(R)))->Factored(P)
params: pInnerMultFact(OV,E,R,P)
comment:
\spad{factor(p,{} ufact)} factors the multivariate polynomial \spad{p} by specializing variables and calling the univariate factorizer ufact.


kind: o
name: factor
exposed: n
type: (SparseUnivariatePolynomial(F),List(F))->Factored(SparseUnivariatePolynomial(F))
params: pExpressionFactorPolynomial(R,F)
comment:
\spad{factor(p,{} [k1,{} ...,{} kn])} factors \spad{p} into irreducible factors over field generated by its coefficients and \spad{k1},{} ...,{} \spad{kn}.


kind: o
name: factor
exposed: n
params: pInnerMultFact(OV,E,R,P)
type:
(SparseUnivariatePolynomial(P),(SparseUnivariatePolynomial(R))->Factored(SparseUnivariatePolynomial(R)))->Factored(SparseUnivariatePolynomial(P))

comment:
\spad{factor(p,{} ufact)} factors the multivariate polynomial \spad{p} by specializing variables and calling the univariate factorizer ufact. \spad{p} is represented as a univariate polynomial with multivariate coefficients.


kind: o
name: factor
exposed: n
type: (UP,List(NonNegativeInteger))->Factored(UP)
params: pGaloisGroupFactorizer(UP)
comment:
\spad{factor(p,{} listOfDegrees)} factorizes the polynomial \spad{p} using the single factor bound algorithm and knowing that \spad{p} has for possible splitting of its degree listOfDegrees.


kind: o
name: factor
exposed: n
type: (UP,NonNegativeInteger)->Factored(UP)
params: pGaloisGroupFactorizer(UP)
comment:
\spad{factor(p,{} r)} factorizes the polynomial \spad{p} using the single factor bound algorithm and knowing that \spad{p} has at least \spad{r} factors.


kind: o
name: factor
exposed: n
type: (UP,R)->Factored(UP)
params: pComplexRootFindingPackage(R,UP)
comment:
\spad{factor(p,{} eps)} tries to factor \spad{p} into linear factors with error at most {\em eps}. An overall error bound {\em eps0} is determined and iterated tree-like calls to {\em pleskenSplit} are used to get the factorization.


kind: o
name: factor
exposed: x
type: (P,List(AlgebraicNumber))->Factored(P)
params: pAlgebraicMultFact(OV,E,P)
comment:
\spad{factor(p,{} lan)} factors the polynomial \spad{p} over the extension generated by the algebraic numbers given by the list lan.


kind: o
name: factor
exposed: x
type: (SparseUnivariatePolynomial(P),List(AlgebraicNumber))->Factored(SparseUnivariatePolynomial(P))
params: pAlgebraicMultFact(OV,E,P)
comment:
\spad{factor(p,{} lan)} factors the polynomial \spad{p} over the extension generated by the algebraic numbers given by the list lan. \spad{p} is presented as a univariate polynomial with multivariate coefficients.


kind: o
name: factor
exposed: x
type: (UP,List(AlgebraicNumber))->Factored(UP)
params: pAlgFactor(UP)
comment:
\spad{factor(p,{} [a1,{} ...,{} an])} returns a prime factorisation of \spad{p} over the field generated by its coefficients and \spad{a1},{} ...,{} an.


kind: o
name: factor
exposed: n
params: pLinearOrdinaryDifferentialOperatorFactorizer2(var,cen)
comment: to be documented later.
type:
(LinearOrdinaryDifferentialOperator1(Fraction(UnivariatePolynomial(var,Expression(Integer)))),(SparseUnivariatePolynomial(Expression(Integer)),List(Expression(Integer)))->Factored(SparseUnivariatePolynomial(Expression(Integer))),List(Expression(Integer)))->List(LinearOrdinaryDifferentialOperator1(Fraction(UnivariatePolynomial(var,Expression(Integer)))))


kind: o
name: factor
exposed: n
type: (UP,List(NonNegativeInteger),NonNegativeInteger)->Factored(UP)
params: pGaloisGroupFactorizer(UP)
comment:
\spad{factor(p,{} listOfDegrees,{} r)} factorizes the polynomial \spad{p} using the single factor bound algorithm,{} knowing that \spad{p} has for possible splitting of its degree \spad{listOfDegrees} and that \spad{p} has at least \spad{r} factors.


kind: o
name: factor
exposed: n
type: (UP,NonNegativeInteger,NonNegativeInteger)->Factored(UP)
params: pGaloisGroupFactorizer(UP)
comment:
\spad{factor(p,{} d,{} r)} factorizes the polynomial \spad{p} using the single factor bound algorithm,{} knowing that \spad{d} divides the degree of all factors of \spad{p} and that \spad{p} has at least \spad{r} factors.


kind: o
name: factor
exposed: n
type: (UP,R,Boolean)->Factored(UP)
params: pComplexRootFindingPackage(R,UP)
comment:
\spad{factor(p,{} eps,{} info)} tries to factor \spad{p} into linear factors with error at most {\em eps}. An overall error bound {\em eps0} is determined and iterated tree-like calls to {\em pleskenSplit} are used to get the factorization. If {\em info} is {\em true},{} then information messages are given.


kind: o
name: factorAndSplit
exposed: x
type: (%)->List(%)
params: dEquation(S)
abbrev: has(S,IntegralDomain)
comment:
\spad{factorAndSplit(eq)} make the right hand side 0 and factors the new left hand side. Each factor is equated to 0 and put into the resulting list without repetitions.


kind: o
name: factorByRecursion
exposed: n
type: (SparseUnivariatePolynomial(S))->Factored(SparseUnivariatePolynomial(S))
params: pPolynomialFactorizationByRecursion(R,E,VarSet,S)
comment:
\spad{factorByRecursion(p)} factors polynomial \spad{p}. This function performs the recursion step for factorPolynomial,{} as defined in \spadtype{PolynomialFactorizationExplicit} category (see \spadfun{factorPolynomial})


kind: o
name: factorGroebnerBasis
exposed: x
type: (List(Dpol))->List(List(Dpol))
params: pGroebnerFactorizationPackage(Dom,Expon,VarSet,Dpol)
comment:
\spad{factorGroebnerBasis(basis)} checks whether the \spad{basis} contains reducible polynomials and uses these to split the \spad{basis}.


kind: o
name: factorGroebnerBasis
exposed: x
type: (List(Dpol),Boolean)->List(List(Dpol))
params: pGroebnerFactorizationPackage(Dom,Expon,VarSet,Dpol)
comment:
\spad{factorGroebnerBasis(basis,{} info)} checks whether the \spad{basis} contains reducible polynomials and uses these to split the \spad{basis}. If argument {\em info} is \spad{true},{} information is printed about partial results.


kind: o
name: factorial
exposed: x
type: (%)->%
params: cCombinatorialFunctionCategory
comment:
\spad{factorial(n)} computes the factorial of \spad{n} (denoted in the literature by \spad{n!}) Note: \spad{n! = n (n-1)! when n > 0}; also,{} \spad{0! = 1}.


kind: o
name: factorial
exposed: x
type: (I)->I
params: pIntegerCombinatoricFunctions(I)
comment:
\spad{factorial(n)} returns \spad{n!}. this is the product of all integers between 1 and \spad{n} (inclusive). Note: \spad{0!} is defined to be 1.


kind: o
name: factorials
exposed: n
type: (F,Symbol)->F
params: pCombinatorialFunction(R,F)
comment:
\spad{factorials(f,{} x)} rewrites the permutations and binomials in \spad{f} involving \spad{x} in terms of factorials.


kind: o
name: factorizationSolve
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger)->List(List(Equation(Polynomial(F))))
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{factorizationSolve(f,{}k_rows,{}k_cols)} returns a (possible empty) list of solutions for an admissible transformation to create an upper right block of zeros of size \spad{k_rows} times \spad{k_cols}.


kind: o
name: factorizationTransformations
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger,List(Equation(Polynomial(F))))->List(Matrix(F))
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{factorizationTransformations(f,{}k_rows,{}k_cols,{}sol)} for debugging purposes (interface LINPEN)


kind: o
name: factorize
exposed: n
type: (%,NonNegativeInteger)->List(%)
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{factorize(f,{}k)} factorizes \spad{f} in f=g*h with rank(\spad{g})\spad{=k} if possible (if necessary by using non-linear techniques).


kind: o
name: factorOfDegree
exposed: n
type: (PositiveInteger,Factored(UP))->UP
params: pGaloisGroupPolynomialUtilities(R,UP)
comment:
\spad{factorOfDegree(d,{} f)} returns a factor of degree \spad{d} of the factored polynomial \spad{f}. Such a factor shall exist.


kind: o
name: factorOfDegree
exposed: n
type: (PositiveInteger,UP,List(NonNegativeInteger))->Union(UP,failed)
params: pGaloisGroupFactorizer(UP)
comment:
\spad{factorOfDegree(d,{} p,{} listOfDegrees)} returns a factor of \spad{p} of degree \spad{d} knowing that \spad{p} has for possible splitting of its degree listOfDegrees.


kind: o
name: factorOfDegree
exposed: n
type: (PositiveInteger,UP,NonNegativeInteger)->Union(UP,failed)
params: pGaloisGroupFactorizer(UP)
comment:
\spad{factorOfDegree(d,{} p,{} r)} returns a factor of \spad{p} of degree \spad{d} knowing that \spad{p} has at least \spad{r} factors.


kind: o
name: factorOfDegree
exposed: n
type: (PositiveInteger,UP,List(NonNegativeInteger),NonNegativeInteger)->Union(UP,failed)
params: pGaloisGroupFactorizer(UP)
comment:
\spad{factorOfDegree(d,{} p,{} listOfDegrees,{} r)} returns a factor of \spad{p} of degree \spad{d} knowing that \spad{p} has for possible splitting of its degree \spad{listOfDegrees},{} and that \spad{p} has at least \spad{r} factors.


kind: o
name: factorOfDegree
exposed: n
type: (PositiveInteger,UP,List(NonNegativeInteger),NonNegativeInteger,Boolean)->Union(UP,failed)
params: pGaloisGroupFactorizer(UP)
comment:
\spad{factorOfDegree(d,{} p,{} listOfDegrees,{} r,{} sqf)} returns a factor of \spad{p} of degree \spad{d} knowing that \spad{p} has for possible splitting of its degree \spad{listOfDegrees},{} and that \spad{p} has at least \spad{r} factors. If \spad{sqf=true} the polynomial is assumed to be square free (\spadignore{i.e.} without repeated factors).


kind: o
name: factorPolynomial
exposed: n
type: (SparseUnivariatePolynomial(F))->Factored(SparseUnivariatePolynomial(F))
params: pExpressionFactorPolynomial(R,F)
comment:
\spad{factorPolynomial(p)} factors \spad{p} into irreducible factors over field generated by its coefficients.


kind: o
name: factorPolynomial
exposed: x
type: (SparseUnivariatePolynomial(%))->Factored(SparseUnivariatePolynomial(%))
params: cPolynomialFactorizationExplicit
comment:
\spad{factorPolynomial(p)} returns the factorization into irreducibles of the univariate polynomial \spad{p}.


kind: o
name: factors
exposed: n
type: (%)->List(%)
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{factors(f)} analysis the block structure of the system matrix of the ALS of \spad{f} to split \spad{f} into factors.


kind: o
name: factors
exposed: x
type: (%)->List(Record(factor:R,exponent:NonNegativeInteger))
params: dFactored(R)
comment:
\spad{factors(u)} returns a list of the factors in a form suitable for iteration. That is,{} it returns a list where each element is a record containing a base and exponent. The original object is the product of all the factors and the unit (which can be extracted by \spad{unit(u)}).


kind: o
name: factorsOfDegree
exposed: n
type: (PositiveInteger,Factored(UP))->List(UP)
params: pGaloisGroupPolynomialUtilities(R,UP)
comment:
\spad{factorsOfDegree(d,{} f)} returns the factors of degree \spad{d} of the factored polynomial \spad{f}.


kind: o
name: factorSquareFree
exposed: n
type: (RP)->Factored(RP)
params: pRationalFactorize(RP)
comment:
\spad{factorSquareFree(p)} factors an extended squareFree polynomial \spad{p} over the rational numbers.


kind: o
name: factorSquareFree
exposed: n
type: (UP)->Factored(UP)
params: pGaloisGroupFactorizer(UP)
comment:
\spad{factorSquareFree(p)} returns the factorization of \spad{p} which is supposed not having any repeated factor (this is not checked).


kind: o
name: factorSquareFree
exposed: n
type: (UP,List(NonNegativeInteger))->Factored(UP)
params: pGaloisGroupFactorizer(UP)
comment:
\spad{factorSquareFree(p,{} listOfDegrees)} factorizes the polynomial \spad{p} using the single factor bound algorithm and knowing that \spad{p} has for possible splitting of its degree listOfDegrees. \spad{p} is supposed not having any repeated factor (this is not checked).


kind: o
name: factorSquareFree
exposed: n
type: (UP,NonNegativeInteger)->Factored(UP)
params: pGaloisGroupFactorizer(UP)
comment:
\spad{factorSquareFree(p,{} r)} factorizes the polynomial \spad{p} using the single factor bound algorithm and knowing that \spad{p} has at least \spad{r} factors. \spad{p} is supposed not having any repeated factor (this is not checked).


kind: o
name: factorSquareFree
exposed: n
type: (UP,List(NonNegativeInteger),NonNegativeInteger)->Factored(UP)
params: pGaloisGroupFactorizer(UP)
comment:
\spad{factorSquareFree(p,{} listOfDegrees,{} r)} factorizes the polynomial \spad{p} using the single factor bound algorithm,{} knowing that \spad{p} has for possible splitting of its degree \spad{listOfDegrees} and that \spad{p} has at least \spad{r} factors. \spad{p} is supposed not having any repeated factor (this is not checked).


kind: o
name: factorSquareFree
exposed: n
type: (UP,NonNegativeInteger,NonNegativeInteger)->Factored(UP)
params: pGaloisGroupFactorizer(UP)
comment:
\spad{factorSquareFree(p,{} d,{} r)} factorizes the polynomial \spad{p} using the single factor bound algorithm,{} knowing that \spad{d} divides the degree of all factors of \spad{p} and that \spad{p} has at least \spad{r} factors. \spad{p} is supposed not having any repeated factor (this is not checked).


kind: o
name: factorSquareFreeByRecursion
exposed: n
type: (SparseUnivariatePolynomial(S))->Factored(SparseUnivariatePolynomial(S))
params: pPolynomialFactorizationByRecursion(R,E,VarSet,S)
comment:
\spad{factorSquareFreeByRecursion(p)} returns the square free factorization of \spad{p}. This functions performs the recursion step for factorSquareFreePolynomial,{} as defined in \spadtype{PolynomialFactorizationExplicit} category (see \spadfun{factorSquareFreePolynomial}).


kind: o
name: factorSquareFreePolynomial
exposed: x
type: (SparseUnivariatePolynomial(%))->Factored(SparseUnivariatePolynomial(%))
params: cPolynomialFactorizationExplicit
comment:
\spad{factorSquareFreePolynomial(p)} factors the univariate polynomial \spad{p} into irreducibles where \spad{p} is known to be square free and primitive with respect to its main variable.


kind: o
name: fffg
exposed: n
params: pFractionFreeFastGaussian(D,V)
comment: \spad{fffg(C,{} c,{} eta)} is version of fffg which uses sum of eta as order
type:
(List(D),(NonNegativeInteger,Vector(SparseUnivariatePolynomial(D)))->D,List(NonNegativeInteger))->Matrix(SparseUnivariatePolynomial(D))


kind: o
name: fffg
exposed: n
params: pFractionFreeFastGaussian(D,V)
type:
(List(D),(NonNegativeInteger,Vector(SparseUnivariatePolynomial(D)))->D,Vector(Integer),NonNegativeInteger)->Matrix(SparseUnivariatePolynomial(D))

comment:
\spad{fffg(C,{} c,{} vd,{} K)} is the general algorithm as proposed by Beckermann and Labahn. \blankline The first argument is the list of \spad{c_}{\spad{i},{} \spad{i}}. These are the only values of \spad{C} explicitly needed in \spad{fffg}. \blankline The second argument \spad{c},{} computes \spad{c_k}(\spad{M}),{} \spadignore{i.e.} \spad{c_k}(.) is the dual basis of the vector space \spad{V},{} but also knows about the special multiplication rule as described in Equation (2). Note that the information about \spad{f} is therefore encoded in \spad{c}. \blankline \spad{vd} is modified by the routine,{} on input it is the vector of degree bounds \spad{n},{} as introduced in Definition 2.1. On output it is vector of defects (degree bound minus degree of solution). \blankline \spad{K} is requested order of solution.


kind: o
name: fglmIfCan
exposed: n
params: pLexTriangularPackage(R,ls)
type:
(List(NewSparseMultivariatePolynomial(R,OrderedVariableList(ls))))->Union(List(NewSparseMultivariatePolynomial(R,OrderedVariableList(ls))),failed)

comment:
\spad{fglmIfCan(lp)} returns the lexicographical Groebner basis of \spad{lp} by using the {\em FGLM} strategy,{} if \spad{zeroDimensional?(lp)} holds .


kind: o
name: fglmIfCan
exposed: n
type: (List(Polynomial(R)))->Union(List(Polynomial(R)),failed)
params: pFGLMIfCanPackage(R,ls)
comment:
\spad{fglmIfCan(lq1)} returns the lexicographical Groebner basis of \spad{lq1} by using the {\em FGLM} strategy,{} if \spad{zeroDimensional?(lq1)} holds.


kind: o
name: fibonacci
exposed: x
type: (Integer)->Integer
params: pIntegerNumberTheoryFunctions
comment:
\spad{fibonacci(n)} returns the \spad{n}th Fibonacci number,{} \spad{F[n]}. The Fibonacci numbers are defined by \spad{F[0] = 0},{} \spad{F[1] = 1} and \spad{F[n] = F[n-1] + F[n-2]}. The algorithm has running time \spad{O(log(n)^3)}. Reference: Knuth,{} The Art of Computer Programming Vol 2,{} Semi-Numerical Algorithms.


kind: o
name: filename
exposed: x
type: (String,String,String)->%
params: cFileNameCategory
comment:
\spad{filename(d,{} n,{} e)} creates a file name with \spad{d} as its directory,{} \spad{n} as its name and \spad{e} as its extension. This is a portable way to create file names. When \spad{d} or \spad{t} is the empty string,{} a default is used.


kind: o
name: fill!
exposed: x
type: (%,Entry)->%
params: cIndexedAggregate(Index,Entry)
abbrev: has(%,shallowlyMutable)
comment:
\spad{fill!(u,{} x)} replaces each entry in aggregate \spad{u} by \spad{x}. The modified \spad{u} is returned as value.


kind: o
name: filterUntil
exposed: x
type: ((S)->Boolean,%)->%
params: dStream(S)
comment:
\spad{filterUntil(p,{} s)} returns \spad{[x0,{} x1,{} ...,{} x(n)]} where \spad{s = [x0,{} x1,{} x2,{} ..]} and \spad{n} is the smallest index such that \spad{p(xn) = true}.


kind: o
name: filterWhile
exposed: x
type: ((S)->Boolean,%)->%
params: dStream(S)
comment:
\spad{filterWhile(p,{} s)} returns \spad{[x0,{} x1,{} ...,{} x(n-1)]} where \spad{s = [x0,{} x1,{} x2,{} ..]} and \spad{n} is the smallest index such that \spad{p(xn) = false}.


kind: o
name: find
exposed: x
type: ((S)->Boolean,%)->Union(S,failed)
params: cCollection(S)
comment:
\spad{find(p,{} u)} returns the first \spad{x} in \spad{u} such that \spad{p(x)} is \spad{true},{} and failed otherwise.


kind: o
name: findNonZeroEntry
exposed: n
type: (Matrix(F),NonNegativeInteger,NonNegativeInteger)->List(NonNegativeInteger)
params: pXDistributedPolynomialFunctions(VAR,F)
comment:
\spad{findNonZeroEntry(A,{}i,{}j)} returns the indices [\spad{k},{}\spad{l}] with i<=k<=m and j<=l<=n such that A(\spad{k},{}\spad{l}) is non-zero and [0,{}0] otherwise. A is of size \spad{m} \spad{x} \spad{n}.


kind: o
name: find_relation
exposed: n
type: (List(Float),NonNegativeInteger)->List(Integer)
params: pLLLReduction
comment:
\spad{find_relation(lf,{} k)} finds short integer relation between elements of \spad{lf} rounded to \spad{k} decimal places.


kind: o
name: finite?
exposed: x
type: (%)->Boolean
params: dCardinalNumber
comment:
\spad{finite?(\spad{a})} determines whether \spad{a} is a finite cardinal,{} \spadignore{i.e.} an integer.


kind: o
name: finitePoset
exposed: n
type: (List(S),(S,S)->Boolean)->%
params: cPoset(S)
comment:
\spad{finitePoset(c,{} p)} constructs a finite poset where the set and structure is supplied. The structure is supplied as a predicate function.


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


kind: o
name: first
exposed: x
type: (%)->Entry
params: cIndexedAggregate(Index,Entry)
abbrev: has(Index,OrderedSet)
comment:
\spad{first(u)} returns the first element \spad{x} of \spad{u}. Note: for collections,{} \spad{first([x,{} y,{} ...,{} z]) = x}. Error: if \spad{u} is empty.


kind: o
name: first
exposed: x
type: (%)->S
params: cUnaryRecursiveAggregate(S)
comment:
\spad{first(u)} returns the first element of \spad{u} (equivalently,{} the value at the current node).


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


kind: o
name: first
exposed: x
type: (%,NonNegativeInteger)->%
params: cLinearAggregate(S)
comment:
\spad{first(u,{} n)} returns a copy of the first \spad{n} elements of \spad{u}. Error: if \spad{u} has less than \spad{n} elements.


kind: o
name: firstSubsetGray
exposed: n
type: (PositiveInteger)->Vector(Vector(Integer))
params: pGrayCode
comment:
\spad{firstSubsetGray(n)} creates the first vector {\em ww} to start a loop using {\em nextSubsetGray(ww,{} n)}


kind: o
name: firstUncouplingMatrix
exposed: n
type: (L,PositiveInteger)->Union(Matrix(R),failed)
params: pPrecomputedAssociatedEquations(R,L)
comment:
\spad{firstUncouplingMatrix(op,{} m)} returns the matrix A such that \spad{A w = (W',{} W'',{} ...,{} W^N)} in the corresponding associated equations for right-factors of order \spad{m} of \spad{op}. Returns failed if the matrix A has not been precomputed for the particular combination \spad{degree(L),{} m}.


kind: o
name: fixedDivisor
exposed: n
type: (SparseUnivariatePolynomial(Integer))->Integer
params: pPolynomialNumberTheoryFunctions
comment:
\spad{fixedDivisor(a)} for \spad{a(x)} in \spad{Z[x]} is the largest integer \spad{f} such that \spad{f} divides \spad{a(x=k)} for all integers \spad{k}. Note: fixed divisor of \spad{a} is \spad{reduce(gcd,{} [a(x=k) for k in 0..degree(a)])}.


kind: o
name: fixedPointExquo
exposed: n
type: (UTS,UTS)->UTS
params: pUnivariateTaylorSeriesODESolver(Coef,UTS)
comment:
\spad{fixedPointExquo(f,{} g)} computes the exact quotient of \spad{f} and \spad{g} using a fixed point computation.


kind: o
name: flagFactor
exposed: x
type: (R,NonNegativeInteger,Union(nil,sqfr,irred,prime))->%
params: dFactored(R)
comment:
\spad{flagFactor(base,{} exponent,{} flag)} creates a factored object with a single factor whose \spad{base} is asserted to be properly described by the information flag.


kind: o
name: flatten
exposed: n
type: (%)->%
params: dInputForm
comment:
\spad{flatten(s)} returns an input form corresponding to \spad{s} with all the nested operations flattened to triples using new local variables. If \spad{s} is a piece of code,{} this speeds up the compilation tremendously later on.


kind: o
name: flatten
exposed: n
type: (DirectedGraph(%))->%
params: cFiniteGraph(S)
comment:
\spad{flatten(n)} takes a second order graph,{} that is a graph whose elements are themselves graphs and create a first order graph whose vertices are the vertices of the inner graphs.


kind: o
name: flexible?
exposed: n
type: ()->Boolean
params: xFiniteRankNonAssociativeAlgebra&(S,R)
comment:
\spad{flexible?()} tests if \spad{2*associator(a,{} b,{} a) = 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: float
exposed: x
type: (%)->Flt
params: cSExpressionCategory(Str,Sym,Int,Flt)
comment:
\spad{float(s)} returns \spad{s} as an element of \spad{Flt}; Error: if \spad{s} is not an atom that also belongs to \spad{Flt}.


kind: o
name: forLoop
exposed: n
type: (SegmentBinding(Polynomial(Integer)),%)->%
params: dFortranCode
comment:
\spad{forLoop(i=1..10,{} c)} creates a representation of a FORTRAN DO loop with \spad{i} ranging over the values 1 to 10.


kind: o
name: forLoop
exposed: n
type: (SegmentBinding(Polynomial(Integer)),Polynomial(Integer),%)->%
params: dFortranCode
comment:
\spad{forLoop(i=1..10,{} n,{} c)} creates a representation of a FORTRAN DO loop with \spad{i} ranging over the values 1 to 10 by \spad{n}.


kind: o
name: formalDiff2
exposed: n
type: (%,PositiveInteger,SparseEchelonMatrix(JB,%))->Record(DPhi:%,JVars:List(JB))
params: cJetBundleFunctionCategory(JB)
comment:
\spad{formalDiff2(f,{} i,{} jm)} formally differentiates the function \spad{f} with the Jacobi matrix \spad{jm} \spad{wrt} the \spad{i}\spad{-}th independent variable. \spad{JVars} is a list of the jet variables effectively in the result \spad{DPhi} (might be too large).


kind: o
name: formalDiff
exposed: n
type: (%,List(NonNegativeInteger))->%
params: cJetBundleFunctionCategory(JB)
comment:
\spad{formalDiff(f,{} mu)} formally differentiates \spad{f} as indicated by the multi-index \spad{mu}.


kind: o
name: formalDiff
exposed: n
type: (List(%),PositiveInteger)->List(%)
params: cJetBundleFunctionCategory(JB)
comment:
\spad{formalDiff(sys,{} i)} formally differentiates a family \spad{sys} of functions \spad{wrt} the \spad{i}\spad{-}th independent variable.


kind: o
name: formalDiff
exposed: n
type: (%,PositiveInteger)->%
params: cJetBundleFunctionCategory(JB)
comment:
\spad{formalDiff(f,{} i)} formally (totally) differentiates \spad{f} \spad{wrt} the \spad{i}\spad{-}th independent variable.


kind: o
name: formatExpression
exposed: n
type: (Integer)->(Integer,List(OutputForm))->OutputBox
params: cFormatterCategory
comment:
\spad{formatExpression(p)} returns a handler \spad{h} that \spad{h(prec,{} args)} returns \spad{formatExpression(first args,{} p)}. This handler is used to change the precedence context in which the argument is formatted.


kind: o
name: formatExpression
exposed: n
type: (OutputForm,Integer)->OutputBox
params: cFormatterCategory
comment:
\spad{formatExpression(o,{} p)} returns an \spadtype{OutputBox} that represent the expression \spad{o} in the respective format when considered in a context with outer precedence \spad{p}. This function is the main dispatcher function. It first checks whether \spad{o} is an integer or a string and treats these cases. Then,{} if the number \spad{n} of arguments is less than 3,{} it tries to find a handler for the top-level operator of \spad{o}. If none is found,{} it checks for a handler of an \spad{n}-ary operator. If no handler is found,{} the operator is treated as a function symbol and formatted as such.


kind: o
name: formatFloat
exposed: n
type: (String)->OutputBox
params: cFormatterCategory
comment:
\spad{formatFloat(s)} formats a floating point number from it string representation in \spadtype{OutputForm}.


kind: o
name: formatFunction
exposed: n
type: (OutputBox,List(OutputBox))->OutputBox
params: cFormatterCategory
comment:
\spad{formatFunction(b,{} args)} is supposed to create a box for \spad{b}(args),{} \spadignore{i.e.} format the list of arguments given by args an put it into a format that represents a function application.


kind: o
name: formatStep
exposed: n
type: (OutputForm,Integer)->%
params: dFormatter(F)
comment:
\spad{format(o,{} n)} creates a formatted form of the \spad{OutputForm} \spad{o} with step number \spad{n}.


kind: o
name: fortran
exposed: n
type: (Symbol,FortranScalarType,FS)->%
params: dSimpleFortranProgram(R,FS)
comment:
\spad{fortran(fname,{} ftype,{} body)} builds an object of type \spadtype{FortranProgramCategory}. The three arguments specify the name,{} the type and the body of the program.


kind: o
name: fortranLiteralLine
exposed: n
type: (String)->Void
params: dFortranTemplate
comment:
\spad{fortranLiteralLine(s)} writes \spad{s} to the current Fortran output stream,{} followed by a carriage return


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


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

comment:
Format a fraction. \spad{fraction(p,{} h1,{} h2)} returns a handler \spad{h} such that \spad{h(prec,{} args)} formats the first argument by \spad{h1} and the second argument by \spad{h2}. Outer parentheses are added if \spad{p < prec}.


kind: o
name: fractionalTerms
exposed: x
type: (%)->List(Record(num:R,d_fact:R,d_exp:NonNegativeInteger))
params: dPartialFraction(R)
comment:
\spad{fractionalTerms(p)} extracts the fractional part of \spad{p} to a list of Record(num : \spad{R},{} den : Factored \spad{R}). This returns [] if there is no fractional part.


kind: o
name: fractionFreeGauss!
exposed: x
type: (M)->M
params: pMatrixLinearAlgebraFunctions(R,Row,Col,M)
abbrev: has(R,IntegralDomain)
comment:
\spad{fractionFreeGauss(m)} performs the fraction free gaussian elimination on the matrix \spad{m},{} also known as Bareiss algorithm.


kind: o
name: fractionPart
exposed: x
type: (%)->%
params: cQuotientFieldCategory(S)
abbrev: has(S,EuclideanDomain)
comment:
\spad{fractionPart(x)} returns the fractional part of \spad{x}. \spad{x} = wholePart(\spad{x}) + fractionPart(\spad{x})


kind: o
name: fractionPart
exposed: x
type: (%)->%
params: cSpecialFunctionCategory
comment:
\spad{fractionPart(x)} returns the fractional part of \spad{x}. Note: fractionPart(\spad{x}) = \spad{x} - floor(\spad{x}).


kind: o
name: fractRadix
exposed: x
type: (List(Integer),List(Integer))->%
params: dRadixExpansion(bb)
comment:
\spad{fractRadix(pre,{} cyc)} creates a fractional radix expansion from a list of prefix ragits and a list of cyclic ragits. For example,{} \spad{fractRadix([1],{} [6])} will return \spad{0.16666666...}.


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


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


kind: o
name: freeMultiplicativeConvolution
exposed: x
type: (%,%)->%
params: dDistribution(R)
abbrev: has(R,Algebra(Fraction(Integer)))
comment:
\spad{freeMultiplicativeConvolution(mu,{} nu)} computes the free multiplicative convolution of the distributions \spad{mu} and \spad{nu}.


kind: o
name: freeOf?
exposed: x
type: (%,%)->Boolean
params: cExpressionSpace2(K)
comment:
\spad{freeOf?(x,{} y)} tests if \spad{x} does not contain any occurrence of \spad{y},{} where \spad{y} is a single kernel.


kind: o
name: freeVariable?
exposed: n
type: (%,UT)->Boolean
params: dSKICombinators(UT)
comment:
the variable indicated by \spad{'s'} is free if it does not appear in node \spad{'n'} or any of its subnodes.


kind: o
name: fresnelC
exposed: x
type: (%)->%
params: cLiouvillianFunctionCategory
comment:
\spad{fresnelC(x)} is the Fresnel integral \spad{C},{} defined by \spad{C(x) = integrate(cos(\%pi*t^2/2),{} t=0..x)}


kind: o
name: fresnelS
exposed: x
type: (%)->%
params: cLiouvillianFunctionCategory
comment:
\spad{fresnelS(x)} is the Fresnel integral \spad{S},{} defined by \spad{S(x) = integrate(sin(\%pi*t^2/2),{} t=0..x)}


kind: o
name: front
exposed: x
type: (%)->S
params: cQueueAggregate(S)
comment:
\spad{front(q)} returns the element at the front of the queue. The queue \spad{q} is unchanged by this operation. Error: if \spad{q} is empty.


kind: o
name: frst
exposed: x
type: (%)->S
params: cLazyStreamAggregate(S)
comment:
\spad{frst(s)} returns the first element of stream \spad{s}. Caution: this function should only be called after a \spad{empty?} test has been made since there is no error check.


kind: o
name: fullDisplay
exposed: x
type: (%,PositiveInteger,PositiveInteger)->Void
params: dDatabase(S)
comment:
\spad{fullDisplay(db,{} start,{} end )} prints full details of entries in the range \spad{start..end} in \spad{db}.


kind: o
name: fullPartialFraction
exposed: x
type: (Fraction(UP))->%
params: dFullPartialFractionExpansion(F,UP)
comment:
\spad{fullPartialFraction(f)} returns \spad{[p,{} [[j,{} Dj,{} Hj]...]]} such that \spad{f = p(x) + \sum_{[j,{} Dj,{} Hj] in l} \sum_{Dj(a)=0} Hj(a)/(x - a)\^j}.


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


kind: o
name: function
exposed: n
type: (String,Integer,(Integer,List(OutputForm))->OutputBox)->(Integer,List(OutputForm))->OutputBox
params: cFormatterCategory
comment:
\spad{function(s,{} p,{} hh)} is meant to typeset function applications. It defaults to prefix(\spad{s},{}\spad{p},{}bracket((,{}),{}\spad{hh})).


kind: o
name: function
exposed: n
type: (Symbol,List(%),NonNegativeInteger)->%
params: dJetBundleExpression(JB)
comment:
\spad{function(f,{} arg,{} show)} generates a function with name \spad{f} and arguments \spad{arg}. In the output only the first \spad{show} arguments are shown.


kind: o
name: functionGraph
exposed: n
params: dFunctionGraph(S)
comment: constructor for graph with given objects more objects and arrows can be added later if required.
type:
(List(Record(value:S,posX:NonNegativeInteger,posY:NonNegativeInteger,next:NonNegativeInteger,map:List(NonNegativeInteger))))->%


kind: o
name: functionGraph
exposed: n
type: (List(S))->%
params: dFunctionGraph(S)
comment:
constructor for graph with given list 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: functionGraph
exposed: n
params: dFunctionGraph(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:
constructor for graph with given objects and arrows more objects and arrows can be added later if required.


kind: o
name: functionName
exposed: n
type: (List(GuessOption))->Symbol
params: dGuessOptionFunctions0
comment:
\spad{functionName returns} the name of the function given by the algebraic differential equation,{} default being \spad{f}


kind: o
name: functionName
exposed: x
type: (Symbol)->%
params: dGuessOption
comment:
\spad{functionName(d)} specifies the name of the function given by the algebraic differential equation or recurrence. This option is expressed in the form \spad{functionName == d}.


kind: o
name: functionNames
exposed: n
type: (List(GuessOption))->List(Symbol)
params: dGuessOptionFunctions0
comment:
\spad{functionNames returns} the names for the function in the algebraic dependence,{} default being \%\spad{f1},{} \%\spad{f2},{} ...


kind: o
name: functionNames
exposed: x
type: (List(Symbol))->%
params: dGuessOption
comment:
\spad{functionNames(d)} specifies the names for the function in algebraic dependence. This option is expressed in the form \spad{functionNames == d}.


kind: o
name: fundamentalGroup
exposed: n
type: (%)->GroupPresentation
params: dFiniteCubicalComplex(VS)
comment:
Generates fundamental group from this cubical complex. This works by converting to a DeltaComplex and then generating the fundamentalGroup from that. This is not the most efficient method because the conversion generates lots of higher order faceMaps which are not used. This will attempt to simplify the group presentation,{} if you don\spad{'t} want this use alternative function of same name. TODO write a faster implementation which only generates edge and square faceMaps.


kind: o
name: fundamentalGroup
exposed: n
type: (%)->GroupPresentation
params: dFiniteSimplicialComplex(VS)
comment:
Generates fundamental group from this simplicial complex. This works by converting to a DeltaComplex and then generating the fundamentalGroup from that. This is not the most efficient method because the conversion generates lots of higher order faceMaps which are not used. This will attempt to simplify the group presentation,{} if you don\spad{'t} want this use alternative function of same name. For more information: \url{http://www.euclideanspace.com/prog/scratchpad/mycode/topology/homotopy/index.\spad{htm}}


kind: o
name: fundamentalGroup
exposed: n
type: (%,Boolean,Boolean)->GroupPresentation
params: dFiniteCubicalComplex(VS)
comment:
Generates fundamental group from this cubical complex. This works by converting to a DeltaComplex and then generating the fundamentalGroup from that. This is not the most efficient method because the conversion generates lots of higher order faceMaps which are not used. TODO write a faster implementation which only generates edge and square faceMaps. This version has options to: simplify - if \spad{true} attempts to simplify the group presentation trace - if \spad{true} outputs trace of simplification rules used.


kind: o
name: fundamentalGroup
exposed: n
type: (%,Boolean,Boolean)->GroupPresentation
params: dFiniteSimplicialComplex(VS)
comment:
Generates fundamental group from this simplicial complex. This works by converting to a DeltaComplex and then generating the fundamentalGroup from that. This is not the most efficient method because the conversion generates lots of higher order faceMaps which are not used. This version has options to: simplify - if \spad{true} attempts to simplify the group presentation trace - if \spad{true} outputs trace of simplification rules used. For more information: \url{http://www.euclideanspace.com/prog/scratchpad/mycode/topology/homotopy/index.\spad{htm}}


kind: o
name: gauge
exposed: n
type: (NonNegativeInteger,Integer,List(NonNegativeInteger))->List(Integer)
params: pCartanKuranishi(JB,D)
comment:
\spad{gauge(q,{} j,{} gamma)} computes the gauge corrections to the number of arbitrary functions of differentiation order \spad{j} for a system of order \spad{q} with \spad{gamma} gauge functions.


kind: o
name: gaugeHilbert
exposed: n
type: (NonNegativeInteger,List(NonNegativeInteger))->SparseUnivariatePolynomial(Fraction(Integer))
params: pCartanKuranishi(JB,D)
comment:
\spad{gaugeHilbert(q,{} gamma)} computes the gauge correction to the Hilbert polynomial for a system of order \spad{q} with \spad{gamma} gauge functions.


kind: o
name: gbasisExtend
exposed: n
type: (List(Dpol),List(Dpol),Integer,Integer)->List(Dpol)
params: pGroebnerInternalPackage(Dom,Expon,Dpol)
comment:
\spad{gbasisExtend(pols,{} gb,{} f1,{} f2)} computes a Groebner basis of concat(\spad{pols},{} \spad{gb}) where \spad{gb} is assumed to be already a Groebner basis,{} \spadignore{i.e.} no \spad{S}-polynomials among elements of \spad{gb} will ever be considered.


kind: o
name: gcd
exposed: x
type: (%,%)->%
params: dNonNegativeInteger
comment:
\spad{gcd(a,{} b)} computes the greatest common divisor of two non negative integers \spad{a} and \spad{b}.


kind: o
name: gcd
exposed: x
type: (%,%)->%
params: dPositiveInteger
comment:
\spad{gcd(a,{} b)} computes the greatest common divisor of two positive integers \spad{a} and \spad{b}.


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


kind: o
name: gcdDecomposition
exposed: n
type: (Vector(Fraction(R)))->Record(basis:Vector(R),transform:Matrix(Integer))
params: pGcdBasis(R)
comment:
\spad{gcdDecomposition(v)} returns \spad{[b,{} t]} such that elements of \spad{b} are relatively prime and that \spad{v(i) = product(b(j)^(t(j,{} i)),{} j=1..n)}


kind: o
name: gcdPolynomial
exposed: x
type: (SparseUnivariatePolynomial(%),SparseUnivariatePolynomial(%))->SparseUnivariatePolynomial(%)
params: cGcdDomain
comment:
\spad{gcdPolynomial(p,{} q)} returns the greatest common divisor (\spad{gcd}) of univariate polynomials over the domain


kind: o
name: gcdPolynomial
exposed: x
type: (SparseUnivariatePolynomial(%),SparseUnivariatePolynomial(%))->SparseUnivariatePolynomial(%)
params: cPolynomialFactorizationExplicit
comment:
\spad{gcdPolynomial(p,{} q)} returns the \spad{gcd} of the univariate polynomials \spad{p} \spad{qnd} \spad{q}.


kind: o
name: gcdPrimitive
exposed: n
type: (P,P)->P
params: pPolynomialGcdPackage(E,OV,R,P)
comment:
\spad{gcdPrimitive(p,{} q)} computes the \spad{gcd} of the primitive polynomials \spad{p} and \spad{q}.


kind: o
name: ge_minimal
exposed: n
params: pLinearOrdinaryDifferentialOperatorFactorizer2(var,cen)
comment: to be documented later.
type:
(LinearOrdinaryDifferentialOperator1(Fraction(UnivariatePolynomial(var,Expression(Integer)))),(SparseUnivariatePolynomial(Expression(Integer)))->Factored(SparseUnivariatePolynomial(Expression(Integer))),String)->List(Record(singularity:Record(point:Union(Expression(Integer),infinity),lpf:LinearOrdinaryDifferentialOperator3(Expression(Integer),UnivariateTaylorSeries(Expression(Integer),var,cen),UnivariateLaurentSeries(Expression(Integer),var,cen)),dxt:PositiveInteger),fos:List(Record(op:LinearOrdinaryDifferentialOperator3(Expression(Integer),UnivariateTaylorSeries(Expression(Integer),var,cen),UnivariateLaurentSeries(Expression(Integer),var,cen)),ram:UnivariatePolynomial(var,Expression(Integer)),expart:UnivariateLaurentSeries(Expression(Integer),var,cen))),mge:List(UnivariateLaurentSeries(Expression(Integer),var,cen))))


kind: o
name: generalCoefficient
exposed: n
params: pFractionFreeFastGaussian(D,V)
type:
((NonNegativeInteger,NonNegativeInteger,V)->D,Vector(V),NonNegativeInteger,Vector(SparseUnivariatePolynomial(D)))->D

comment:
\spad{generalCoefficient(action,{} f,{} k,{} p)} gives the coefficient of \spad{x^k} in \spad{p}(\spad{z})\dot \spad{f}(\spad{x}),{} where the \spad{action} of \spad{z^l} on a polynomial in \spad{x} is given by \spad{action},{} \spadignore{i.e.} \spad{action}(\spad{k},{} \spad{l},{} \spad{f}) should return the coefficient of \spad{x^k} in \spad{z^l} \spad{f}(\spad{x}).


kind: o
name: generalInfiniteProduct
exposed: x
type: (UTS,Integer,Integer)->UTS
params: pInfiniteLambertProduct(Coef,UTS)
comment:
\spad{generalInfiniteProduct(f(x),{} a,{} d)} computes \spad{product(n=a,{} a+d,{} a+2*d,{} ...,{} f(x^n))}. The series \spad{f(x)} should have constant coefficient 1.


kind: o
name: generalInterpolation
exposed: n
params: pFractionFreeFastGaussianFractions(D,V,VF)
type:
(List(D),(NonNegativeInteger,NonNegativeInteger,V)->D,Vector(VF),List(NonNegativeInteger))->Matrix(SparseUnivariatePolynomial(D))

comment:
\spad{generalInterpolation(l,{} CA,{} f,{} eta)} performs Hermite-Pade approximation using the given action \spad{CA} of polynomials on the elements of \spad{f}. The result is guaranteed to be correct up to order |eta|-1. Given that eta is a normal point,{} the degrees on the diagonal are given by eta. The degrees of column \spad{i} are in this case eta + \spad{e}.\spad{i} - [1,{} 1,{} ...,{} 1],{} where the degree of zero is \spad{-1}.


kind: o
name: generalInterpolation
exposed: n
params: pFractionFreeFastGaussian(D,V)
type:
(List(D),(NonNegativeInteger,NonNegativeInteger,V)->D,Vector(V),List(NonNegativeInteger))->Matrix(SparseUnivariatePolynomial(D))

comment:
\spad{generalInterpolation(C,{} CA,{} f,{} eta)} performs Hermite-Pade approximation using the given action \spad{CA} of polynomials on the elements of \spad{f}. The result is guaranteed to be correct up to order |eta|-1. Given that eta is a normal point,{} the degrees on the diagonal are given by eta. The degrees of column \spad{i} are in this case eta + \spad{e}.\spad{i} - [1,{} 1,{} ...,{} 1],{} where the degree of zero is \spad{-1}. \blankline The first argument \spad{C} is the list of coefficients \spad{c_}{\spad{k},{} \spad{k}} in the expansion <x^k> \spad{z} \spad{g}(\spad{x}) = sum_{\spad{i=0}}\spad{^k} \spad{c_}{\spad{k},{} \spad{i}} <x^i> \spad{g}(\spad{x}). \blankline The second argument,{} \spad{CA}(\spad{k},{} \spad{l},{} \spad{f}),{} should return the coefficient of \spad{x^k} in \spad{z^l} \spad{f}(\spad{x}).


kind: o
name: generalInterpolation
exposed: n
params: pFractionFreeFastGaussian(D,V)
type:
(List(D),(NonNegativeInteger,NonNegativeInteger,V)->D,Vector(V),Vector(Integer),NonNegativeInteger)->Matrix(SparseUnivariatePolynomial(D))

comment:
\spad{generalInterpolation(C,{} CA,{} f,{} vd,{} K)} is like \spad{generalInterpolation(C,{} CA,{} f,{} eta)} but solves up to order \spad{K} and modifies \spad{vd} to return defects of solutions


kind: o
name: generalizedContinuumHypothesisAssumed
exposed: x
type: (Boolean)->Boolean
params: dCardinalNumber
comment:
\spad{generalizedContinuumHypothesisAssumed(bool)} is used to dictate whether the hypothesis is to be assumed.


kind: o
name: generalizedEigenvector
exposed: n
params: pInnerEigenPackage(F)
type:
(Record(eigval:Union(F,SparseUnivariatePolynomial(F)),eigmult:NonNegativeInteger,eigvec:List(Vector(SparseUnivariatePolynomial(F)))),Matrix(F))->List(Vector(SparseUnivariatePolynomial(F)))

comment:
\spad{generalizedEigenvector(eigen,{} m)} returns the generalized eigenvectors of the matrix relative to the eigenvalue \spad{eigen},{} as returned by the function eigenvectors.


kind: o
name: generalizedEigenvector
exposed: x
params: pEigenPackage(R)
type:
(Record(eigval:Union(Fraction(Polynomial(R)),SuchThat(Symbol,Polynomial(R))),eigmult:NonNegativeInteger,eigvec:List(Matrix(Fraction(Polynomial(R))))),Matrix(Fraction(Polynomial(R))))->List(Matrix(Fraction(Polynomial(R))))

comment:
\spad{generalizedEigenvector(eigen,{} m)} returns the generalized eigenvectors of the matrix relative to the eigenvalue \spad{eigen},{} as returned by the function eigenvectors.


kind: o
name: generalizedEigenvector
exposed: n
params: pInnerEigenPackage(F)
type:
(Union(F,SparseUnivariatePolynomial(F)),Matrix(F),NonNegativeInteger,NonNegativeInteger)->List(Vector(SparseUnivariatePolynomial(F)))

comment:
\spad{generalizedEigenvector(alpha,{} m,{} k,{} g)} returns the generalized eigenvectors of the matrix relative to the eigenvalue \spad{alpha}. The integers \spad{k} and \spad{g} are respectively the algebraic and the geometric multiplicity of the eigenvalue \spad{alpha}.


kind: o
name: generalizedEigenvector
exposed: x
params: pEigenPackage(R)
type:
(Union(Fraction(Polynomial(R)),SuchThat(Symbol,Polynomial(R))),Matrix(Fraction(Polynomial(R))),NonNegativeInteger,NonNegativeInteger)->List(Matrix(Fraction(Polynomial(R))))

comment:
\spad{generalizedEigenvector(alpha,{} m,{} k,{} g)} returns the generalized eigenvectors of the matrix relative to the eigenvalue \spad{alpha}. The integers \spad{k} and \spad{g} are respectively the algebraic and the geometric multiplicity of the eigenvalue \spad{alpha}.


kind: o
name: generalizedEigenvectors
exposed: n
params: pInnerEigenPackage(F)
abbrev: has(F,PolynomialFactorizationExplicit)
comment: \spad{generalizedEigenvectors(m)} returns the generalized eigenvectors of the matrix \spad{m}.
type:
(Matrix(F))->List(Record(eigval:Union(F,SparseUnivariatePolynomial(F)),geneigvec:List(Vector(SparseUnivariatePolynomial(F)))))


kind: o
name: generalizedEigenvectors
exposed: x
params: pEigenPackage(R)
abbrev: has(R,PolynomialFactorizationExplicit)
type:
(Matrix(Fraction(Polynomial(R))))->List(Record(eigval:Union(Fraction(Polynomial(R)),SuchThat(Symbol,Polynomial(R))),geneigvec:List(Matrix(Fraction(Polynomial(R))))))

comment:
\spad{generalizedEigenvectors(m)} returns the generalized returns the generalized eigenvectors of the matrix \spad{m}.


kind: o
name: generalizedEigenvectors
exposed: n
params: pInnerEigenPackage(F)
type:
(Matrix(F),(SparseUnivariatePolynomial(F))->Factored(SparseUnivariatePolynomial(F)))->List(Record(eigval:Union(F,SparseUnivariatePolynomial(F)),geneigvec:List(Vector(SparseUnivariatePolynomial(F)))))

comment:
\spad{generalizedEigenvectors(m,{} fac)} returns the generalized eigenvectors of the matrix \spad{m}. fac is a factorizer for polynomials over \spad{F}.


kind: o
name: generalizedInverse
exposed: n
type: (M)->M
params: pInnerMatrixLinearAlgebraFunctions(R,Row,Col,M)
abbrev: has(R,Field)
comment:
\spad{generalizedInverse(m)} returns the generalized (Moore--Penrose) inverse of the matrix \spad{m},{} \spadignore{i.e.} the matrix \spad{h} such that m*h*m=h,{} h*m*h=m,{} \spad{m*h} and \spad{h*m} are both symmetric matrices.


kind: o
name: generalLambert
exposed: n
type: (%,Integer,Integer)->%
params: dUnivariateTaylorSeries(Coef,var,cen)
comment:
\spad{generalLambert(f(x),{} a,{} d)} returns \spad{f(x^a) + f(x^(a + d)) + \indented{1}{f(x^(a + 2 d)) + ... }. \spad{f(x)} should have zero constant} \indented{1}{coefficient and \spad{a} and \spad{d} should be positive.}


kind: o
name: generalLambert
exposed: n
type: (Stream(A),Integer,Integer)->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{generalLambert(f(x),{} a,{} d)} returns \spad{f(x^a) + f(x^(a + d)) + f(x^(a + 2 d)) + ...}. \spad{f(x)} should have zero constant coefficient and \spad{a} and \spad{d} should be positive.


kind: o
name: general_Lambert_product
exposed: n
type: (Stream(A),Integer,Integer)->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{general_Lambert_product(f(x),{} a,{} d)} returns \spad{f(x^a)*f(x^(a + d))*f(x^(a + 2 d))* ...}. \spad{f(x)} should have constant coefficient equal to one and \spad{a} and \spad{d} should be positive.


kind: o
name: generalPosition
exposed: x
type: (%,List(VarSet))->Record(mval:Matrix(F),invmval:Matrix(F),genIdeal:%)
params: dPolynomialIdeal(F,Expon,VarSet,DPoly)
comment:
\spad{generalPosition(I,{} listvar)} perform a random linear transformation on the variables in listvar and returns the transformed ideal along with the change of basis matrix.


kind: o
name: generalTwoFactor
exposed: n
params: pTwoFactorize(F)
type:
(SparseUnivariatePolynomial(SparseUnivariatePolynomial(F)))->Factored(SparseUnivariatePolynomial(SparseUnivariatePolynomial(F)))

comment:
\spad{generalTwoFactor(p)} returns the factorisation of polynomial \spad{p},{} a sparse univariate polynomial (sup) over a sup over \spad{F}.


kind: o
name: generator
exposed: x
type: ()->%
params: cFiniteAlgebraicExtensionField(F)
abbrev: has(F,Finite)
comment:
\spad{generator()} returns a root of the defining polynomial. This element generates the field as an algebra over the ground field.


kind: o
name: generator
exposed: x
type: (%)->Union(R,failed)
params: cFiniteDivisorCategory(F,UP,UPUP,R)
comment:
\spad{generator(d)} returns \spad{f} if \spad{(f) = d},{} failed if \spad{d} is not principal. \spad{d} is assumed to be of degree 0.


kind: o
name: generator
exposed: x
type: (%,Integer,List(UP))->Union(R,failed)
params: cFiniteDivisorCategory(F,UP,UPUP,R)
comment:
\spad{generator(d,{} k,{} lp)} returns \spad{f} if \spad{(f) = d},{} failed if \spad{d} is not principal. \spad{k} is sum of orders of \spad{d} at special places. Special places are places over infinity and over zeros of polynomials in \spad{lp}. Elements of \spad{lp} are assumed to be relatively prime.


kind: o
name: generic
exposed: n
type: ()->%
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
comment:
\spad{generic()} returns a generic element,{} \spadignore{i.e.} the linear combination of the fixed basis with the symbolic coefficients \spad{\%x1,{} \%x2,{} ..}


kind: o
name: generic
exposed: n
type: (Symbol)->%
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
comment:
\spad{generic(s)} returns a generic element,{} \spadignore{i.e.} the linear combination of the fixed basis with the symbolic coefficients \spad{s1,{} s2,{} ..}


kind: o
name: generic
exposed: n
type: (Vector(%))->%
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
comment:
\spad{generic(ve)} returns a generic element,{} \spadignore{i.e.} the linear combination of \spad{ve} basis with the symbolic coefficients \spad{\%x1,{} \%x2,{} ..}


kind: o
name: generic
exposed: n
type: (Vector(Symbol))->%
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
comment:
\spad{generic(vs)} returns a generic element,{} \spadignore{i.e.} the linear combination of the fixed basis with the symbolic coefficients \spad{vs}; error,{} if the vector of symbols is too short


kind: o
name: generic
exposed: n
type: (Symbol,Vector(%))->%
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
comment:
\spad{generic(s,{} v)} returns a generic element,{} \spadignore{i.e.} the linear combination of \spad{v} with the symbolic coefficients \spad{s1,{} s2,{} ..}


kind: o
name: generic
exposed: n
type: (Vector(Symbol),Vector(%))->%
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
comment:
\spad{generic(vs,{} ve)} returns a generic element,{} \spadignore{i.e.} the linear combination of \spad{ve} with the symbolic coefficients \spad{vs} error,{} if the vector of symbols is shorter than the vector of elements


kind: o
name: genericLeftDiscriminant
exposed: n
type: ()->Fraction(Polynomial(R))
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
abbrev: has(R,IntegralDomain)
comment:
\spad{genericLeftDiscriminant()} is the determinant of the generic left trace forms of all products of basis element,{} if the generic left trace form is associative,{} an algebra is separable if the generic left discriminant is invertible,{} if it is non-zero,{} there is some ring extension which makes the algebra separable


kind: o
name: genericLeftMinimalPolynomial
exposed: n
type: (%)->SparseUnivariatePolynomial(Fraction(Polynomial(R)))
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
abbrev: has(R,IntegralDomain)
comment:
\spad{genericLeftMinimalPolynomial(a)} substitutes the coefficients of {em a} for the generic coefficients in \spad{leftRankPolynomial()}


kind: o
name: genericLeftNorm
exposed: n
type: (%)->Fraction(Polynomial(R))
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
abbrev: has(R,IntegralDomain)
comment:
\spad{genericLeftNorm(a)} substitutes the coefficients of \spad{a} for the generic coefficients into the coefficient of the constant term in \spadfun{leftRankPolynomial} and changes the sign if the degree of this polynomial is odd. This is a form of degree \spad{k}


kind: o
name: genericLeftTrace
exposed: n
type: (%)->Fraction(Polynomial(R))
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
abbrev: has(R,IntegralDomain)
comment:
\spad{genericLeftTrace(a)} substitutes the coefficients of \spad{a} for the generic coefficients into the coefficient of the second highest term in \spadfun{leftRankPolynomial} and changes the sign. \indented{1}{This is a linear form}


kind: o
name: genericLeftTraceForm
exposed: n
type: (%,%)->Fraction(Polynomial(R))
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
abbrev: has(R,IntegralDomain)
comment:
\spad{genericLeftTraceForm (a,{} b)} is defined to be \spad{genericLeftTrace (a*b)},{} this defines a symmetric bilinear form on the algebra


kind: o
name: genericPosition
exposed: n
params: pGroebnerSolve(lv,F,R)
type:
(List(DistributedMultivariatePolynomial(lv,F)),List(OrderedVariableList(lv)))->Record(dpolys:List(DistributedMultivariatePolynomial(lv,F)),coords:List(Integer))

comment:
\spad{genericPosition(lp,{} lv)} puts a radical zero dimensional ideal in general position,{} for system \spad{lp} in variables \spad{lv}.


kind: o
name: genericRightDiscriminant
exposed: n
type: ()->Fraction(Polynomial(R))
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
abbrev: has(R,IntegralDomain)
comment:
\spad{genericRightDiscriminant()} is the determinant of the generic left trace forms of all products of basis element,{} if the generic left trace form is associative,{} an algebra is separable if the generic left discriminant is invertible,{} if it is non-zero,{} there is some ring extension which makes the algebra separable


kind: o
name: genericRightMinimalPolynomial
exposed: n
type: (%)->SparseUnivariatePolynomial(Fraction(Polynomial(R)))
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
abbrev: has(R,IntegralDomain)
comment:
\spad{genericRightMinimalPolynomial(a)} substitutes the coefficients of \spad{a} for the generic coefficients in \spadfun{rightRankPolynomial}


kind: o
name: genericRightNorm
exposed: n
type: (%)->Fraction(Polynomial(R))
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
abbrev: has(R,IntegralDomain)
comment:
\spad{genericRightNorm(a)} substitutes the coefficients of \spad{a} for the generic coefficients into the coefficient of the constant term in \spadfun{rightRankPolynomial} and changes the sign if the degree of this polynomial is odd


kind: o
name: genericRightTrace
exposed: n
type: (%)->Fraction(Polynomial(R))
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
abbrev: has(R,IntegralDomain)
comment:
\spad{genericRightTrace(a)} substitutes the coefficients of \spad{a} for the generic coefficients into the coefficient of the second highest term in \spadfun{rightRankPolynomial} and changes the sign


kind: o
name: genericRightTraceForm
exposed: n
type: (%,%)->Fraction(Polynomial(R))
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
abbrev: has(R,IntegralDomain)
comment:
\spad{genericRightTraceForm (a,{} b)} is defined to be \spadfun{genericRightTrace (a*b)},{} this defines a symmetric bilinear form on the algebra


kind: o
name: gen_exp
exposed: n
params: pLinearOrdinaryDifferentialOperatorFactorizer2(var,cen)
comment: to be documented later.
type:
(LinearOrdinaryDifferentialOperator1(Fraction(UnivariatePolynomial(var,Expression(Integer)))),Union(Expression(Integer),infinity),(SparseUnivariatePolynomial(Expression(Integer)),List(Expression(Integer)))->Factored(SparseUnivariatePolynomial(Expression(Integer))),List(Expression(Integer)))->List(Record(ecs:List(UnivariateLaurentSeries(Expression(Integer),var,cen)),ecr:UnivariatePolynomial(var,Expression(Integer)),ect:Fraction(UnivariatePolynomial(var,Expression(Integer)))))


kind: o
name: gen_Monte_Carlo_check
exposed: n
params: pModularHermitePadeSolver(F,S)
type:
((List(SparseUnivariatePolynomial(S)))->Union(good,reject,no_solution),List(List(F)),Symbol,Symbol,NonNegativeInteger,(List(U32Vector),Integer,Integer)->Vector(U32Vector))->(List(SparseUnivariatePolynomial(S)))->Union(good,reject,no_solution)

comment:
\spad{gen_Monte_Carlo_check(check,{} l,{} kind,{} qvar,{} sigma,{} gen)} returns Monte Carlo \spad{check} for solutions to guessing problem. If Monte Carlo \spad{check} is unavailable returns \spad{check}.


kind: o
name: genVectorStream
exposed: n
type: (NonNegativeInteger,NonNegativeInteger,NonNegativeInteger)->Stream(List(NonNegativeInteger))
params: pFractionFreeFastGaussian(D,V)
comment:
\spad{genVectorStream(sumEta,{} maxEta,{} k)} generates stream of all possible non-increasing lists \spad{eta} with maximal entry \spad{maxEta} and sum of entries at most \spad{sumEta}.


kind: o
name: getArr
exposed: n
type: (%)->List(List(Boolean))
params: cPoset(S)
comment:
\spad{getArr(s)} returns a list of all the arrows (or edges) Note: different from getArrows(\spad{s}) which is inherited from FiniteGraph(\spad{S})


kind: o
name: getArrows
exposed: n
params: xPoset&(A,S)
type:
(A)->List(Record(name:String,arrType:NonNegativeInteger,fromOb:NonNegativeInteger,toOb:NonNegativeInteger,xOffset:Integer,yOffset:Integer,map:List(NonNegativeInteger)))


kind: o
name: getArrows
exposed: n
params: cFiniteGraph(S)
comment: \spad{getArrows(s)} returns a list of all the arrows (or edges)
type:
(%)->List(Record(name:String,arrType:NonNegativeInteger,fromOb:NonNegativeInteger,toOb:NonNegativeInteger,xOffset:Integer,yOffset:Integer,map:List(NonNegativeInteger)))


kind: o
name: getBadValues
exposed: n
type: (%)->List(Any)
params: dPattern(R)
comment:
\spad{getBadValues(p)} returns the list of bad values for \spad{p}. Note: \spad{p} is not allowed to match any of its bad values.


kind: o
name: getChildren
exposed: n
type: (%)->List(%)
params: dLambda(UT)
comment:
returns 2 child nodes if this is a compound term returns 1 child node if this is a lambda term otherwise returns []


kind: o
name: getCode
exposed: n
type: (%)->List(String)
params: dFortranCode
comment:
\spad{getCode(f)} returns a list of strings representing \spad{f} in Fortran notation. This is used by the FortranProgram domain.


kind: o
name: getCurve
exposed: n
type: (%)->Curve
params: dTubePlot(Curve)
comment:
\spad{getCurve(t)} returns the \spadtype{PlottableSpaceCurveCategory} representing the parametric curve of the given tube plot \spad{t}.


kind: o
name: getDatabase
exposed: x
type: (String)->Database(IndexCard)
params: pOperationsQuery
comment:
\spad{getDatabase(char)} returns a list of appropriate entries in the browser database. The legal values for \spad{char} are o (operations),{} \spad{k} (constructors),{} \spad{d} (domains),{} \spad{c} (categories) or \spad{p} (packages).


kind: o
name: get_elliptics
exposed: n
type: ((UP)->UP,F)->List(Record(f_form:R,e_form:R,f_var:F,f_pol:UP))
params: pGenerateEllipticIntegrals(F,UP,UPUP,R)
comment:
\spad{get_elliptics(der,{} x)} tries to find elliptic forms on \spad{R} \spad{x} is expression for variable of integration in \spad{F}


kind: o
name: getEq
exposed: n
type: (F)->F
params: pRecurrenceOperator(R,F)
comment:
\spad{getEq f} returns the defining equation,{} if \spad{f} represents the coefficient of an ADE or a recurrence.


kind: o
name: get_extension_degree
exposed: n
type: (MD)->Integer
params: cModularFactorizationOperations(PA,MMT,MD,PMD)
comment:
\spad{get_extension_degree(md)} returns degree of the field described by info \spad{md} over its prime subfield.


kind: o
name: getGraph
exposed: n
type: (%,PositiveInteger)->GraphImage
params: dTwoDimensionalViewport
comment:
\spad{getGraph(v,{} n)} returns the graph which is of the domain \spadtype{GraphImage} which is located in graph field \spad{n} of the given two-dimensional viewport,{} \spad{v},{} which is of the domain \spadtype{TwoDimensionalViewport}.


kind: o
name: getMatch
exposed: n
type: (Pattern(R),%)->Union(S,failed)
params: dPatternMatchResult(R,S)
comment:
\spad{getMatch(var,{} r)} returns the expression that \spad{var} matches in the result \spad{r},{} and failed if \spad{var} is not matched in \spad{r}.


kind: o
name: getMultiplicationTable
exposed: n
type: ()->Vector(List(Record(value:GF,index:SingleInteger)))
params: dFiniteFieldNormalBasisExtensionByPolynomial(GF,uni)
comment:
\spad{getMultiplicationTable()} returns the multiplication table for the normal basis of the field. This table is used to perform multiplications between field elements.


kind: o
name: getOrder
exposed: n
type: ()->Record(low:List(S),high:List(S))
params: pUserDefinedPartialOrdering(S)
comment:
\spad{getOrder()} returns \spad{[[b1,{} ...,{} bm],{} [a1,{} ...,{} an]]} such that the partial ordering on \spad{S} was given by \spad{setOrder([b1,{} ...,{} bm],{} [a1,{} ...,{} an])}.


kind: o
name: getPickedPoints
exposed: n
type: (%)->List(Point(DoubleFloat))
params: dTwoDimensionalViewport
comment:
\spad{getPickedPoints(x)} returns a list of small floats for the points the user interactively picked on the viewport for full integration into the system,{} some design issues need to be addressed: \spadignore{e.g.} how to go through the GraphImage interface,{} how to default to graphs,{} etc.


kind: o
name: get_rational_roots
exposed: n
type: (F,Kernel(F))->List(Fraction(Integer))
params: pFunctionSpaceRationalRoots(R,F)
comment:
\spad{get_rational_roots(f,{} k)} finds rational root of \spad{f} treated as univariate polynomial in \spad{k}.


kind: o
name: getRef
exposed: n
type: (%)->Reference(OrderedCompletion(Integer))
params: dInnerSparseUnivariatePowerSeries(Coef)
comment:
\spad{getRef(f)} returns a reference containing the order to which the terms of \spad{f} have been computed.


kind: o
name: getSimplifyDenomsFlag
exposed: x
type: ()->Boolean
params: dExpression(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{getSimplifyDenomsFlag()} gets values of flag affecting simplification of denominators. See setSimplifyDenomsFlag.


kind: o
name: getType
exposed: n
type: (%)->ILogic
params: cVarCat
comment:
returns the type of the variable. This may be a compound type,{} for instance [a,{}\spad{b}] represents a-\spad{>b} a function from type a to type \spad{b} untyped implementations return []


kind: o
name: getVariable
exposed: n
type: (%)->UT
params: dLambda(UT)
comment:
introspection: returns value of unbound variable in unbound leaf node or bound variable in lambda term


kind: o
name: getVariableOrder
exposed: x
type: ()->Record(high:List(Symbol),low:List(Symbol))
params: pUserDefinedVariableOrdering
comment:
\spad{getVariableOrder()} returns \spad{[[b1,{} ...,{} bm],{} [a1,{} ...,{} an]]} such that the ordering on the variables was given by \spad{setVariableOrder([b1,{} ...,{} bm],{} [a1,{} ...,{} an])}.


kind: o
name: getVert
exposed: n
type: (%)->List(S)
params: cPoset(S)
comment:
\spad{getVert(s)} returns a list of all the vertices (or objects) of the graph \spad{s}. Note: different from getVertices(\spad{s}) which is inherited from FiniteGraph(\spad{S})


kind: o
name: getZechTable
exposed: n
type: ()->PrimitiveArray(SingleInteger)
params: dFiniteFieldCyclicGroupExtensionByPolynomial(GF,defpol)
comment:
\spad{getZechTable()} returns the zech logarithm table of the field it is used to perform additions in the field quickly.


kind: o
name: getZechTable
exposed: n
type: ()->PrimitiveArray(SingleInteger)
params: dFiniteFieldCyclicGroupExtension(GF,extdeg)
comment:
\spad{getZechTable()} returns the zech logarithm table of the field. This table is used to perform additions in the field quickly.


kind: o
name: GF2FG
exposed: n
type: (Complex(F))->FG
params: pInnerTrigonometricManipulations(R,F,FG)
comment:
\spad{GF2FG(a + i b)} returns \spad{a + i b} viewed as a function with the \spad{i} pushed down into the coefficient domain.


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


kind: o
name: goodPoint
exposed: n
type: (List(UPUP),UPUP)->F
params: pChangeOfVariable(F,UP,UPUP)
comment:
\spad{goodPoint([p1,{} ...,{} pn],{} q)} returns an integer a such that a is neither a pole of \spad{\spad{pi}(x,{} y)} for some \spad{i} nor a branch point of \spad{q(x,{} y) = 0}.


kind: o
name: GospersMethod
exposed: n
type: (Q,V,()->V)->Union(Q,failed)
params: pGosperSummationMethod(E,V,R,P,Q)
comment:
\spad{GospersMethod(b,{} n,{} new)} returns a rational function \spad{rf(n)} such that \spad{a(n) * rf(n)} is the indefinite sum of \spad{a(n)} with respect to upward difference on \spad{n},{} \spadignore{i.e.} \spad{a(n+1) * rf(n+1) - a(n) * rf(n) = a(n)},{} where \spad{b(n) = a(n)/a(n-1)} is a rational function. Returns failed if no such rational function \spad{rf(n)} exists. Note: \spad{new} is a nullary function returning a new \spad{V} every time. The condition on \spad{a(n)} is that \spad{a(n)/a(n-1)} is a rational function of \spad{n}.


kind: o
name: grade
exposed: n
type: (%)->List(List(CubicalFacet))
params: dFiniteCubicalComplex(VS)
comment:
A function to grade faces according to the number of non-degenerate intervals. This nests the lists according to their order Vertices,{} edges,{} squares and so on.


kind: o
name: grade
exposed: n
type: (%)->List(List(OrientedFacet))
params: dFiniteSimplicialComplex(VS)
comment:
a function to grade simplexes according to their lengths. This nests the lists according to their length. Vertices,{} edges,{} triangles and so on. The list is returned in reverse order,{} that is,{} it starts at highest grade and works down.


kind: o
name: grade
exposed: x
type: (%)->NonNegativeInteger
params: dCliffordAlgebra(n,K,bLin)
comment:
return the max grade of multivector,{} for example 1 is grade 0 \spad{e1} is grade 1 e1/\e2 is grade 2 and so on


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


kind: o
name: graeffe
exposed: n
type: (UP)->UP
params: pComplexRootFindingPackage(R,UP)
comment:
\spad{graeffe p} determines \spad{q} such that \spad{q(-z^2) = p(z)*p(-z)}. Note that the roots of \spad{q} are the squares of the roots of \spad{p}.


kind: o
name: gramschmidt
exposed: x
type: (List(Matrix(Expression(Integer))))->List(Matrix(Expression(Integer)))
params: pRadicalEigenPackage
comment:
\spad{gramschmidt(lv)} converts the list of column vectors \spad{lv} into a set of orthogonal column vectors of euclidean length 1 using the Gram-Schmidt algorithm.


kind: o
name: graphCurves
exposed: n
type: (List(List(Point(DoubleFloat))))->GraphImage
params: pViewportPackage
comment:
\spad{graphCurves([[p0],{} [p1],{} ...,{} [pn]])} creates a \spadtype{GraphImage} from the list of lists of points indicated by \spad{p0} through \spad{pn}.


kind: o
name: graphCurves
exposed: n
type: (List(List(Point(DoubleFloat))),List(DrawOption))->GraphImage
params: pViewportPackage
comment:
\spad{graphCurves([[p0],{} [p1],{} ...,{} [pn]],{} [options])} creates a \spadtype{GraphImage} from the list of lists of points,{} \spad{p0} through \spad{pn},{} using the options specified in the list \spad{options}.


kind: o
name: graphCurves
exposed: n
type: (List(List(Point(DoubleFloat))),Palette,Palette,PositiveInteger,List(DrawOption))->GraphImage
params: pViewportPackage
comment:
\spad{graphCurves([[p0],{} [p1],{} ...,{} [pn]],{} ptColor,{} lineColor,{} ptSize,{} [options])} creates a \spadtype{GraphImage} from the list of lists of points,{} \spad{p0} through \spad{pn},{} using the options specified in the list \spad{options}. The graph point color is specified by \spad{ptColor},{} the graph line color is specified by \spad{lineColor},{} and the size of the points is specified by \spad{ptSize}.


kind: o
name: graphImage
exposed: n
type: ()->%
params: dGraphImage
comment:
\spad{graphImage()} returns an empty graph with 0 point lists of the domain \spadtype{GraphImage}. A graph image contains the graph data component of a two dimensional viewport.


kind: o
name: graphs
exposed: n
type: (%)->Vector(Union(GraphImage,undefined))
params: dTwoDimensionalViewport
comment:
\spad{graphs(v)} returns a vector,{} or list,{} which is a union of all the graphs,{} of the domain \spadtype{GraphImage},{} which are allocated for the two-dimensional viewport,{} \spad{v},{} of domain \spadtype{TwoDimensionalViewport}. Those graphs which have no data are labeled undefined,{} otherwise their contents are shown.


kind: o
name: graphs
exposed: x
type: (Integer)->SymmetricPolynomial(Fraction(Integer))
params: pCycleIndicators
comment:
\spad{graphs n} is the cycle index of the group induced on \indented{1}{the edges of a graph by applying the symmetric function to the} \indented{1}{\spad{n} nodes.}


kind: o
name: graphState
exposed: n
params: dTwoDimensionalViewport
type:
(%,PositiveInteger,DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat,Integer,Integer,Integer,Integer,Palette,Integer,Palette,Integer)->Void

comment:
\spad{graphState(v,{} num,{} sX,{} sY,{} dX,{} dY,{} pts,{} lns,{} box,{} axes,{} axesC,{} un,{} unC,{} cP)} sets the state of the characteristics for the graph indicated by \spad{num} in the given two-dimensional viewport \spad{v},{} of domain \spadtype{TwoDimensionalViewport},{} to the values given as parameters. The scaling of the graph in the \spad{x} and \spad{y} component directions is set to be \spad{sX} and \spad{sY}; the window translation in the \spad{x} and \spad{y} component directions is set to be \spad{dX} and \spad{dY}; The graph points,{} lines,{} bounding \spad{box},{} \spad{axes},{} or units will be shown in the viewport if their given parameters \spad{pts},{} \spad{lns},{} \spad{box},{} \spad{axes} or \spad{un} are set to be \spad{1},{} but will not be shown if they are set to \spad{0}. The color of the \spad{axes} and the color of the units are indicated by the palette colors \spad{axesC} and \spad{unC} respectively. To display the control panel when the viewport window is displayed,{} set \spad{cP} to \spad{1},{} otherwise set it to \spad{0}.


kind: o
name: graphStates
exposed: n
params: dTwoDimensionalViewport
type:
(%)->Vector(Record(scaleX:DoubleFloat,scaleY:DoubleFloat,deltaX:DoubleFloat,deltaY:DoubleFloat,points:Integer,connect:Integer,spline:Integer,axes:Integer,axesColor:Palette,units:Integer,unitsColor:Palette,showing:Integer))

comment:
\spad{graphStates(v)} returns and shows a listing of a record containing the current state of the characteristics of each of the ten graph records in the given two-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{TwoDimensionalViewport}.


kind: o
name: groebgen
exposed: n
params: pLinGroebnerPackage(lv,F)
comment: \spad{groebgen }\undocumented
type:
(List(DistributedMultivariatePolynomial(lv,F)))->Record(glbase:List(DistributedMultivariatePolynomial(lv,F)),glval:List(Integer))


kind: o
name: groebner
exposed: n
type: (List(Dpol))->List(Dpol)
params: pNGroebnerPackage(Dom,Expon,Dpol)
comment:
\spad{groebner(lp)} computes a groebner basis for a polynomial ideal generated by the list of polynomials \spad{lp}.


kind: o
name: groebner
exposed: n
type: (List(%))->List(%)
params: dDistributedJetBundlePolynomial(R,JB,LJV,E)
abbrev: has(R,GcdDomain)
comment:
\spad{groebner(lp)} computes a Groebner basis for the ideal generated by the list of polynomials \spad{lp}.


kind: o
name: groebner
exposed: n
type: (List(%))->List(%)
params: dJetBundlePolynomial(R,JB)
abbrev: has(R,GcdDomain)
comment:
\spad{groebner(lp)} computes a Groebner basis for the ideal generated by \spad{lp} \spad{wrt} a lexicographic ordering.


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

comment:
\spad{groebner(lp)} returns the lexicographical Groebner basis of \spad{lp}. If \spad{lp} generates a zero-dimensional ideal then the {\em FGLM} strategy is used,{} otherwise the {\em Sugar} strategy is used.


kind: o
name: groebner
exposed: n
type: (List(Polynomial(R)))->List(Polynomial(R))
params: pFGLMIfCanPackage(R,ls)
comment:
\spad{groebner(lq1)} returns the lexicographical Groebner basis of \spad{lq1}. If \spad{lq1} generates a zero-dimensional ideal then the {\em FGLM} strategy is used,{} otherwise the {\em Sugar} strategy is used.


kind: o
name: groebner
exposed: x
type: (List(Dpol),String)->List(Dpol)
params: pGroebnerPackage(Dom,Expon,Dpol)
comment:
\spad{groebner(lp,{} infoflag)} computes a groebner basis for a polynomial ideal generated by the list of polynomials \spad{lp}. Argument infoflag is used to get information on the computation. If infoflag is info,{} then summary information is displayed for each \spad{s}-polynomial generated. If infoflag is redcrit,{} the reduced critical pairs are displayed. If infoflag is any other string,{} no information is printed during computation.


kind: o
name: groebner
exposed: x
type: (List(Dpol),String,String)->List(Dpol)
params: pGroebnerPackage(Dom,Expon,Dpol)
comment:
\spad{groebner(lp,{} info,{} redcrit)} computes a groebner basis for a polynomial ideal generated by the list of polynomials \spad{lp},{} displaying both a summary of the critical pairs considered (\spad{info}) and the result of reducing each critical pair (redcrit). If the second or third arguments have any other string value,{} the indicated information is suppressed.


kind: o
name: groebnerFactorize
exposed: x
type: (List(Dpol))->List(List(Dpol))
params: pGroebnerFactorizationPackage(Dom,Expon,VarSet,Dpol)
comment:
\spad{groebnerFactorize(listOfPolys)} returns a list of groebner bases. The union of their solutions is the solution of the system of equations given by {\em listOfPolys}. At each stage the polynomial \spad{p} under consideration (either from the given basis or obtained from a reduction of the next \spad{S}-polynomial) is factorized. For each irreducible factors of \spad{p},{} a new {\em createGroebnerBasis} is started doing the usual updates with the factor in place of \spad{p}.


kind: o
name: groebnerFactorize
exposed: x
type: (List(Dpol),Boolean)->List(List(Dpol))
params: pGroebnerFactorizationPackage(Dom,Expon,VarSet,Dpol)
comment:
\spad{groebnerFactorize(listOfPolys,{} info)} returns a list of groebner bases. The union of their solutions is the solution of the system of equations given by {\em listOfPolys}. At each stage the polynomial \spad{p} under consideration (either from the given basis or obtained from a reduction of the next \spad{S}-polynomial) is factorized. For each irreducible factors of \spad{p},{} a new {\em createGroebnerBasis} is started doing the usual updates with the factor in place of \spad{p}. If {\em info} is \spad{true},{} information is printed about partial results.


kind: o
name: groebnerFactorize
exposed: x
type: (List(Dpol),List(Dpol))->List(List(Dpol))
params: pGroebnerFactorizationPackage(Dom,Expon,VarSet,Dpol)
comment:
\spad{groebnerFactorize(listOfPolys,{} nonZeroRestrictions)} returns a list of groebner basis. The union of their solutions is the solution of the system of equations given by {\em listOfPolys} under the restriction that the polynomials of {\em nonZeroRestrictions} don\spad{'t} vanish. At each stage the polynomial \spad{p} under consideration (either from the given basis or obtained from a reduction of the next \spad{S}-polynomial) is factorized. For each irreducible factors of \spad{p},{} a new {\em createGroebnerBasis} is started doing the usual updates with the factor in place of \spad{p}.


kind: o
name: groebnerFactorize
exposed: x
type: (List(Dpol),List(Dpol),Boolean)->List(List(Dpol))
params: pGroebnerFactorizationPackage(Dom,Expon,VarSet,Dpol)
comment:
\spad{groebnerFactorize(listOfPolys,{} nonZeroRestrictions,{} info)} returns a list of groebner basis. The union of their solutions is the solution of the system of equations given by {\em listOfPolys} under the restriction that the polynomials of {\em nonZeroRestrictions} don\spad{'t} vanish. At each stage the polynomial \spad{p} under consideration (either from the given basis or obtained from a reduction of the next \spad{S}-polynomial) is factorized. For each irreducible factors of \spad{p} a new {\em createGroebnerBasis} is started doing the usual updates with the factor in place of \spad{p}. If argument {\em info} is \spad{true},{} information is printed about partial results.


kind: o
name: groebnerIdeal
exposed: x
type: (List(DPoly))->%
params: dPolynomialIdeal(F,Expon,VarSet,DPoly)
comment:
\spad{groebnerIdeal(polyList)} constructs the ideal generated by the list of polynomials \spad{polyList} which are assumed to be a Groebner basis. Note: this operation avoids a Groebner basis computation.


kind: o
name: groebSolve
exposed: n
params: pGroebnerSolve(lv,F,R)
type:
(List(DistributedMultivariatePolynomial(lv,F)),List(OrderedVariableList(lv)))->List(List(DistributedMultivariatePolynomial(lv,F)))

comment:
\spad{groebSolve(lp,{} lv)} reduces the polynomial system \spad{lp} in variables \spad{lv} to triangular form. Algorithm based on groebner bases algorithm with linear algebra for change of ordering. Preprocessing for the general solver. The polynomials in input are of type \spadtype{DMP}.


kind: o
name: ground
exposed: x
type: (%)->R
params: cFunctionSpace2(R,K)
comment:
\spad{ground(f)} returns \spad{f} as an element of \spad{R}. An error occurs if \spad{f} is not an element of \spad{R}.


kind: o
name: group_terms
exposed: x
params: dPartialFraction(R)
comment: Should be local but conditional.
type:
(List(Record(num:R,d_fact:R,d_exp:NonNegativeInteger)))->List(Record(num:R,d_fact:R,d_exp:NonNegativeInteger))


kind: o
name: guess
exposed: x
type: (List(F))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guess l} applies recursively \spadfun{guessRat} to the successive differences and quotients of the list. Default options as described in \spadtype{GuessOptionFunctions0} are used.


kind: o
name: guess
exposed: x
type: (List(F),List(GuessOption))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guess(l,{} options)} applies recursively \spadfun{guessRat} to the successive differences and quotients of the list. The given options are used.


kind: o
name: guess
exposed: n
params: pGuessAlgebraicNumber
type:
(List(AlgebraicNumber),List((List(AlgebraicNumber),List(GuessOption))->List(Expression(Integer))),List(Symbol))->List(Expression(Integer))


kind: o
name: guess
exposed: x
params: pGuessFinite(F)
type:
(List(F),List((List(F),List(GuessOption))->List(Expression(Integer))),List(Symbol))->List(Expression(Integer))


kind: o
name: guess
exposed: x
type: (List(F),List((List(F),List(GuessOption))->List(EXPRR)),List(Symbol))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guess(l,{} guessers,{} ops)} applies recursively the given \spad{guessers} to the successive differences if ops contains the symbol guessSum and quotients if ops contains the symbol guessProduct to the list. Default options as described in \spadtype{GuessOptionFunctions0} are used.


kind: o
name: guess
exposed: x
params: pGuessInteger
type:
(List(Fraction(Integer)),List((List(Fraction(Integer)),List(GuessOption))->List(Expression(Integer))),List(Symbol))->List(Expression(Integer))


kind: o
name: guess
exposed: x
params: pGuessPolynomialInteger
type:
(List(Fraction(Polynomial(Integer))),List((List(Fraction(Polynomial(Integer))),List(GuessOption))->List(Expression(Integer))),List(Symbol))->List(Expression(Integer))


kind: o
name: guess
exposed: x
params: pGuessPolynomial(R)
type:
(List(Fraction(Polynomial(R))),List((List(Fraction(Polynomial(R))),List(GuessOption))->List(Expression(Integer))),List(Symbol))->List(Expression(Integer))


kind: o
name: guess
exposed: n
params: pGuessAlgebraicNumber
type:
(List(AlgebraicNumber),List((List(AlgebraicNumber),List(GuessOption))->List(Expression(Integer))),List(Symbol),List(GuessOption))->List(Expression(Integer))


kind: o
name: guess
exposed: x
params: pGuessFinite(F)
type:
(List(F),List((List(F),List(GuessOption))->List(Expression(Integer))),List(Symbol),List(GuessOption))->List(Expression(Integer))


kind: o
name: guess
exposed: x
params: pGuess(F,S,EXPRR,retract,coerce)
type:
(List(F),List((List(F),List(GuessOption))->List(EXPRR)),List(Symbol),List(GuessOption))->List(EXPRR)

comment:
\spad{guess(l,{} guessers,{} ops)} applies recursively the given \spad{guessers} to the successive differences if ops contains the symbol \spad{guessSum} and quotients if ops contains the symbol \spad{guessProduct} to the list. The given options are used.


kind: o
name: guess
exposed: x
params: pGuessInteger
type:
(List(Fraction(Integer)),List((List(Fraction(Integer)),List(GuessOption))->List(Expression(Integer))),List(Symbol),List(GuessOption))->List(Expression(Integer))


kind: o
name: guess
exposed: x
params: pGuessPolynomialInteger
type:
(List(Fraction(Polynomial(Integer))),List((List(Fraction(Polynomial(Integer))),List(GuessOption))->List(Expression(Integer))),List(Symbol),List(GuessOption))->List(Expression(Integer))


kind: o
name: guess
exposed: x
params: pGuessPolynomial(R)
type:
(List(Fraction(Polynomial(R))),List((List(Fraction(Polynomial(R))),List(GuessOption))->List(Expression(Integer))),List(Symbol),List(GuessOption))->List(Expression(Integer))


kind: o
name: guessADE
exposed: x
type: (List(F))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessADE l} tries to find an algebraic differential equation for a generating function whose first Taylor coefficients are given by \spad{l},{} using the default options described in \spadtype{GuessOptionFunctions0}.


kind: o
name: guessADE
exposed: x
type: (Symbol)->(List(F),List(GuessOption))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
abbrev: AND(has(F,RetractableTo(Symbol)),has(S,RetractableTo(Symbol)))
comment:
\spad{guessADE q} returns a guesser that tries to find an algebraic differential equation for a generating function whose first Taylor coefficients are given by \spad{l},{} using the given options.


kind: o
name: guessADE
exposed: x
type: (List(F),List(GuessOption))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessADE(l,{} options)} tries to find an algebraic differential equation for a generating function whose first Taylor coefficients are given by \spad{l},{} using the given options.


kind: o
name: guessAlg
exposed: x
type: (List(F))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessAlg l} tries to find an algebraic equation for a generating function whose first Taylor coefficients are given by \spad{l},{} using the default options described in \spadtype{GuessOptionFunctions0}. It is equivalent to \spadfun{guessADE}(\spad{l},{} maxDerivative \spad{==} 0).


kind: o
name: guessAlg
exposed: x
type: (List(F),List(GuessOption))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessAlg(l,{} options)} tries to find an algebraic equation for a generating function whose first Taylor coefficients are given by \spad{l},{} using the given options. It is equivalent to \spadfun{guessADE}(\spad{l},{} options) with \spad{maxDerivative == 0}.


kind: o
name: guessAlgDep
exposed: x
type: (List(List(F)))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessAlgDep ll} tries to find an algebraic dependence between several power series whose first Taylor coefficients are given by members of \spad{ll},{} using the default options described in \spadtype{GuessOptionFunctions0}.


kind: o
name: guessAlgDep
exposed: x
type: (List(List(F)),List(GuessOption))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessAlgDep ll} tries to find an algebraic dependence between several power series whose first Taylor coefficients are given by members of \spad{ll},{} using the given options.


kind: o
name: guessBinRat
exposed: n
type: (Symbol)->(List(F),List(GuessOption))->List(EXPRR)
params: pGuessExpBin(F,S,EXPRR,retract,coerce)
abbrev: AND(has(F,RetractableTo(Symbol)),has(S,RetractableTo(Symbol)))
comment:
\spad{guessBinRat q} returns a guesser that tries to find a function of the form \spad{n+}->qbinomial(a+b \spad{n},{} \spad{n}) \spad{r}(\spad{n}),{} where \spad{r}(\spad{q^n}) is a \spad{q}-rational function,{} that fits \spad{l}.


kind: o
name: guessBinRat
exposed: x
type: (List(F))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessBinRat(l,{} options)} tries to find a function of the form \spad{n+}->binomial(a+b \spad{n},{} \spad{n}) \spad{r}(\spad{n}),{} where \spad{r}(\spad{n}) is a rational function,{} that fits \spad{l}.


kind: o
name: guessExpRat
exposed: n
type: (Symbol)->(List(F),List(GuessOption))->List(EXPRR)
params: pGuessExpBin(F,S,EXPRR,retract,coerce)
abbrev: AND(has(F,RetractableTo(Symbol)),has(S,RetractableTo(Symbol)))
comment:
\spad{guessExpRat q} returns a guesser that tries to find a function of the form \spad{n+}->(a+b \spad{q^n})\spad{^n} \spad{r}(\spad{q^n}),{} where \spad{r}(\spad{q^n}) is a \spad{q}-rational function,{} that fits \spad{l}.


kind: o
name: guessExpRat
exposed: x
type: (List(F))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessExpRat l} tries to find a function of the form \spad{n+}->(a+b \spad{n})\spad{^n} \spad{r}(\spad{n}),{} where \spad{r}(\spad{n}) is a rational function,{} that fits \spad{l}.


kind: o
name: guessExpRat
exposed: n
type: (List(F),List(GuessOption))->List(EXPRR)
params: pGuessExpBin(F,S,EXPRR,retract,coerce)
comment:
\spad{guessExpRat(l,{} options)} tries to find a function of the form \spad{n+}->(a+b \spad{n})\spad{^n} \spad{r}(\spad{n}),{} where \spad{r}(\spad{n}) is a rational function,{} that fits \spad{l}.


kind: o
name: guessFE
exposed: x
type: (List(F))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessFE l} tries to find an algebraic substitution equation for a generating function whose first Taylor coefficients are given by \spad{l},{} using the default options described in \spadtype{GuessOptionFunctions0}.


kind: o
name: guessFE
exposed: x
type: (List(F),List(GuessOption))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessFE(l,{} options)} tries to find an algebraic substitution equation for a generating function whose first Taylor coefficients are given by \spad{l},{} using the given options.


kind: o
name: guessHolo
exposed: x
type: (List(F))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessHolo l} tries to find an ordinary linear differential equation for a generating function whose first Taylor coefficients are given by \spad{l},{} using the default options described in \spadtype{GuessOptionFunctions0}. It is equivalent to \spadfun{guessADE}\spad{(l,{} maxPower == 1)}.


kind: o
name: guessHolo
exposed: x
type: (Symbol)->(List(F),List(GuessOption))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
abbrev: AND(has(F,RetractableTo(Symbol)),has(S,RetractableTo(Symbol)))
comment:
\spad{guessHolo q} returns a guesser that tries to find a linear differential equation for a generating function whose first Taylor coefficients are given by \spad{l},{} using the given options.


kind: o
name: guessHolo
exposed: x
type: (List(F),List(GuessOption))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessHolo(l,{} options)} tries to find an ordinary linear differential equation for a generating function whose first Taylor coefficients are given by \spad{l},{} using the given options. It is equivalent to \spadfun{guessADE}\spad{(l,{} options)} with \spad{maxPower == 1}.


kind: o
name: guessPade
exposed: x
type: (List(F))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessPade(l,{} options)} tries to find a rational function whose first Taylor coefficients are given by \spad{l},{} using the default options described in \spadtype{GuessOptionFunctions0}. It is equivalent to \spadfun{guessADE}\spad{(l,{} options)} with \spad{maxDerivative == 0,{} maxPower == 1,{} allDegrees == true}.


kind: o
name: guessPade
exposed: x
type: (List(F),List(GuessOption))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessPade(l,{} options)} tries to find a rational function whose first Taylor coefficients are given by \spad{l},{} using the given options. It is equivalent to \spadfun{guessADE}\spad{(l,{} maxDerivative == 0,{} maxPower == 1,{} allDegrees == true)}.


kind: o
name: guessPRec
exposed: x
type: (List(F))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessPRec l} tries to find a linear recurrence with polynomial coefficients whose first values are given by \spad{l},{} using the default options described in \spadtype{GuessOptionFunctions0}. It is equivalent to \spadfun{guessRec}\spad{(l,{} maxPower == 1)}.


kind: o
name: guessPRec
exposed: x
type: (Symbol)->(List(F),List(GuessOption))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
abbrev: AND(has(F,RetractableTo(Symbol)),has(S,RetractableTo(Symbol)))
comment:
\spad{guessPRec q} returns a guesser that tries to find a linear \spad{q}-recurrence with polynomial coefficients whose first values are given by \spad{l},{} using the given options. It is equivalent to \spadfun{guessRec}\spad{(q)} with \spad{maxPower == 1}.


kind: o
name: guessPRec
exposed: x
type: (List(F),List(GuessOption))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessPRec(l,{} options)} tries to find a linear recurrence with polynomial coefficients whose first values are given by \spad{l},{} using the given options. It is equivalent to \spadfun{guessRec}\spad{(l,{} options)} with \spad{maxPower == 1}.


kind: o
name: guessRat
exposed: x
type: (List(F))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessRat l} tries to find a rational function whose first values are given by \spad{l},{} using the default options described in \spadtype{GuessOptionFunctions0}. It is equivalent to \spadfun{guessRec}\spad{(l,{} maxShift == 0,{} maxPower == 1,{} allDegrees == true)}.


kind: o
name: guessRat
exposed: x
type: (Symbol)->(List(F),List(GuessOption))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
abbrev: AND(has(F,RetractableTo(Symbol)),has(S,RetractableTo(Symbol)))
comment:
\spad{guessRat q} returns a guesser that tries to find a \spad{q}-rational function whose first values are given by \spad{l},{} using the given options. It is equivalent to \spadfun{guessRec} with \spad{(l,{} maxShift == 0,{} maxPower == 1,{} allDegrees == true)}.


kind: o
name: guessRat
exposed: x
type: (List(F),List(GuessOption))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessRat(l,{} options)} tries to find a rational function whose first values are given by \spad{l},{} using the given options. It is equivalent to \spadfun{guessRec}\spad{(l,{} maxShift == 0,{} maxPower == 1,{} allDegrees == true)}.


kind: o
name: guessRec
exposed: x
type: (List(F))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessRec l} tries to find an ordinary difference equation whose first values are given by \spad{l},{} using the default options described in \spadtype{GuessOptionFunctions0}.


kind: o
name: guessRec
exposed: x
type: (Symbol)->(List(F),List(GuessOption))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
abbrev: AND(has(F,RetractableTo(Symbol)),has(S,RetractableTo(Symbol)))
comment:
\spad{guessRec q} returns a guesser that finds an ordinary \spad{q}-difference equation whose first values are given by \spad{l},{} using the given options.


kind: o
name: guessRec
exposed: x
type: (List(F),List(GuessOption))->List(EXPRR)
params: pGuess(F,S,EXPRR,retract,coerce)
comment:
\spad{guessRec(l,{} options)} tries to find an ordinary difference equation whose first values are given by \spad{l},{} using the given options.


kind: o
name: hadamard
exposed: n
params: pUnivariateFormalPowerSeriesFunctions(Coef)
type:
(UnivariateFormalPowerSeries(Coef),UnivariateFormalPowerSeries(Coef))->UnivariateFormalPowerSeries(Coef)


kind: o
name: halfExtendedResultant1
exposed: n
type: (%,%)->Record(resultant:R,coef1:%)
params: dNewSparseUnivariatePolynomial(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{halfExtendedResultant1(a,{} b)} returns \spad{[r,{} ca]} such that \spad{extendedResultant(a,{} b)} returns \spad{[r,{} ca,{} cb]}


kind: o
name: halfExtendedResultant2
exposed: n
type: (%,%)->Record(resultant:R,coef2:%)
params: dNewSparseUnivariatePolynomial(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{halfExtendedResultant2(a,{} b)} returns \spad{[r,{} ca]} such that \spad{extendedResultant(a,{} b)} returns \spad{[r,{} ca,{} cb]}


kind: o
name: halfExtendedSubResultantGcd1
exposed: n
type: (%,%)->Record(gcd:%,coef1:%)
params: dNewSparseUnivariatePolynomial(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{halfExtendedSubResultantGcd1(a,{} b)} returns \spad{[g,{} ca]} such that \spad{extendedSubResultantGcd(a,{} b)} returns \spad{[g,{} ca,{} cb]}


kind: o
name: halfExtendedSubResultantGcd1
exposed: x
type: (%,%)->Record(gcd:%,coef1:%)
params: cRecursivePolynomialCategory(R,E,V)
abbrev: has(R,IntegralDomain)
comment:
\spad{halfExtendedSubResultantGcd1(a,{} b)} returns \spad{[g,{} ca]} if \spad{extendedSubResultantGcd(a,{} b)} returns \spad{[g,{} ca,{} cb]} otherwise produces an error.


kind: o
name: halfExtendedSubResultantGcd2
exposed: n
type: (%,%)->Record(gcd:%,coef2:%)
params: dNewSparseUnivariatePolynomial(R)
abbrev: has(R,IntegralDomain)
comment:
\spad{halfExtendedSubResultantGcd2(a,{} b)} returns \spad{[g,{} cb]} such that \spad{extendedSubResultantGcd(a,{} b)} returns \spad{[g,{} ca,{} cb]}


kind: o
name: halfExtendedSubResultantGcd2
exposed: x
type: (%,%)->Record(gcd:%,coef2:%)
params: cRecursivePolynomialCategory(R,E,V)
abbrev: has(R,IntegralDomain)
comment:
\spad{halfExtendedSubResultantGcd2(a,{} b)} returns \spad{[g,{} cb]} if \spad{extendedSubResultantGcd(a,{} b)} returns \spad{[g,{} ca,{} cb]} otherwise produces an error.


kind: o
name: handle_imaginary
exposed: n
params: pPointsOfFiniteOrder(R0,F,UP,UPUP,R)
comment: \spad{handle_imaginary(d)} should be local but conditional.
type:
(FiniteDivisor(F,UP,UPUP,R))->Record(ncurve:UPUP,n_div_numer:Vector(UPUP),n_div_denom:UPUP,need_change:Boolean)


kind: o
name: handler
exposed: n
type: (%,Integer,String)->HANDLER
params: dOperatorHandlers(HANDLER)
comment:
\spad{handler(x,{} n,{} op)} is only valid if \spad{knownHandler?(n,{} op)} is \spad{true}. It returns the respective handler stored in \spad{x}.


kind: o
name: hankelDeterminant
exposed: n
type: (Sequence(R),NonNegativeInteger)->R
params: pMomentPackage(R)
comment:
\spad{hankelDeterminant(x,{} n)} returns the \spad{n}th Hankel determinant of the sequence \spad{x}.


kind: o
name: hankelDeterminants
exposed: n
type: (%)->Stream(R)
params: cDistributionCategory(R)
comment:
\spad{hankelDeterminants(x)} returns the stream of hankel determinants of the distribution \spad{x}.


kind: o
name: hankelIndices
exposed: n
type: (XDistributedPolynomial(VAR,F))->List(FreeMonoid(VAR))
params: pXDistributedPolynomialFunctions(VAR,F)
comment:
\spad{hankelIndices(p)} returns a list of all left and right factors of the monomials of a given multivariate noncommutative polynomial. Factorization: \spad{w} = u*v


kind: o
name: HankelMatrix
exposed: n
type: (List(R))->Matrix(R)
params: pHankelPackage(R)
comment:
\spad{HankelMatrix([a_0,{} a_1,{} a_2,{} ...,{} a_{2n}])} builds the Hankel matrix [ \spad{a0},{} \spad{a1},{} ...,{} an ] [ \spad{a1},{} \spad{a2},{} ... ] [ ... ] [ an,{} ...,{} a2n]


kind: o
name: hankelMatrix
exposed: n
type: (XDistributedPolynomial(VAR,F))->Matrix(F)
params: pXDistributedPolynomialFunctions(VAR,F)
comment:
\spad{hankelMatrix(p)} returns the Hankel matrix \spad{H}(\spad{p}) of given polynomial \spad{p},{} \spadignore{i.e.} the entries at (\spad{u},{}\spad{v}) are the coefficients of the monomials \spad{w} = u*v. Rows and columns are indexed by words.


kind: o
name: hankelMatrix
exposed: n
type: (XDistributedPolynomial(VAR,F),VAR)->Matrix(F)
params: pXDistributedPolynomialFunctions(VAR,F)
comment:
\spad{hankelMatrix(p,{}x)} returns a matrix with the entries of the coefficients of \spad{p} at (\spad{u},{}\spad{v}) where the monomials factorizes through \spad{w} = u*x*v. This matrix is indexed by all words of the Hankel matrix.


kind: o
name: hankelSystem
exposed: n
params: pXDistributedPolynomialFunctions(VAR,F)
type:
(XDistributedPolynomial(VAR,F))->Record(rows:List(FreeMonoid(VAR)),cols:List(FreeMonoid(VAR)),H:Matrix(F))

comment:
\spad{hankelSystem(p)} creates a Hankel-matrix for the polynomial \spad{p} with respect to the basis of all factors in \spad{p}. Row- and column-indices can be different.


kind: o
name: harmonic
exposed: x
type: (Integer)->Fraction(Integer)
params: pIntegerNumberTheoryFunctions
comment:
\spad{harmonic(n)} returns the \spad{n}th harmonic number. This is \spad{H[n] = sum(1/k,{} k=1..n)}.


kind: o
name: hasDimension?
exposed: n
type: (%)->Boolean
params: dSimpleCell(TheField,ThePols)
comment:
\spad{hasDimension?(c)} returns \spad{true} if \spad{c} is of positive dimension (that is one-dimensional),{} otherwise hasDimension?(\spad{c}) returns \spad{false}


kind: o
name: hasDimension?
exposed: n
type: (%,Symbol)->Boolean
params: dCell(TheField)
comment:
\spad{hasDimension?(c)} returns \spad{true} if \spad{c} is of positive dimension. Otherwise hasDimension?(\spad{c}) returns \spad{false}.


kind: o
name: hashUpdate!
exposed: n
type: (HashState,%)->HashState
params: cHashable
comment:
\spad{hashUpdate!(hs,{} s)} computes new HashState from old and \spad{s} used for incremental computation of hash values. hashUpdate! might destructively work on its first argument.


kind: o
name: hasoln
exposed: n
type: (List(GR),List(GR))->Record(sysok:Boolean,z0:List(GR),n0:List(GR))
params: pParametricLinearEquations(R,Var,Expon,GR)
comment:
\spad{hasoln(g,{} l)} tests whether the quasi-algebraic set defined by \spad{p} = 0 for \spad{p} in \spad{g} and \spad{q} \spad{~=} 0 for \spad{q} in \spad{l} is empty or not and returns a simplified definition of the quasi-algebraic set


kind: o
name: has_op?
exposed: n
type: (OutputForm,Symbol)->Boolean
params: pOutputFormTools
comment:
\spad{has_op?(f,{} s)} returns \spad{true} is \spad{f} is a composite from with operator \spad{s},{} otherwise returns \spad{false}


kind: o
name: hclf
exposed: n
type: (%,%)->%
params: dFreeMonoid(S)
comment:
\spad{hclf(x,{} y)} returns the highest common left factor of \spad{x} and \spad{y},{} \spadignore{i.e.} the largest \spad{d} such that \spad{x = d a} and \spad{y = d b}.


kind: o
name: hconcat
exposed: n
type: (List(%))->%
params: dOutputBox
comment:
\spad{hconcat(lbox)} aligns the boxes at their baseline and concats those boxes horizontally from left to right.


kind: o
name: hcrf
exposed: n
type: (%,%)->%
params: dFreeMonoid(S)
comment:
\spad{hcrf(x,{} y)} returns the highest common right factor of \spad{x} and \spad{y},{} \spadignore{i.e.} the largest \spad{d} such that \spad{x = a d} and \spad{y = b d}.


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


kind: o
name: head
exposed: x
type: (%)->%
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{head(p)} returns \spad{p} if \spad{p} belongs to \spad{R},{} otherwise returns its leading term (monomial in the FriCAS sense),{} where \spad{p} is viewed as a univariate polynomial in its main variable.


kind: o
name: headReduce
exposed: x
type: (%,%)->%
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{headReduce(a,{} b)} returns a polynomial \spad{r} such that \spad{headReduced?(r,{} b)} holds and there exists an integer \spad{e} such that \spad{init(b)^e a - r} is zero modulo \spad{b}.


kind: o
name: headReduce
exposed: x
type: (P,%)->P
params: cTriangularSetCategory(R,E,V,P)
comment:
\spad{headReduce(p,{} ts)} returns a polynomial \spad{r} such that \spad{headReduce?(r,{} ts)} holds and there exists some product \spad{h} of \spad{initials(ts)} such that \spad{h*p - r} lies in the ideal generated by \spad{ts}.


kind: o
name: headReduced?
exposed: x
type: (%)->Boolean
params: cTriangularSetCategory(R,E,V,P)
comment:
\spad{headReduced?(ts)} returns \spad{true} iff the head of every element of \spad{ts} is reduced \spad{w}.\spad{r}.\spad{t} to any other element of \spad{ts}.


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


kind: o
name: headReduced?
exposed: x
type: (P,%)->Boolean
params: cTriangularSetCategory(R,E,V,P)
comment:
\spad{headReduced?(p,{} ts)} returns \spad{true} iff the head of \spad{p} is reduced \spad{w}.\spad{r}.\spad{t}. \spad{ts}.


kind: o
name: headRemainder
exposed: x
type: (P,%)->Record(num:P,den:R)
params: cPolynomialSetCategory(R,E,VarSet,P)
abbrev: has(R,IntegralDomain)
comment:
\spad{headRemainder(a,{} ps)} returns \spad{[b,{} r]} such that the leading monomial of \spad{b} is reduced in the sense of Groebner bases \spad{w}.\spad{r}.\spad{t}. \spad{ps} and \spad{r*a - b} lies in the ideal generated by \spad{ps}.


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


kind: o
name: height
exposed: n
type: (%)->NonNegativeInteger
params: dOutputBox
comment:
\spad{height(box)} returns the height of the \spad{box} (above the baseline) including the baseline.


kind: o
name: height
exposed: x
type: (%)->NonNegativeInteger
params: cExpressionSpace2(K)
comment:
\spad{height(f)} returns the highest nesting level appearing in \spad{f}. Constants have height 0. Symbols have height 1. For any operator op and expressions \spad{f1},{} ...,{} \spad{fn},{} \spad{op(f1,{} ...,{} fn)} has height equal to \spad{1 + max(height(f1),{} ...,{} height(fn))}.


kind: o
name: henselFact
exposed: n
type: (UP,Boolean)->Record(contp:Integer,factors:List(Record(irr:UP,pow:NonNegativeInteger)))
params: pGaloisGroupFactorizer(UP)
comment:
\spad{henselFact(p,{} sqf)} returns the factorization of \spad{p},{} the result is a Record such that \spad{contp=}content \spad{p},{} \spad{factors=}List of irreducible factors of \spad{p} with exponent. If \spad{sqf=true} the polynomial is assumed to be square free (\spadignore{i.e.} without repeated factors).


kind: o
name: HenselLift
exposed: n
type: (TP,List(TP),RP,PositiveInteger)->Record(plist:List(TP),modulo:RP)
params: pGeneralHenselPackage(RP,TP)
comment:
\spad{HenselLift(pol,{} lfacts,{} prime,{} bound)} lifts \spad{lfacts},{} that are the factors of \spad{pol} mod \spad{prime},{} to factors of \spad{pol} mod prime^k > bound. No recombining is done .


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


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


kind: o
name: HermiteIntegrate
exposed: n
params: pTranscendentalHermiteIntegration(F,UP)
type:
(Fraction(UP),(UP)->UP)->Record(answer:Fraction(UP),logpart:Fraction(UP),specpart:Fraction(UP),polypart:UP)

comment:
\spad{HermiteIntegrate(f,{} D)} returns \spad{[g,{} h,{} s,{} p]} such that \spad{f = Dg + h + s + p},{} \spad{h} has a squarefree denominator normal \spad{w}.\spad{r}.\spad{t}. \spad{D},{} and all the squarefree factors of the denominator of \spad{s} are special \spad{w}.\spad{r}.\spad{t}. \spad{D}. Furthermore,{} \spad{h} and \spad{s} have no polynomial parts. \spad{D} is the derivation to use on \spadtype{UP}.


kind: o
name: HermiteIntegrate
exposed: n
type: (R,(UP)->UP)->Record(answer:R,logpart:R)
params: pAlgebraicHermiteIntegration(F,UP,UPUP,R)
comment:
\spad{HermiteIntegrate(f,{} ')} returns \spad{[g,{} h]} such that \spad{f = g' + h} and \spad{h} has a only simple finite normal poles.


kind: o
name: HermiteIntegrate
exposed: n
params: pTranscendentalHermiteIntegration(F,UP)
type:
(Fraction(UP),(UP)->UP,UP)->Record(answer:Fraction(UP),logpart:Fraction(UP),specpart:Fraction(UP),polypart:UP)

comment:
\spad{HermiteIntegrate(f,{} D,{} d0)} returns \spad{[g,{} h,{} s,{} p]} such that \spad{f = Dg + g*d0 + h + s + p},{} \spad{h} has a squarefree denominator normal \spad{w}.\spad{r}.\spad{t}. \spad{D},{} and all the squarefree factors of the denominator of \spad{s} are special \spad{w}.\spad{r}.\spad{t}. \spad{D}. Furthermore,{} \spad{h} and \spad{s} have no polynomial parts. \spad{D} is the derivation to use on \spadtype{UP}.


kind: o
name: HermiteIntegrate
exposed: n
type: (R,(UP)->UP,R)->Record(answer:R,logpart:R)
params: pAlgebraicHermiteIntegration(F,UP,UPUP,R)
comment:
\spad{HermiteIntegrate(f,{} ',{} d0)} returns \spad{[g,{} h]} such that \spad{f = g' + d0*g + h} and \spad{h} has a only simple finite normal poles. Note: \spad{d0} must be integral.


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


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


kind: o
name: hexDigit?
exposed: x
type: (%)->Boolean
params: dCharacter
comment:
\spad{hexDigit?(c)} tests if \spad{c} is a hexadecimal numeral,{} \spadignore{i.e.} one of 0..9,{} a..\spad{f} or A..\spad{F}.


kind: o
name: hitherPlane
exposed: x
type: (%,Float)->Void
params: dThreeDimensionalViewport
comment:
\spad{hitherPlane(v,{} h)} sets the hither clipping plane of the graph to \spad{h},{} for the viewport \spad{v},{} which is of the domain \spadtype{ThreeDimensionalViewport}.


kind: o
name: homogeneous?
exposed: n
type: (%)->Boolean
params: dDeRhamComplex(CoefRing,listIndVar)
comment:
\spad{homogeneous?(df)} tests if all of the terms of differential form \spad{df} have the same degree.


kind: o
name: homogeneous
exposed: n
type: (List(GuessOption))->Union(PositiveInteger,Boolean)
params: dGuessOptionFunctions0
comment:
\spad{homogeneous returns} whether we allow only homogeneous algebraic differential equations,{} default being \spad{false}


kind: o
name: homogeneous
exposed: x
type: (Union(PositiveInteger,Boolean))->%
params: dGuessOption
comment:
\spad{homogeneous(d)} specifies whether we allow only homogeneous algebraic differential equations. This option is expressed in the form \spad{homogeneous == d}. If \spad{true},{} then maxPower must be set,{} too,{} and ADEs with constant total degree are allowed. If a PositiveInteger is given,{} only ADE\spad{'s} with this total degree are allowed.


kind: o
name: homology
exposed: n
type: (%)->List(Homology)
params: dFiniteSimplicialComplex(VS)
comment:
calculate homology using SmithNormalForm For more information: \url{http://www.euclideanspace.com/prog/scratchpad/mycode/topology/homology/index.\spad{htm}}


kind: o
name: homologyGroup
exposed: n
type: (Matrix(Integer),Matrix(Integer))->%
params: dHomology
comment:
construct from differential over integers uses method described by Waldek Hebisch here: https://groups.google.com/forum/?hl=en\#!topic/fricas-devel/mLOdQ-\spad{fwbO0}


kind: o
name: horizConcat
exposed: x
type: (List(%))->%
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{horizConcat(l)} horizontally concatenates all members of \spad{l} Error: if the arrays do not have the same number of rows.


kind: o
name: horizConcat
exposed: x
type: (%,%)->%
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{horizConcat(x,{} y)} horizontally concatenates two arrays with an equal number of rows. The entries of \spad{y} appear to the right of the entries of \spad{x}. Error: if the arrays do not have the same number of rows.


kind: o
name: horizJoin
exposed: n
type: (%,%)->%
params: dSparseEchelonMatrix(C,D)
comment:
\spad{horizJoin(A,{} B)} horizontally concats the matrices \spad{A} and \spad{B}. It is assumed that all indices of \spad{B} are smaller than those of \spad{A}.


kind: o
name: horizSplit
exposed: n
type: (%,C)->Record(Left:%,Right:%)
params: dSparseEchelonMatrix(C,D)
comment:
\spad{horizSplit(A,{} c)} splits the matrix \spad{A} into two at the column given by \spad{c}. The first column of the right matrix is enumerated by the first index less or equal to \spad{c}.


kind: o
name: horizSplit
exposed: x
type: (%,List(NonNegativeInteger))->List(%)
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{horizSplit(a,{} [n1,{} n2,{} ...,{} \spad{ni}])} splits a into arrays having \spad{n1},{} ...,{} \spad{ni} columns. Error: if number of columns of a is different than \spad{n1} + ... + \spad{ni}.


kind: o
name: horizSplit
exposed: x
type: (%,PositiveInteger)->List(%)
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{horizSplit(a,{} n)} splits a into \spad{n} arrays of equal size column wise. Error: if number of columns of a is not divisible by \spad{n}.


kind: o
name: hp_solve
exposed: n
params: pVectorHermitePadeSolver
type:
(List(Vector(SparseUnivariatePolynomial(Expression(Integer)))),List(NonNegativeInteger),NonNegativeInteger)->Matrix(SparseUnivariatePolynomial(Expression(Integer)))

comment:
\spad{hp_solve(lv,{} eta,{} K)} solves Hermite-Pade problem with degree bound \spad{eta} up to order \spad{K}.


kind: o
name: HP_solve
exposed: n
params: pModularHermitePadeSolver(F,S)
type:
(List(List(F)),List(Integer),Symbol,Symbol,NonNegativeInteger,(List(U32Vector),Integer,Integer)->Vector(U32Vector),(List(SparseUnivariatePolynomial(S)))->Union(good,reject,no_solution))->Union(Matrix(SparseUnivariatePolynomial(S)),Boolean)

comment:
\spad{HP_solve(l,{} degs,{} kind,{} sigma,{} gen check)} finds a \spad{sigma} basis with degree bounds given by \spad{degs}. It returns \spad{false} if there is no interpolating vector that is correct up to (and including) \spad{z^}(\spad{sigma}-1) with \spad{sigma} \spad{>=} |degs+[1,{} 1,{} ...,{} 1]| or if check rejects all solutions. It returns \spad{true} if it can not handle given problem.


kind: o
name: HP_solve_A
exposed: n
params: pModularHermitePade
comment: HP_solve_A is a fake solver over algebraic numbers.
type:
(List(List(AlgebraicNumber)),List(Integer),Symbol,NonNegativeInteger,(List(U32Vector),Integer,Integer)->Vector(U32Vector),(List(SparseUnivariatePolynomial(AlgebraicNumber)))->Union(good,reject,no_solution))->Union(Matrix(SparseUnivariatePolynomial(AlgebraicNumber)),Boolean)


kind: o
name: HP_solve_I
exposed: n
params: pModularHermitePade
comment: \spad{HP_solve_I implements} HP_solve over integers.
type:
(List(List(Fraction(Integer))),List(Integer),Symbol,NonNegativeInteger,(List(U32Vector),Integer,Integer)->Vector(U32Vector),(List(SparseUnivariatePolynomial(Integer)))->Union(good,reject,no_solution))->Union(Matrix(SparseUnivariatePolynomial(Integer)),Boolean)


kind: o
name: HP_solve_M
exposed: n
params: pModularHermitePade
comment: \spad{HP_solve_M implements} HP_solve over \$\spad{Z_p}\$ with machine-sized \$\spad{p}\$.
type:
(List(List(Integer)),List(Integer),Symbol,Integer,NonNegativeInteger,(List(U32Vector),Integer,Integer)->Vector(U32Vector),(List(SparseUnivariatePolynomial(Integer)))->Union(good,reject,no_solution))->Union(Matrix(SparseUnivariatePolynomial(Integer)),Boolean)


kind: o
name: HP_solve_P
exposed: n
params: pModularHermitePade
comment: \spad{HP_solve_P implements} HP_solve over integer polynomials.
type:
(List(List(Fraction(Polynomial(Integer)))),List(Integer),Symbol,Symbol,NonNegativeInteger,(List(U32Vector),Integer,Integer)->Vector(U32Vector),(List(SparseUnivariatePolynomial(Polynomial(Integer))))->Union(good,reject,no_solution))->Union(Matrix(SparseUnivariatePolynomial(Polynomial(Integer))),Boolean)


kind: o
name: HP_solve_PA
exposed: n
params: pModularHermitePade
comment: HP_solve_PA is a fake solver over polynomials having algebraic coefficients.
type:
(List(List(Fraction(Polynomial(AlgebraicNumber)))),List(Integer),Symbol,Symbol,NonNegativeInteger,(List(U32Vector),Integer,Integer)->Vector(U32Vector),(List(SparseUnivariatePolynomial(Polynomial(AlgebraicNumber))))->Union(good,reject,no_solution))->Union(Matrix(SparseUnivariatePolynomial(Polynomial(AlgebraicNumber))),Boolean)


kind: o
name: hue
exposed: n
type: (Point(R))->R
params: pPointPackage(R)
comment:
\spad{hue(pt)} returns the third element of the two dimensional point,{} \spad{pt},{} although no assumptions are made with regards as to how the components of higher dimensional points are interpreted. This function is defined for the convenience of the user using specifically,{} hue to express a third dimension.


kind: o
name: hyperelliptic
exposed: n
type: ()->Union(UP,failed)
params: xFunctionFieldCategory&(S,F,UP,UPUP)
comment:
\spad{hyperelliptic()} returns \spad{p(x)} if the curve is the hyperelliptic defined by \spad{y^2 = p(x)},{} failed otherwise.


kind: o
name: iCompose
exposed: n
type: (%,%)->%
params: dInnerSparseUnivariatePowerSeries(Coef)
comment:
\spad{iCompose(f,{} g)} returns \spad{f(g(x))}. This is an internal function which should only be called for Taylor series \spad{f(x)} and \spad{g(x)} such that the constant coefficient of \spad{g(x)} is zero.


kind: o
name: idealiser
exposed: n
type: (Matrix(R),Matrix(R),R)->Matrix(R)
params: pIntegralBasisTools(R,UP,F)
comment:
\spad{idealiser(m1,{} m2,{} d)} computes the order of an ideal defined by \spad{m1} and \spad{m2} where \spad{d} is the known part of the denominator


kind: o
name: idealiserMatrix
exposed: n
type: (Matrix(R),Matrix(R))->Matrix(R)
params: pIntegralBasisTools(R,UP,F)
comment:
\spad{idealiserMatrix(m1,{} m2)} returns the matrix representing the linear conditions on the Ring associated with an ideal defined by \spad{m1} and \spad{m2}.


kind: o
name: idealSimplify
exposed: n
type: (%)->%
params: dQuasiAlgebraicSet(R,Var,Expon,Dpoly)
comment:
\spad{idealSimplify(s)} returns a different and presumably simpler representation of \spad{s} with the defining polynomials for the equations forming a groebner basis,{} and the defining polynomial for the inequation reduced with respect to the basis,{} using Buchberger\spad{'s} algorithm.


kind: o
name: identification
exposed: n
type: (%,%)->List(Equation(R))
params: dLieExponentials(VarSet,R,Order)
comment:
\spad{identification(g,{} h)} returns the list of equations \spad{g_i = h_i},{} where \spad{g_i} (resp. \spad{h_i}) are exponential coordinates of \spad{g} (resp. \spad{h}).


kind: o
name: iExquo
exposed: n
type: (%,%,Boolean)->Union(%,failed)
params: dInnerSparseUnivariatePowerSeries(Coef)
comment:
\spad{iExquo(f,{} g,{} taylor?)} is the quotient of the power series \spad{f} and \spad{g}. If \spad{taylor?} is \spad{true},{} then we must have \spad{order(f) >= order(g)}.


kind: o
name: ignore?
exposed: n
type: (String)->Boolean
params: pDefiniteIntegrationTools(R,F)
comment:
\spad{ignore?(s)} is \spad{true} if \spad{s} is the string that tells the integrator to assume that the function has no pole in the integration interval.


kind: o
name: implies
exposed: n
type: (%,%)->%
params: dILogic
comment:
\spad{implies(a,{} b)} returns the logical implication of ILogic a and \spad{b}. a is premise,{} \spad{b} is conclusion,{} result is \spad{false} (contradiction) if premise=true and conclusion=false does not mean there is a causal connection


kind: o
name: inBounds?
exposed: n
type: (%,%,%)->Boolean
params: cSPointCategory
comment:
\spad{inBounds?(pt,{} mns,{} mxs)} returns \spad{true} if \spad{pt} is inside bounding box where bounding box is specified by min and max.


kind: o
name: incFail
exposed: n
type: (String,List(OutputForm))->Void
params: pUnittestCount
comment:
\spad{incFail(s,{} o)} is an internal function that steps the number of failed tests and records in- and output.


kind: o
name: incidenceAlgebra
exposed: n
type: (Matrix(R),List(S))->%
params: dIncidenceAlgebra(R,S)
comment:
\spad{incidenceAlgebra(A,{} ss)} constructs an adjacency matrix with with indices \spad{ss} and Matrix A


kind: o
name: incidenceMatrix
exposed: n
type: (%)->Matrix(Integer)
params: cFiniteGraph(S)
comment:
\spad{incidenceMatrix(s)} represents graph \spad{s} by a matrix of size \spad{|V|} by |E| where: V=number of vertices E=number of edges entry [vertex,{} arrow] = arrow endpoint data (undirected case case: 1 - incident,{} 0 - not incident,{} directed case: \spad{-1} - start,{} 1 - end,{} 0 - not incident).


kind: o
name: incLibraryError
exposed: n
type: (String,List(OutputForm))->Void
params: pUnittestCount
comment:
incLibraryError is an internal function that steps the number of failed tests,{} but not the number of tests.


kind: o
name: inconsistent?
exposed: n
type: (List(GR))->Boolean
params: pParametricLinearEquations(R,Var,Expon,GR)
comment:
\spad{inconsistent?(pl)} returns \spad{true} if the system of equations \spad{p} = 0 for \spad{p} in \spad{pl} is inconsistent. It is assumed that \spad{pl} is a groebner basis.


kind: o
name: incr
exposed: x
type: (%)->Integer
params: cSegmentCategory(S)
comment:
\spad{incr(s)} returns \spad{n},{} where \spad{s} is a segment in which every \spad{n}\spad{-}th element is used. Note: \spad{incr(l..h by n) = n}.


kind: o
name: increasePrecision
exposed: x
type: (Integer)->PositiveInteger
params: cFloatingPointSystem
abbrev: has(%,arbitraryPrecision)
comment:
\spad{increasePrecision(n)} increases the current \spadfunFrom{precision}{FloatingPointSystem} by \spad{n} decimal digits.


kind: o
name: increment
exposed: n
type: ()->(R)->R
params: pIncrementingMaps(R)
comment:
\spad{increment()} produces a function which adds \spad{1} to whatever argument it is given. For example,{} if {\spad{f} \spad{:=} increment()} then \spad{f x} is \spad{x+1}.


kind: o
name: incrementBy
exposed: n
type: (R)->(R)->R
params: pIncrementingMaps(R)
comment:
\spad{incrementBy(n)} produces a function which adds \spad{n} to whatever argument it is given. For example,{} if {\spad{f} \spad{:=} increment(\spad{n})} then \spad{f x} is \spad{x+n}.


kind: o
name: incrementKthElement
exposed: n
type: (%,PositiveInteger)->Union(%,failed)
params: dSetOfMIntegersInOneToN(m,n)
comment:
\spad{incrementKthElement(S,{} k)} increments the \spad{k^}{th} element of \spad{S},{} and returns failed if the result is not a set of \spad{M} integers in \spad{1..n} any more.


kind: o
name: incXfPass
exposed: n
type: (String,List(OutputForm))->Void
params: pUnittestCount
comment:
\spad{incXfPass(s,{} o)} is an internal function that steps the number of tests that passed but were expected to fail and records in- and output.


kind: o
name: index
exposed: x
type: (PositiveInteger)->%
params: cFinite
comment:
\spad{index(i)} takes a positive integer \spad{i} less than or equal to \spad{size()} and returns the \spad{i}\spad{-}th element of the set. This operation establishes a bijection between the elements of the finite set and \spad{1..size()}.


kind: o
name: indexName
exposed: n
type: (List(GuessOption))->Symbol
params: dGuessOptionFunctions0
comment:
\spad{indexName returns} the name of the index variable used for the formulas,{} default being \spad{n}


kind: o
name: indexName
exposed: x
type: (Symbol)->%
params: dGuessOption
comment:
\spad{indexName(d)} specifies the index variable used for the formulas. This option is expressed in the form \spad{indexName == d}.


kind: o
name: indiceSubResultantEuclidean
exposed: n
type: (polR,polR,NonNegativeInteger)->Record(coef1:polR,coef2:polR,subResultant:polR)
params: pPseudoRemainderSequence(R,polR)
comment:
\spad{indiceSubResultant(P,{} Q,{} i)} returns the subresultant \spad{S_i(P,{} Q)} and carries out the equality \spad{coef1*P + coef2*Q = S_i(P,{} Q)}


kind: o
name: indicialEquations
exposed: n
type: (L)->List(Record(center:UP,equation:UP))
params: pPrimitiveRatDE(F,UP,L,LQ)
comment:
\spad{indicialEquations op} returns \spad{[[d1,{} e1],{} ...,{} [dq,{} eq]]} where the \spad{d_i}\spad{'s} are the affine singularities of \spad{op},{} and the \spad{e_i}\spad{'s} are the indicial equations at each \spad{d_i}.


kind: o
name: indicialEquations
exposed: n
type: (LQ,UP)->List(Record(center:UP,equation:UP))
params: pPrimitiveRatDE(F,UP,L,LQ)
comment:
\spad{indicialEquations(op,{} p)} returns \spad{[[d1,{} e1],{} ...,{} [dq,{} eq]]} where the \spad{d_i}\spad{'s} are the affine singularities of \spad{op} above the roots of \spad{p},{} and the \spad{e_i}\spad{'s} are the indicial equations at each \spad{d_i}.


kind: o
name: infieldint
exposed: n
type: (Fraction(UP))->Union(Fraction(UP),failed)
params: pRationalIntegration(F,UP)
comment:
\spad{infieldint(f)} returns \spad{g} such that \spad{g' = f} or failed if the integral of \spad{f} is not a rational function.


kind: o
name: infieldIntegrate
exposed: x
type: (Fraction(Polynomial(F)),Symbol)->Union(Fraction(Polynomial(F)),failed)
params: pRationalFunctionIntegration(F)
comment:
\spad{infieldIntegrate(f,{} x)} returns a fraction \spad{g} such that \spad{dg/dx = f} if \spad{g} exists,{} failed otherwise.


kind: o
name: infiniteProduct
exposed: x
type: (UTS)->UTS
params: pInfiniteLambertProduct(Coef,UTS)
comment:
\spad{infiniteProduct(f(x))} computes \spad{product(n=1,{} 2,{} 3...,{} f(x^n))}. The series \spad{f(x)} should have constant coefficient 1.


kind: o
name: infinityNorm
exposed: n
type: (UP)->F
params: pGaloisGroupFactorizationUtilities(R,UP,F)
comment:
\spad{infinityNorm(f)} returns the maximal absolute value of the coefficients of the polynomial \spad{f}.


kind: o
name: infix?
exposed: n
type: (%)->Boolean
params: dOutputForm
comment:
\spad{infix?(op)} returns \spad{true} if \spad{op} is an infix operator,{} and \spad{false} otherwise.


kind: o
name: infix
exposed: n
type: (%,List(%))->%
params: dOutputForm
comment:
\spad{infix(f,{} l)} creates a form depicting the \spad{n}-ary application of infix operation \spad{f} to a tuple of arguments \spad{l}.


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

comment:
\spad{infix(op,{} p,{} h1,{} h2)} returns a handler \spad{h} such that \spad{h(prec,{} args)} formats the first argument by \spad{h1} and the second argument by \spad{h2}. Both boxes will be horizontally concatenated with \spad{box op} in the middle. Outer parentheses are added if \spad{p < prec}.


kind: o
name: infLex?
exposed: n
type: (%,%,(V,V)->Boolean,(C,C)->Boolean)->Boolean
params: dSplittingNode(V,C)
comment:
\spad{infLex?(n1,{} n2,{} o1,{} o2)} returns \spad{true} iff \spad{o1(value(n1),{} value(n2))} or \spad{value(n1) = value(n2)} and \spad{o2(condition(n1),{} condition(n2))}.


kind: o
name: infRittWu?
exposed: x
type: (%,%)->Boolean
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{infRittWu?(a,{} b)} returns \spad{true} if \spad{a} is less than \spad{b} \spad{w}.\spad{r}.\spad{t}. the Ritt and Wu Wen Tsun ordering using the refinement of Lazard.


kind: o
name: infRittWu?
exposed: x
type: (%,%)->Boolean
params: cTriangularSetCategory(R,E,V,P)
comment:
\spad{infRittWu?(ts1,{} ts2)} returns \spad{true} iff \spad{ts2} has higher rank than \spad{ts1} in Wu Wen Tsun sense.


kind: o
name: infsum
exposed: n
type: (Stream(%))->%
params: dGeneralizedUnivariatePowerSeries(Coef,Expon,var,cen)
comment:
\spad{infsum(x)} computes sum of all elements of \spad{x}. Degrees of elements of \spad{x} must be nondecreasing and tend to infinity.


kind: o
name: inHallBasis?
exposed: x
type: (Integer,Integer,Integer,Integer)->Boolean
params: pHallBasis
comment:
\spad{inHallBasis?(numberOfGens,{} leftCandidate,{} rightCandidate,{} left)} tests to see if a new element should be added to the \spad{P}. Hall basis being constructed. The list \spad{[leftCandidate,{} wt,{} rightCandidate]} is included in the basis if in the unique factorization of \spad{rightCandidate},{} we have left factor leftOfRight,{} and leftOfRight \spad{<=} \spad{leftCandidate}


kind: o
name: ini_rdata
exposed: n
type: (PA,MD)->PMD
params: cModularFactorizationOperations(PA,MMT,MD,PMD)
comment:
\spad{ini_rdata(pv,{} p)} generates data allowing faster computation of remainders from division by \spad{pv} modulo \spad{p}. Result is used by other functions in this package,{} in particular \spad{red_pol!}.


kind: o
name: init
exposed: x
type: (%)->%
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{init(p)} returns an error if \spad{p} belongs to \spad{R},{} otherwise returns its leading coefficient,{} where \spad{p} is viewed as a univariate polynomial in its main variable.


kind: o
name: initial
exposed: x
type: (%)->%
params: cDifferentialPolynomialCategory(R,S,V,E)
comment:
\spad{initial(p)} returns the leading coefficient when the differential polynomial \spad{p} is written as a univariate polynomial in its leader.


kind: o
name: initializeGroupForWordProblem
exposed: x
type: (%)->Void
params: dPermutationGroup(S)
comment:
\spad{initializeGroupForWordProblem(gp)} initializes the group {\em gp} for the word problem. Notes: it calls the other function of this name with parameters 0 and 1: {\em initializeGroupForWordProblem(gp,{} 0,{} 1)}. Notes: (1) be careful: invoking this routine will destroy the possibly information about your group (but will recompute it again) (2) users need not call this function normally for the solution of the word problem.


kind: o
name: initializeGroupForWordProblem
exposed: x
type: (%,Integer,Integer)->Void
params: dPermutationGroup(S)
comment:
\spad{initializeGroupForWordProblem(gp,{} m,{} n)} initializes the group {\em gp} for the word problem. Notes: (1) with a small integer you get shorter words,{} but the routine takes longer than the standard routine for longer words. (2) be careful: invoking this routine will destroy the possibly stored information about your group (but will recompute it again). (3) users need not call this function normally for the solution of the word problem.


kind: o
name: initiallyReduce
exposed: x
type: (%,%)->%
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{initiallyReduce(a,{} b)} returns a polynomial \spad{r} such that \spad{initiallyReduced?(r,{} b)} holds and there exists an integer \spad{e} such that \spad{init(b)^e a - r} is zero modulo \spad{b}.


kind: o
name: initiallyReduce
exposed: x
type: (P,%)->P
params: cTriangularSetCategory(R,E,V,P)
comment:
\spad{initiallyReduce(p,{} ts)} returns a polynomial \spad{r} such that \spad{initiallyReduced?(r,{} ts)} holds and there exists some product \spad{h} of \spad{initials(ts)} such that \spad{h*p - r} lies in the ideal generated by \spad{ts}.


kind: o
name: initiallyReduced?
exposed: x
type: (%)->Boolean
params: cTriangularSetCategory(R,E,V,P)
comment:
\spad{initiallyReduced?(ts)} returns \spad{true} iff for every element \spad{p} of \spad{ts} \spad{p} and all its iterated initials are reduced \spad{w}.\spad{r}.\spad{t}. to the other elements of \spad{ts} with the same main variable.


kind: o
name: initiallyReduced?
exposed: x
type: (%,%)->Boolean
params: cRecursivePolynomialCategory(R,E,V)
comment:
\spad{initiallyReduced?(a,{} b)} returns \spad{false} iff there exists an iterated initial of \spad{a} which is not reduced \spad{w}.\spad{r}.\spad{t} \spad{b}.


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


kind: o
name: initiallyReduced?
exposed: x
type: (P,%)->Boolean
params: cTriangularSetCategory(R,E,V,P)
comment:
\spad{initiallyReduced?(p,{} ts)} returns \spad{true} iff \spad{p} and all its iterated initials are reduced \spad{w}.\spad{r}.\spad{t}. to the elements of \spad{ts} with the same main variable.


kind: o
name: innerEigenvectors
exposed: n
params: pInnerNumericEigenPackage(K,F,Par)
type:
(Matrix(K),Par,(SparseUnivariatePolynomial(K))->Factored(SparseUnivariatePolynomial(K)))->List(Record(outval:F,outmult:Integer,outvect:List(Matrix(F))))

comment:
\spad{innerEigenvectors(m,{} eps,{} factor)} computes explicitly the eigenvalues and the correspondent eigenvectors of the matrix \spad{m}. The parameter \spad{eps} determines the type of the output,{} factor is the univariate factorizer used to reduce the characteristic polynomial into irreducible factors.


kind: o
name: innerint
exposed: x
params: pElementaryFunctionDefiniteIntegration(R,F)
comment: \spad{innerint(f,{} x,{} a,{} b,{} ignore?)} should be local but conditional
type:
(F,Symbol,OrderedCompletion(F),OrderedCompletion(F),Boolean)->Union(f1:OrderedCompletion(F),f2:List(OrderedCompletion(F)),fail:failed,pole:potentialPole)


kind: o
name: innerSolve1
exposed: n
type: (Polynomial(K),Par)->List(F)
params: pInnerNumericFloatSolvePackage(K,F,Par)
comment:
\spad{innerSolve1(p,{} eps)} returns the list of the zeros of the polynomial \spad{p} with precision eps.


kind: o
name: innerSolve1
exposed: n
type: (SparseUnivariatePolynomial(K),Par)->List(F)
params: pInnerNumericFloatSolvePackage(K,F,Par)
comment:
\spad{innerSolve1(up,{} eps)} returns the list of the zeros of the univariate polynomial \spad{up} with precision eps.


kind: o
name: innerSolve
exposed: n
type: (List(Polynomial(K)),List(Polynomial(K)),List(Symbol),Par)->List(List(F))
params: pInnerNumericFloatSolvePackage(K,F,Par)
comment:
\spad{innerSolve(lnum,{} lden,{} lvar,{} eps)} returns a list of solutions of the system of polynomials \spad{lnum},{} with the side condition that none of the members of \spad{lden} vanish identically on any solution. Each solution is expressed as a list corresponding to the list of variables in \spad{lvar} and with precision specified by eps.


kind: o
name: input
exposed: x
type: (%)->Union((List(InputForm))->InputForm,failed)
params: dBasicOperator
comment:
\spad{input(op)} returns the \%input property of \spad{op} if it has one attached,{} failed otherwise.


kind: o
name: input
exposed: x
type: (%,(List(InputForm))->InputForm)->%
params: dBasicOperator
comment:
\spad{input(op,{} foo)} attaches foo as the \%input property of \spad{op}. If \spad{op} has a \%input property \spad{f},{} then \spad{op(a1,{}...,{}an)} gets converted to InputForm as \spad{f(a1,{} ...,{} an)}.


kind: o
name: inRadical?
exposed: x
type: (DPoly,%)->Boolean
params: dPolynomialIdeal(F,Expon,VarSet,DPoly)
comment:
\spad{inRadical?(f,{} I)} tests if some power of the polynomial \spad{f} belongs to the ideal \spad{I}.


kind: o
name: insert!
exposed: x
type: (%,%,Integer)->%
params: cExtensibleLinearAggregate(S)
comment:
\spad{insert!(v,{} u,{} i)} destructively inserts aggregate \spad{v} into \spad{u} at position \spad{i}.


kind: o
name: insert
exposed: x
type: (%,%,Integer)->%
params: cLinearAggregate(S)
comment:
\spad{insert(v,{} u,{} i)} returns a copy of \spad{u} having \spad{v} inserted beginning at the \spad{i}th element. Note: \spad{insert(v,{} u,{} i) = concat(u(minIndex(u)..i-1),{} concat(v,{} u(i..)))}.


kind: o
name: insert
exposed: x
type: (S,%,Integer)->%
params: cLinearAggregate(S)
comment:
\spad{insert(x,{} u,{} i)} returns a copy of \spad{u} having \spad{x} as its \spad{i}th element. Note: \spad{insert(x,{} u,{} i) = concat(u(minIndex(u)..i-1),{} concat(x,{} u(i..)))}.


kind: o
name: insert!
exposed: x
type: (S,%,NonNegativeInteger)->%
params: cMultiDictionary(S)
comment:
\spad{insert!(x,{} d,{} n)} destructively inserts \spad{n} copies of \spad{x} into dictionary \spad{d}.


kind: o
name: insertBottom!
exposed: x
type: (S,%)->S
params: cDequeueAggregate(S)
comment:
\spad{insertBottom!(x,{} d)} destructively inserts \spad{x} into the dequeue \spad{d} at the bottom (back) of the dequeue.


kind: o
name: insertMatch
exposed: n
type: (Pattern(R),S,%)->%
params: dPatternMatchResult(R,S)
comment:
\spad{insertMatch(var,{} expr,{} r)} adds the match (\spad{var},{} \spad{expr}) in \spad{r},{} without checking predicates or previous matches for \spad{var}.


kind: o
name: insertRowsColumns
exposed: n
type: (%,List(NonNegativeInteger),List(NonNegativeInteger))->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{insertRowsColumns(f,{} lst_row,{} lst_col)} returns a new system with rows and columns inserted. An index \spad{k} means a new row/column between \spad{k} and \spad{k+1}. The number of rows and columns have to be the same!


kind: o
name: insertRowsColumns
exposed: n
type: (%,List(NonNegativeInteger),List(NonNegativeInteger))->%
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{insertRowsColumns(p,{} lst_row,{} lst_col)} returns a new pencil with additional rows and columns after the specified indices. addRowsColumns(\spad{p},{} [0,{}0,{}1],{} [0,{}0,{}3]) would insert 2 rows and columns at the beginning an one row and column between rows 1 and 2 and columns 3 and 4 respectively.


kind: o
name: insertTop!
exposed: x
type: (S,%)->S
params: cDequeueAggregate(S)
comment:
\spad{insertTop!(x,{} d)} destructively inserts \spad{x} into the dequeue \spad{d},{} that is,{} at the top (front) of the dequeue. The element previously at the top of the dequeue becomes the second in the dequeue,{} and so on.


kind: o
name: int
exposed: n
type: (A)->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{int(r)} returns [\spad{r},{} \spad{r+1},{} \spad{r+2},{} ...],{} where \spad{r} is a ring element.


kind: o
name: int
exposed: n
type: (%,%)->%
params: dOutputForm
comment:
\spad{int(expr,{} lowerlimit)} creates the form prefixing \spad{expr} by an integral sign with a lowerlimit.


kind: o
name: int
exposed: n
type: (%,%,%)->%
params: dOutputForm
comment:
\spad{int(expr,{} lowerlimit,{} upperlimit)} creates the form prefixing \spad{expr} by an integral sign with both a \spad{lowerlimit} and upperlimit.


kind: o
name: intBasis
exposed: n
type: (List(%))->%
params: dVectorSpaceBasis(R)
comment:
\spad{intBasis Lb} computes a basis of the intersection of the list of subspaces represented by \spad{LLv}.


kind: o
name: intBasis
exposed: n
type: (List(List(Vector(R))))->%
params: dVectorSpaceBasis(R)
comment:
\spad{intBasis LLv} computes a basis of the intersection of the list of subspaces represented by \spad{LLv}.


kind: o
name: intBasis
exposed: n
type: (List(Vector(R)),List(Vector(R)))->%
params: dVectorSpaceBasis(R)
comment:
\spad{intBasis(Lv1,{} Lv2)} computes a basis of the intersection of the two subspaces spanned by the vectors of \spad{Lv1} and \spad{Lv2}.


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


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


kind: o
name: integer
exposed: n
type: (OutputForm)->Integer
params: pOutputFormTools
comment:
\spad{integer(f)} gives integer corresponding to \spad{f}. Valid only when integer?(\spad{f}) is \spad{true}


kind: o
name: integer
exposed: x
type: (%)->Int
params: cSExpressionCategory(Str,Sym,Int,Flt)
comment:
\spad{integer(s)} returns \spad{s} as an element of Int. Error: if \spad{s} is not an atom that also belongs to Int.


kind: o
name: integerBound
exposed: n
type: (UP)->Integer
params: pBoundIntegerRoots(F,UP)
comment:
\spad{integerBound(p)} returns a lower bound on the negative integer roots of \spad{p},{} and 0 if \spad{p} has no negative integer roots.


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


kind: o
name: integral
exposed: n
type: (Integer)->(Integer,List(OutputForm))->OutputBox
params: cFormatterCategory
comment:
\spad{integral(p)} returns a handler \spad{h} such that \spad{h(prec,{} args)} formats the expression as an integral with integral sign and respective limits. Outer parentheses are added if \spad{p < prec}.


kind: o
name: integral
exposed: n
type: (F,SegmentBinding(F))->F
params: pLiouvillianFunction(R,F)
comment:
\spad{integral(f,{} x = a..b)} denotes the definite integral of \spad{f} with respect to \spad{x} from \spad{a} to \spad{b}.


kind: o
name: integral
exposed: x
type: (%,SegmentBinding(%))->%
params: cPrimitiveFunctionCategory
comment:
\spad{integral(f,{} x = a..b)} returns the formal definite integral of \spad{f} \spad{dx} for \spad{x} between \spad{a} and \spad{b}.


kind: o
name: integralBasis
exposed: n
type: ()->Record(basis:Matrix(Integer),basisDen:Integer,basisInv:Matrix(Integer))
params: pNumberFieldIntegralBasis(UP,F)
comment:
\spad{integralBasis()} returns a record \spad{[basis,{} basisDen,{} basisInv]} containing information regarding the integral closure of \spad{Z} 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: integralBasis
exposed: n
type: ()->Record(basis:Matrix(R),basisDen:R,basisInv:Matrix(R))
params: pFunctionFieldIntegralBasis(R,UP,F)
comment:
\spad{integralBasis()} returns a record \spad{[basis,{} basisDen,{} basisInv]} containing information regarding the integral closure of \spad{R} 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 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: integralBasis
exposed: n
type: ()->Record(basis:Matrix(R),basisDen:R,basisInv:Matrix(R))
params: pPAdicWildFunctionFieldIntegralBasis(K,R,UP,F)
comment:
\spad{integralBasis()} returns a record \spad{[basis,{} basisDen,{} basisInv] } containing information regarding the integral closure of \spad{R} 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 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: integralCoordinates
exposed: x
type: (%)->Record(num:Vector(UP),den:UP)
params: cFunctionFieldCategory(F,UP,UPUP)
comment:
\spad{integralCoordinates(f)} returns \spad{[[A1,{} ...,{} An],{} D]} such that \spad{f = (A1 w1 +...+ An wn) / D} where \spad{(w1,{} ...,{} wn)} is the integral basis returned by \spad{integralBasis()}.


kind: o
name: integralDerivationMatrix
exposed: x
type: ((UP)->UP)->Record(num:Matrix(UP),den:UP)
params: cFunctionFieldCategory(F,UP,UPUP)
comment:
\spad{integralDerivationMatrix(d)} extends the derivation \spad{d} from UP to \$ and returns (\spad{M},{} \spad{Q}) such that the i^th row of \spad{M} divided by \spad{Q} form the coordinates of \spad{d(\spad{wi})} with respect to \spad{(w1,{} ...,{} wn)} where \spad{(w1,{} ...,{} wn)} is the integral basis returned by integralBasis().


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


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


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


kind: o
name: integralRepresents
exposed: x
type: (Vector(UP),UP)->%
params: cFunctionFieldCategory(F,UP,UPUP)
comment:
\spad{integralRepresents([A1,{} ...,{} An],{} D)} returns \spad{(A1 w1+...+An wn)/D} where \spad{(w1,{} ...,{} wn)} is the integral basis of \spad{integralBasis()}.


kind: o
name: integrate
exposed: n
type: (%)->%
params: cUnivariateSeriesWithRationalExponents(Coef,Expon)
abbrev: has(Coef,Algebra(Fraction(Integer)))
comment:
\spad{integrate(f(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: n
type: (%)->%
params: dInnerSparseUnivariatePowerSeries(Coef)
abbrev: has(Coef,Algebra(Fraction(Integer)))
comment:
\spad{integrate(f(x))} returns an anti-derivative of the power series \spad{f(x)} with constant coefficient 0. Warning: function does not check for a term of degree \spad{-1}.


kind: o
name: integrate
exposed: x
type: (%)->%
params: cUnivariatePolynomialCategory(R)
abbrev: has(R,Algebra(Fraction(Integer)))
comment:
\spad{integrate(p)} integrates the univariate polynomial \spad{p} with respect to its distinguished variable.


