# olibdb

kind: c
name: AbelianGroup
exposed: x
type: ()->Category
abbrev: ABELGRP
comment:
The class of abelian groups,{} \spadignore{i.e.} additive monoids where each element has an additive inverse. \blankline


kind: c
name: AbelianMonoid
exposed: x
type: ()->Category
abbrev: ABELMON
comment:
The class of multiplicative monoids,{} \spadignore{i.e.} semigroups with an additive identity element. \blankline


kind: c
name: AbelianMonoidRing
exposed: x
type: (Join(SemiRng,etc),OrderedAbelianMonoid)->Category
params: (R,E)
abbrev: AMR
comment:
Abelian monoid ring elements (not necessarily of finite support) of this ring are of the form formal SUM (r_i * e_i) where the r_i are coefficients and the e_i,{} elements of the ordered abelian monoid,{} are thought of as exponents or monomials. The monomials commute with each other,{} but in general do not commute with the coefficients (which themselves may or may not be commutative). See \spadtype{FiniteAbelianMonoidRing} for the case of finite support. A useful common model for polynomials and power series. Conceptually at least,{} only the non-zero terms are ever operated on.


kind: c
name: AbelianSemiGroup
exposed: x
type: ()->Category
abbrev: ABELSG
comment:
the class of all additive (commutative) semigroups,{} \spadignore{i.e.} a set with a commutative and associative operation \spadop{+}. \blankline


kind: c
name: additiveValuation
exposed: n
type: ()->Category
abbrev: ATADDVA
comment:
The class of all euclidean domains such that \spad{euclideanSize(a*b)=euclideanSize(a)+euclideanSize(b)}.


kind: c
name: Aggregate
exposed: x
type: ()->Category
abbrev: AGG
comment:
The notion of aggregate serves to model any data structure aggregate,{} designating any collection of objects,{} with heterogeneous or homogeneous members,{} with a finite or infinite number of members,{} explicitly or implicitly represented. An aggregate can in principle represent everything from a string of characters to abstract sets such as the set of \spad{x} satisfying relation {\em r(x)}. An attribute \spadtype{finiteAggregate} is used to assert that a domain has a finite number of elements.


kind: c
name: AssociationListAggregate
exposed: x
type: (SetCategory,Type)->Category
params: (Key,Entry)
abbrev: ALAGG
comment:
An association list is a list of key entry pairs which may be viewed as a table. It is a poor mans version of a table: searching for a key is a linear operation.


kind: c
name: BagAggregate
exposed: x
type: (Type)->Category
params: (S)
abbrev: BGAGG
comment:
A bag aggregate is an aggregate for which one can insert and extract objects,{} and where the order in which objects are inserted determines the order of extraction. Examples of bags are stacks,{} queues,{} and dequeues.


kind: c
name: BasicType
exposed: x
type: ()->Category
abbrev: BASTYPE
comment:
\spadtype{BasicType} is the basic category for describing a collection of elements with \spadop{=} (equality).


kind: c
name: Bialgebra
exposed: x
type: (R:CommutativeRing,Module(R))->Category
params: (R,MxM)
abbrev: BIALG
comment:
A bialgebra is a coalgebra which at the same time is an algebra such that the comultiplication is also an algebra homomorphism. MxM: Module(\spad{R}) should be replaced by a more restricted category,{} but it is not clear at this point which one.


kind: c
name: BiCPO
exposed: n
type: (SetCategory)->Category
params: (S)
abbrev: BICPO
comment:
Complete partial Order,{} partial order that is guaranteed to have both a join and a meet of any two elements. For more documentation see: \indented{2}{\url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.\spad{htm}}}


kind: c
name: BiModule
exposed: x
type: (SemiRng,SemiRng)->Category
params: (R,S)
abbrev: BMODULE
comment:
A \spadtype{BiModule} is both a left and right module with respect to potentially different rings. \blankline


kind: c
name: BinaryRecursiveAggregate
exposed: x
type: (Type)->Category
params: (S)
abbrev: BRAGG
comment:
A binary-recursive aggregate has 0,{} 1 or 2 children and serves as a model for a binary tree or a doubly-linked aggregate structure


kind: c
name: BinaryTreeCategory
exposed: x
type: (SetCategory)->Category
params: (S)
abbrev: BTCAT
comment:
\spadtype{BinaryTreeCategory(S)} is the category of binary trees: a tree which is either empty or has a \spadfun{node} consisting of a value and a \spadfun{left} and \spadfun{right} which are both binary trees.


kind: c
name: BoundedDistributiveLattice
exposed: n
type: ()->Category
abbrev: BDISTL
comment:
not every lattice is distributive so treat this \indented{13}{as a separate case} \indented{2}{for more documentation see:} \indented{2}{\url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.\spad{htm}}}


kind: c
name: BoundedJoinSemilattice
exposed: n
type: ()->Category
abbrev: BJOIN
comment:
join semilattice with bottom \indented{2}{Different from exterior Grassmann product operator as} \indented{2}{that anticommutes.} \indented{2}{need to check precedence when used as an infix operator} \indented{2}{for more documentation see:} \indented{2}{\url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.\spad{htm}}}


kind: c
name: BoundedLattice
exposed: n
type: ()->Category
abbrev: BLAT
comment:
lattice with top and bottom \indented{2}{for more documentation see:} \indented{2}{\url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.\spad{htm}}}


kind: c
name: BoundedMeetSemilattice
exposed: n
type: ()->Category
abbrev: BMEET
comment:
meet semilattice with top \indented{2}{Implementations in set,{} logic and orders} \indented{2}{for more documentation see:} \indented{2}{\url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.\spad{htm}}}


kind: c
name: CancellationAbelianMonoid
exposed: x
type: ()->Category
abbrev: CABMON
comment:
This is an \spadtype{AbelianMonoid} with the cancellation property,{} \spadignore{i.e.} \spad{ a+b = a+c => b=c }. This is formalised by the partial subtraction operator,{} which satisfies the axioms listed below: \blankline


kind: c
name: Canonical
exposed: n
type: ()->Category
abbrev: ATCANON
comment:
The class of all domains which have canonical representation,{} that is if mathematically equal elements have the same data structures.


kind: c
name: canonicalsClosed
exposed: n
type: ()->Category
abbrev: ATCANCL
comment:
The class of all integral domains such that \spad{unitCanonical(a)*unitCanonical(b) = unitCanonical(a*b)}.


kind: c
name: canonicalUnitNormal
exposed: n
type: ()->Category
abbrev: ATCUNOR
comment:
The class of all integral domains such that we can choose a canonical representative for each class of associate elements,{} that is \spad{associates?(a,{} b)} returns \spad{true} if and only if \spad{unitCanonical(a) = unitCanonical(b)}.


kind: c
name: Coalgebra
exposed: x
type: (R:CommutativeRing,Module(R))->Category
params: (R,MxM)
abbrev: COALG
comment:
A coalgebra A over a ring is an \spad{R}-module with a coassociative comultiplication from A to the tensor product of A with itself and which possesses a counit.


kind: c
name: CoDcpo
exposed: n
type: (SetCategory)->Category
params: (S)
abbrev: CODCPO
comment:
Directed-complete Order,{} partial order that is guaranteed to have a meet of any two elements. For more documentation see: \indented{2}{\url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.\spad{htm}}}


kind: c
name: CoercibleFrom
exposed: n
type: (Type)->Category
params: (S)
abbrev: KOERCEF
comment:
A is coercible to \spad{B} means any element of A can automatically be converted into an element of \spad{B} by the interpreter.


kind: c
name: Collection
exposed: x
type: (Type)->Category
params: (S)
abbrev: CLAGG
comment:
A collection is a homogeneous aggregate which can be built from a list of members. The operation used to build the aggregate is generically named \spadfun{construct}. However,{} each collection provides its own special function with the same name as the data type,{} except with an initial lower case letter,{} \spadignore{e.g.} \spadfun{list} for \spadtype{List},{} \spadfun{flexibleArray} for \spadtype{FlexibleArray},{} and so on.


kind: c
name: CombinatorialOpsCategory
exposed: x
type: ()->Category
abbrev: COMBOPC
comment:
CombinatorialOpsCategory is the category obtaining by adjoining summations and products to the usual combinatorial operations.


kind: c
name: CommutativeRing
exposed: x
type: ()->Category
abbrev: COMRING
comment:
The category of commutative rings with unity,{} \spadignore{i.e.} rings where \spadop{*} is commutative,{} and which have a multiplicative identity. element.


kind: c
name: CommutativeStar
exposed: n
type: ()->Category
abbrev: ATCS
comment:
The class of all commutative semigroups in multiplicative notation. In other words domains \spad{D} with \spad{*: (D,{} D) -> D} which is commutative. Typically applied to rings.


kind: c
name: ConvertibleFrom
exposed: n
type: (Type)->Category
params: (S)
abbrev: KONVERF
comment:
A is convertible to \spad{B} means any element of A can be converted into an element of \spad{B},{} but not automatically by the interpreter.


kind: c
name: Dcpo
exposed: n
type: (SetCategory)->Category
params: (S)
abbrev: DCPO
comment:
Directed-complete partial order,{} partial order that is guaranteed to have a join of any two elements. For more documentation see: \indented{2}{\url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.\spad{htm}}}


kind: c
name: DequeueAggregate
exposed: x
type: (Type)->Category
params: (S)
abbrev: DQAGG
comment:
A dequeue is a doubly ended stack,{} that is,{} a bag where first items inserted are the first items extracted,{} at either the front or the back end of the data structure.


kind: c
name: Dictionary
exposed: x
type: (Type)->Category
params: (S)
abbrev: DIAGG
comment:
A dictionary is an aggregate in which entries can be inserted,{} searched for and removed. Duplicates are thrown away on insertion. This category models the usual notion of dictionary which involves large amounts of data where copying is impractical. Principal operations are thus destructive (non-copying) ones.


kind: c
name: DictionaryOperations
exposed: x
type: (Type)->Category
params: (S)
abbrev: DIOPS
comment:
This category is a collection of operations common to both categories \spadtype{Dictionary} and \spadtype{MultiDictionary}


kind: c
name: DifferentialExtension
exposed: x
type: (Ring)->Category
params: (R)
abbrev: DIFEXT
comment:
Differential extensions of a ring \spad{R}. Given a differentiation on \spad{R},{} extend it to a differentiation on \%.


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


kind: c
name: DifferentialRing
exposed: x
type: ()->Category
abbrev: DIFRING
comment:
An ordinary differential ring,{} that is,{} a ring with an operation \spadfun{differentiate}. \blankline


kind: c
name: DifferentialVariableCategory
exposed: x
type: (OrderedSet)->Category
params: (S)
abbrev: DVARCAT
comment:
\spadtype{DifferentialVariableCategory} constructs the set of derivatives of a given set of (ordinary) differential indeterminates. If \spad{x},{} ...,{} \spad{y} is an ordered set of differential indeterminates,{} and the prime notation is used for differentiation,{} then the set of derivatives (including zero-th order) of the differential indeterminates is \spad{x},{} \spad{x'},{} \spad{x''},{} ...,{} \spad{y},{} \spad{y'},{} \spad{y''},{} ... (Note: in the interpreter,{} the \spad{n}-th derivative of \spad{y} is displayed as \spad{y} with a subscript \spad{n}.) This set is viewed as a set of algebraic indeterminates,{} totally ordered in a way compatible with differentiation and the given order on the differential indeterminates. Such a total order is called a ranking of the differential indeterminates. \blankline A domain in this category is needed to construct a differential polynomial domain. Differential polynomials are ordered by a ranking on the derivatives,{} and by an order (extending the ranking) on on the set of differential monomials. One may thus associate a domain in this category with a ranking of the differential indeterminates,{} just as one associates a domain in the category \spadtype{OrderedAbelianMonoidSup} with an ordering of the set of monomials in a set of algebraic indeterminates. The ranking is specified through the binary relation \spadfun{<}. For example,{} one may define one derivative to be less than another by lexicographically comparing first the \spadfun{order},{} then the given order of the differential indeterminates appearing in the derivatives. This is the default implementation. \blankline The notion of weight generalizes that of degree. A polynomial domain may be made into a graded ring if a weight function is given on the set of indeterminates,{} Very often,{} a grading is the first step in ordering the set of monomials. For differential polynomial domains,{} this constructor provides a function \spadfun{weight},{} which allows the assignment of a non-negative number to each derivative of a differential indeterminate. For example,{} one may define the weight of a derivative to be simply its \spadfun{order} (this is the default assignment). This weight function can then be extended to the set of all differential polynomials,{} providing a graded ring structure.


kind: c
name: DirectProductCategory
exposed: x
type: (NonNegativeInteger,Type)->Category
params: (dim,R)
abbrev: DIRPCAT
comment:
\indented{2}{This category represents a finite cartesian product of a given type.} Many categorical properties are preserved under this construction.


kind: c
name: DivisionRing
exposed: x
type: ()->Category
abbrev: DIVRING
comment:
A division ring (sometimes called a skew field),{} \spadignore{i.e.} a not necessarily commutative ring where all non-zero elements have multiplicative inverses.


kind: c
name: DoublyLinkedAggregate
exposed: x
type: (Type)->Category
params: (S)
abbrev: DLAGG
comment:
A doubly-linked aggregate serves as a model for a doubly-linked list,{} that is,{} a list which has links to both next and previous nodes and thus can be efficiently traversed in both directions.


kind: c
name: Eltable
exposed: x
type: (Type,Type)->Category
params: (D,I)
abbrev: ELTAB
comment:
An eltable over domains \spad{D} and \spad{I} is a structure which can be viewed as a function from \spad{D} to \spad{I}. Examples of eltable structures range from data structures,{} \spadignore{e.g.} those of type \spadtype{List},{} to algebraic structures,{} \spadignore{e.g.} \spadtype{Polynomial}.


kind: c
name: EltableAggregate
exposed: x
type: (Type,Type)->Category
params: (Dom,Im)
abbrev: ELTAGG
comment:
An eltable aggregate is one which can be viewed as a function. For example,{} the list \spad{[1,{} 7,{} 4]} can be applied to 1,{} 2,{} and 3 respectively and will return the integers 1,{} 7,{} and 4; thus this list may be viewed as mapping 1 to 1,{} 2 to 7 and 3 to 4. In general,{} an aggregate can map members of a domain {\em Dom} to an image domain {\em Im}.


kind: c
name: EntireRing
exposed: x
type: ()->Category
abbrev: ENTIRER
comment:
Entire Rings (non-commutative Integral Domains),{} \spadignore{i.e.} a ring not necessarily commutative which has no zero divisors. \blankline


kind: c
name: EuclideanDomain
exposed: x
type: ()->Category
abbrev: EUCDOM
comment:
A constructive euclidean domain,{} \spadignore{i.e.} one can divide producing a quotient and a remainder where the remainder is either zero or is smaller (\spadfun{euclideanSize}) than the divisor. \blankline Conditional attributes: \indented{2}{multiplicativeValuation\tab{25}\spad{Size(a*b)=Size(a)*Size(b)}} \indented{2}{additiveValuation\tab{25}\spad{Size(a*b)=Size(a)+Size(b)}}


kind: c
name: Evalable
exposed: x
type: (SetCategory)->Category
params: (R)
abbrev: EVALAB
comment:
This category provides \spadfun{eval} operations. A domain may belong to this category if it is possible to make


kind: c
name: ExtensibleLinearAggregate
exposed: x
type: (Type)->Category
params: (S)
abbrev: ELAGG
comment:
An extensible aggregate is one which allows insertion and deletion of entries. These aggregates are models of lists which are represented by linked structures so as to make insertion,{} deletion,{} and concatenation efficient. However,{} access to elements of these extensible aggregates is generally slow since access is made from the end. See \spadtype{FlexibleArray} for an exception.


kind: c
name: FacetCategory
exposed: n
type: ()->Category
abbrev: FACTCAT
comment:
This is a category to represent different types of facet,{} such as,{} (1) A single simplex (2) A single cubical simplex (3) The product of two facets \blankline


kind: c
name: Field
exposed: x
type: ()->Category
abbrev: FIELD
comment:
The category of commutative fields,{} \spadignore{i.e.} commutative rings where all non-zero elements have multiplicative inverses. The \spadfun{factor} operation while trivial is useful to have defined. \blankline


kind: c
name: FieldOfPrimeCharacteristic
exposed: x
type: ()->Category
abbrev: FPC
comment:
FieldOfPrimeCharacteristic is the category of fields of prime characteristic,{} \spadignore{e.g.} finite fields,{} algebraic closures of fields of prime characteristic,{} transcendental extensions of of fields of prime characteristic.


kind: c
name: FileCategory
exposed: x
type: (SetCategory,SetCategory)->Category
params: (Name,S)
abbrev: FILECAT
comment:
This category provides an interface to operate on files in the computer\spad{'s} file system. The precise method of naming files is determined by the Name parameter. The type of the contents of the file is determined by \spad{S}.


kind: c
name: Finite
exposed: x
type: ()->Category
abbrev: FINITE
comment:
The category of domains composed of a finite set of elements. We include the functions \spadfun{lookup} and \spadfun{index} to give a bijection between the finite set and an initial segment of positive integers. \blankline


kind: c
name: FiniteAbelianMonoidRing
exposed: x
type: (Join(SemiRng,etc),OrderedAbelianMonoid)->Category
params: (R,E)
abbrev: FAMR
comment:
This category is similar to AbelianMonoidRing,{} except that the sum is assumed to be finite. It is a useful model for polynomials,{} but is somewhat more general.


kind: c
name: FiniteAlgebraicExtensionField
exposed: x
type: (Field)->Category
params: (F)
abbrev: FAXF
comment:
FiniteAlgebraicExtensionField {\em F} is the category of fields which are finite algebraic extensions of the field {\em F}. If {\em F} is finite then any finite algebraic extension of {\em F} is finite,{} too. Let {\em K} be a finite algebraic extension of the finite field {\em F}. The exponentiation of elements of {\em K} defines a \spad{Z}-module structure on the multiplicative group of {\em K}. The additive group of {\em K} becomes a module over the ring of polynomials over {\em F} via the operation \spadfun{linearAssociatedExp}(a: \spad{K},{} \spad{f:} SparseUnivariatePolynomial \spad{F}) which is linear over {\em F},{} \spadignore{i.e.} for elements {\em a} from {\em K},{} {\em c,{} d} from {\em F} and {\em f,{} g} univariate polynomials over {\em F} we have \spadfun{linearAssociatedExp}(a,{} cf+dg) equals {\em c} times \spadfun{linearAssociatedExp}(a,{} \spad{f}) plus {\em d} times \spadfun{linearAssociatedExp}(a,{} \spad{g}). Therefore \spadfun{linearAssociatedExp} is defined completely by its action on monomials from {\em F[X]}: \spadfun{linearAssociatedExp}(a,{} monomial(1,{} \spad{k})\spad{\$}SUP(\spad{F})) is defined to be \spadfun{Frobenius}(a,{} \spad{k}) which is {\em a^(q^k)} where {\em q=size()\$F}. The operations order and discreteLog associated with the multiplicative exponentiation have additive analogues associated to the operation \spadfun{linearAssociatedExp}. These are the functions \spadfun{linearAssociatedOrder} and \spadfun{linearAssociatedLog},{} respectively.


kind: c
name: FiniteDivisorCategory
exposed: x
params: (F,UP,UPUP,R)
abbrev: FDIVCAT
type:
(F:Field,UP:UnivariatePolynomialCategory(F),UPUP:UnivariatePolynomialCategory(Fraction(UP)),FunctionFieldCategory(F,UP,UPUP))->Category

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


kind: c
name: FiniteRankAlgebra
exposed: x
type: (R:CommutativeRing,UnivariatePolynomialCategory(R))->Category
params: (R,UP)
abbrev: FINRALG
comment:
A FiniteRankAlgebra is an algebra over a commutative ring \spad{R} which is a free \spad{R}-module of finite rank.


kind: c
name: FiniteRankNonAssociativeAlgebra
exposed: x
type: (CommutativeRing)->Category
params: (R)
abbrev: FINAALG
comment:
A FiniteRankNonAssociativeAlgebra is a non associative algebra over a commutative ring \spad{R} which is a free \spad{R}-module of finite rank.


kind: c
name: FiniteSetAggregate
exposed: x
type: (SetCategory)->Category
params: (S)
abbrev: FSAGG
comment:
A finite-set aggregate models the notion of a finite set,{} that is,{} a collection of elements characterized by membership,{} but not by order or multiplicity. See \spadtype{Set} for an example.


kind: c
name: FloatingPointSystem
exposed: x
type: ()->Category
abbrev: FPS
comment:
This category is intended as a model for floating point systems. A floating point system is a model for the real numbers. In fact,{} it is an approximation in the sense that not all real numbers are exactly representable by floating point numbers. A floating point system is characterized by the following: \blankline \indented{2}{1: \spadfunFrom{base}{FloatingPointSystem} of the \spadfunFrom{exponent}{FloatingPointSystem}.} \indented{9}{(actual implementations are usually binary or decimal)} \indented{2}{2: \spadfunFrom{precision}{FloatingPointSystem} of the \spadfunFrom{mantissa}{FloatingPointSystem} (arbitrary or fixed)} \indented{2}{3: rounding error for operations} \blankline Because a Float is an approximation to the real numbers,{} even though it is defined to be a join of a Field and OrderedRing,{} some of the attributes do not hold. In particular associative(\spad{+}) does not hold. Algorithms defined over a field need special considerations when the field is a floating point system.


kind: c
name: FortranFunctionCategory
exposed: n
type: ()->Category
abbrev: FORTFN
comment:
\spadtype{FortranFunctionCategory} is the category of arguments to NAG Library routines which return (sets of) function values.


kind: c
name: FortranMatrixCategory
exposed: n
type: ()->Category
abbrev: FMC
comment:
\spadtype{FortranMatrixCategory} provides support for producing Functions and Subroutines when the input to these is a FriCAS object of type \spadtype{Matrix} or in domains involving \spadtype{FortranCode}.


kind: c
name: FortranMatrixFunctionCategory
exposed: n
type: ()->Category
abbrev: FMFUN
comment:
\spadtype{FortranMatrixFunctionCategory} provides support for producing Functions and Subroutines representing matrices of expressions.


kind: c
name: FortranProgramCategory
exposed: n
type: ()->Category
abbrev: FORTCAT
comment:
\spadtype{FortranProgramCategory} provides various models of FORTRAN subprograms. These can be transformed into actual FORTRAN code.


kind: c
name: FortranVectorCategory
exposed: n
type: ()->Category
abbrev: FVC
comment:
\spadtype{FortranVectorCategory} provides support for producing Functions and Subroutines when the input to these is a FriCAS object of type \spadtype{Vector} or in domains involving \spadtype{FortranCode}.


kind: c
name: FortranVectorFunctionCategory
exposed: n
type: ()->Category
abbrev: FVFUN
comment:
\spadtype{FortranVectorFunctionCategory} is the category of arguments to NAG Library routines which return the values of vectors of functions.


kind: c
name: FramedAlgebra
exposed: x
type: (R:CommutativeRing,UnivariatePolynomialCategory(R))->Category
params: (R,UP)
abbrev: FRAMALG
comment:
A \spadtype{FramedAlgebra} is a \spadtype{FiniteRankAlgebra} together with a fixed \spad{R}-module basis.


kind: c
name: FramedNonAssociativeAlgebra
exposed: x
type: (CommutativeRing)->Category
params: (R)
abbrev: FRNAALG
comment:
FramedNonAssociativeAlgebra(\spad{R}) is a \spadtype{FiniteRankNonAssociativeAlgebra} (\spadignore{i.e.} a non associative algebra over \spad{R} which is a free \spad{R}-module of finite rank) over a commutative ring \spad{R} together with a fixed \spad{R}-module basis.


kind: c
name: FreeLieAlgebra
exposed: x
type: (OrderedSet,CommutativeRing)->Category
params: (VarSet,R)
abbrev: FLALG
comment:
The category of free Lie algebras. It is used by domains of non-commutative algebra: \spadtype{LiePolynomial} and \spadtype{XPBWPolynomial}. \newline Author: Michel Petitot (petitot@lifl.\spad{fr})


kind: c
name: FreeModuleCategory
exposed: x
type: (Join(SemiRng,etc),SetCategory)->Category
params: (R,S)
abbrev: FMCAT
comment:
A domain of this category implements formal linear combinations of elements from a domain \spad{Basis} with coefficients in a domain \spad{R}. The domain \spad{Basis} needs only to belong to the category \spadtype{SetCategory} and \spad{R} to the category \spadtype{Ring}. Thus the coefficient ring may be non-commutative. See the \spadtype{XDistributedPolynomial} constructor for examples of domains built with the \spadtype{FreeModuleCategory} category constructor. Author: Michel Petitot (petitot@lifl.\spad{fr}) \blankline Note (Franz Lehner,{} June 2009): \spad{FreeModule} originally was not of FreeModuleCategory. Some functions (like \spad{support},{} \spad{coefficients},{} \spad{monomials},{} ...) from here could be moved to \spad{IndexedDirectProductCategory} but at the moment there is no need for this.


kind: c
name: FullyEvalableOver
exposed: x
type: (SetCategory)->Category
params: (R)
abbrev: FEVALAB
comment:
This category provides a selection of evaluation operations depending on what the argument type \spad{R} provides.


kind: c
name: FullyLinearlyExplicitOver
exposed: x
type: (Ring)->Category
params: (R)
abbrev: FLINEXP
comment:
\spad{S} is \spadtype{FullyLinearlyExplicitOver R} means that \spad{S} is a \spadtype{LinearlyExplicitOver R} and,{} in addition,{} if \spad{R} is a \spadtype{LinearlyExplicitOver Integer},{} then so is \spad{S}


kind: c
name: FullyPatternMatchable
exposed: x
type: (Type)->Category
params: (R)
abbrev: FPATMAB
comment:
A set \spad{S} is PatternMatchable over \spad{R} if \spad{S} can lift the pattern-matching functions of \spad{S} over the integers and float to itself (necessary for matching in towers).


kind: c
name: FullyRetractableTo
exposed: x
type: (Type)->Category
params: (S)
abbrev: FRETRCT
comment:
\indented{2}{A is fully retractable to \spad{B} means that A is retractable to \spad{B},{} and,{}} \indented{2}{in addition,{} if \spad{B} is retractable to the integers or rational} \indented{2}{numbers then so is A.} \indented{2}{In particular,{} what we are asserting is that there are no integers} \indented{2}{(rationals) in A which don\spad{'t} retract into \spad{B}.} Date Created: March 1990


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


kind: c
name: GcdDomain
exposed: x
type: ()->Category
abbrev: GCDDOM
comment:
This category describes domains where \spadfun{\spad{gcd}} can be computed but where there is no guarantee of the existence of \spadfun{factor} operation for factorization into irreducibles. However,{} if such a \spadfun{factor} operation exist,{} factorization will be unique up to order and units.


kind: c
name: Group
exposed: x
type: ()->Category
abbrev: GROUP
comment:
The class of multiplicative groups,{} \spadignore{i.e.} monoids with multiplicative inverses. \blankline


kind: c
name: HomogeneousAggregate
exposed: x
type: (Type)->Category
params: (S)
abbrev: HOAGG
comment:
A homogeneous aggregate is an aggregate of elements all of the same type. In the current system,{} all aggregates are homogeneous. Two attributes characterize classes of aggregates. Aggregates from domains with attribute \spadtype{finiteAggregate} have a finite number of members. Of course,{} such a domain may have an infinite number of elements,{} like,{} for example \spadtype{List}. Those domains with attribute \spadtype{shallowlyMutable} allow an element to be modified or updated without changing its overall value.


kind: c
name: IndexedAggregate
exposed: x
type: (Type,Type)->Category
params: (Index,Entry)
abbrev: IXAGG
comment:
An indexed aggregate is a many-to-one mapping of indices to entries. For example,{} a one-dimensional-array is an indexed aggregate where the index is an integer. Also,{} a table is an indexed aggregate where the indices and entries may have any type.


kind: c
name: IndexedDirectProductCategory
exposed: x
type: (SetCategory,SetCategory)->Category
params: (A,S)
abbrev: IDPC
comment:
This category represents the direct product of some set with respect to an ordered indexing set. The ordered set \spad{S} is considered as the


kind: c
name: IndexedProductCategory
exposed: n
type: (SetCategory,SetCategory)->Category
params: (A,S)
abbrev: IPC
comment:
This category represents the product of some set with respect to an indexing set. The set \spad{S} is considered as the


kind: c
name: IntegralDomain
exposed: x
type: ()->Category
abbrev: INTDOM
comment:
The category of commutative integral domains,{} \spadignore{i.e.} commutative rings with no zero divisors. \blankline


kind: c
name: IntervalCategory
exposed: x
type: (Join(FloatingPointSystem,etc))->Category
params: (R)
abbrev: INTCAT
comment:
\indented{1}{+ Author: Mike Dewar} + Date Created: November 1996 + Basic Functions: + Related Constructors: + Also See: + AMS Classifications: + Keywords: + References: + Description: This category implements of interval arithmetic and + transcendental functions over intervals.


kind: c
name: JetBundleBaseFunctionCategory
exposed: n
type: (JetBundleCategory)->Category
params: (JB)
abbrev: JBBFC
comment:
\spadtype{JetBundleBaseFunctionCategory} defines the category of functions (local sections) of the base space of a jet bundle,{} \spadignore{i.e.} functions depending only on the independent variables. Such a category is needed \spadignore{e.g.} for the representation of solutions.


kind: c
name: JetBundleCategory
exposed: n
type: ()->Category
abbrev: JBC
comment:
\spadtype{JetBundleCategory} provides basic data structures and procedures for jet bundles. Nearly all necessary functions are implemented already here. Only the representation and functions which directly access it must be implemented in a domain. Two notations of derivatives are supported. Default is multi-index notation,{} where the \spad{i}-th entry of the index denotes the number of differentiations taken with respect to \spad{x^i}. In repeated index notation each entry \spad{i} in the index denotes a differentiation with respect to \spad{x^i}. The choice affects,{} however,{} only in- and output. Internally,{} multi-index notation is used throughout.


kind: c
name: JetBundleFunctionCategory
exposed: n
type: (JetBundleCategory)->Category
params: (JB)
abbrev: JBFC
comment:
\spadtype{JetBundleFunctionCategory} defines the category of functions (local sections) over a jet bundle. The formal derivative is defined already here. It uses the Jacobi matrix of the functions. The columns of the matrices are enumerated by jet variables. Thus they are represented as a \spadtype{Record} of the matrix and a list of the jet variables. Several simplification routines are implemented already here.


kind: c
name: JoinSemilattice
exposed: n
type: ()->Category
abbrev: JOINLAT
comment:
join semilattice \indented{2}{Different from exterior Grassmann product operator as} \indented{2}{that anticommutes.} \indented{2}{need to check precedence when used as an infix operator} \indented{2}{for more documentation see:} \indented{2}{\url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.\spad{htm}}}


kind: c
name: KeyedDictionary
exposed: x
type: (Type,Type)->Category
params: (Key,Entry)
abbrev: KDAGG
comment:
A keyed dictionary is a dictionary of key-entry pairs for which there is a unique entry for each key.


kind: c
name: Lattice
exposed: n
type: ()->Category
abbrev: LAT
comment:
lattice \indented{2}{for more documentation see:} \indented{2}{\url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.\spad{htm}}}


kind: c
name: LazyStreamAggregate
exposed: x
type: (Type)->Category
params: (S)
abbrev: LZSTAGG
comment:
LazyStreamAggregate is the category of streams with lazy evaluation. It is understood that the function 'empty?' will cause lazy evaluation if necessary to determine if there are entries. Functions which call 'empty?',{} \spadignore{e.g.} 'first' and 'rest',{} will also cause lazy evaluation if necessary. Elements of LazyStreamAggregate are computed only when strictly needed. Lazy computation means that potential errors are delayed,{} so errors are detected later than in case of normal (eager) evaluation used by other aggregates. In some cases computation that would signal error when using eager evaluation can succeed when using lazy evaluation.


kind: c
name: LeftModule
exposed: x
type: (SemiRng)->Category
params: (R)
abbrev: LMODULE
comment:
The category of left modules over an \spad{rng} (ring not necessarily with unit). This is an abelian group which supports left multiplication by elements of the \spad{rng}. \blankline


kind: c
name: LeftOreRing
exposed: n
type: ()->Category
abbrev: LORER
comment:
This is category of left ore rings,{} that is noncommutaive rings without zero divisors where we can compute least left common multiple


kind: c
name: LieAlgebra
exposed: x
type: (CommutativeRing)->Category
params: (R)
abbrev: LIECAT
comment:
The category of Lie Algebras. It is used by the following domains of non-commutative algebra: \spadtype{LiePolynomial} and \spadtype{XPBWPolynomial}. \newline Author : Michel Petitot (petitot@lifl.\spad{fr}).


kind: c
name: LinearAggregate
exposed: x
type: (Type)->Category
params: (S)
abbrev: LNAGG
comment:
A linear aggregate is an aggregate whose elements are indexed by integers. Examples of linear aggregates are strings,{} lists,{} and arrays. Most of the exported operations for linear aggregates are non-destructive but are not always efficient for a particular aggregate. For example,{} \spadfun{concat} of two lists needs only to copy its first argument,{} whereas \spadfun{concat} of two arrays needs to copy both arguments. Most of the operations exported here apply to infinite objects (\spadignore{e.g.} streams) as well to finite ones. If the aggregate is a finite aggregate then it has several additional exports such as \spadfun{reverse},{} \spadfun{sort},{} and so on.


kind: c
name: LinearOrdinaryDifferentialOperatorCategory
exposed: x
type: (Ring)->Category
params: (A)
abbrev: LODOCAT
comment:
\spad{LinearOrdinaryDifferentialOperatorCategory} is the category of differential operators with coefficients in a ring A with a given derivation. Multiplication of operators corresponds to functional composition: \indented{4}{\spad{(L1 * L2).(f) = L1 L2 f}}


kind: c
name: ListAggregate
exposed: x
type: (Type)->Category
params: (S)
abbrev: LSAGG
comment:
A list aggregate is a model for a linked list data structure. A linked list is a versatile data structure. Insertion and deletion are efficient and searching is a linear operation.


kind: c
name: MagmaWithUnit
exposed: x
type: ()->Category
abbrev: MAGMAWU
comment:
\indented{1}{MagmaWithUnit is the class of multiplicative monads with unit,{}} \indented{1}{\spadignore{i.e.} sets with a binary operation and a unit element.} Axioms \indented{3}{leftIdentity(*:(\%,{}\%)\spad{->}\%,{}1)\space{3}\tab{30} 1*x=x} \indented{3}{rightIdentity(*:(\%,{}\%)\spad{->}\%,{}1)\space{2}\tab{30} x*1=x} Common Additional Axioms \indented{3}{unitsKnown---if recip says failed,{} that PROVES input wasn\spad{'t} a unit}


kind: c
name: MatrixCategory
exposed: x
type: (R:AbelianMonoid,FiniteLinearAggregate(R),FiniteLinearAggregate(R))->Category
params: (R,Row,Col)
abbrev: MATCAT
comment:
\spadtype{MatrixCategory} is a general matrix category which allows different representations and indexing schemes. Rows and columns may be extracted with rows returned as objects of type Row and columns returned as objects of type Col. A domain belonging to this category will be shallowly mutable. The index of the 'first' row may be obtained by calling the function \spadfun{minRowIndex}. The index of the 'first' column may be obtained by calling the function \spadfun{minColIndex}. The index of the first element of a Row is the same as the index of the first column in a matrix and vice versa.


kind: c
name: MaybeSkewPolynomialCategory
exposed: n
type: (Join(SemiRng,etc),OrderedAbelianMonoidSup,OrderedSet)->Category
params: (R,E,VarSet)
abbrev: GPOLCAT
comment:
The category for general multi-variate possibly skew polynomials over a ring \spad{R},{} in variables from VarSet,{} with exponents from the \spadtype{OrderedAbelianMonoidSup}.


kind: c
name: MeetSemilattice
exposed: n
type: ()->Category
abbrev: MEETLAT
comment:
meet semilattice \indented{2}{Implementations in set,{} logic and orders} \indented{2}{for more documentation see:} \indented{2}{\url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.\spad{htm}}}


kind: c
name: ModularAlgebraicGcdOperations
exposed: n
type: (Type,Type,Type)->Category
params: (MP,MPT,MD)
abbrev: MAGCDOC
comment:
This category specifies operations needed by \indented{1}{ModularAlgebraicGcd package.\space{2}Since we have multiple} \indented{1}{implementations we specify interface here and put} \indented{1}{implementations in separate packages.\space{2}Most operations} \indented{1}{are done using special purpose abstract representation.} \indented{1}{Appropriate types are passed as parameters: \spad{MPT} is type} \indented{1}{of modular polynomials in one variable with coefficients} \indented{1}{in some algebraic extension.\space{2}\spad{MD} is type of modulus.} \indented{1}{Final results are converted to packed representation,{}} \indented{1}{with coefficients (from prime field) stored in one} \indented{1}{array and exponents (in main variable and in auxiliary} \indented{1}{variables representing generators of algebrac extension)} \indented{1}{stored in parallel array.}


kind: c
name: ModularEvaluationCategory
exposed: n
type: (Type,Type)->Category
params: (PT,MP)
abbrev: MEVCAT
comment:
ModularEvaluationCategory(\spad{PT},{} \spad{MP}) defines interface \indented{1}{to evaluation functions for \spad{ModularAlgebraicGcd2}.}


kind: c
name: ModularFactorizationOperations
exposed: n
type: (Type,Type,Type,Type)->Category
params: (PA,MMT,MD,PMD)
abbrev: MFOPC
comment:
This category specifies operations needed by \indented{1}{univariate factorization over finite fields}


kind: c
name: MonogenicAlgebra
exposed: x
type: (R:CommutativeRing,UnivariatePolynomialCategory(R))->Category
params: (R,UP)
abbrev: MONOGEN
comment:
A \spadtype{MonogenicAlgebra} is an algebra of finite rank which can be generated by a single element.


kind: c
name: Monoid
exposed: x
type: ()->Category
abbrev: MONOID
comment:
The class of multiplicative monoids,{} \spadignore{i.e.} semigroups with a multiplicative identity element. \blankline


kind: c
name: MonoidRingCategory
exposed: x
type: (Ring,Monoid)->Category
params: (R,M)
abbrev: MRCAT
comment:
\spadtype{MonoidRingCategory}(\spad{R},{} \spad{M}) defines the algebra of all maps from the monoid \spad{M} to the commutative ring \spad{R} with finite support.


kind: c
name: MultiDictionary
exposed: x
type: (SetCategory)->Category
params: (S)
abbrev: MDAGG
comment:
A multi-dictionary is a dictionary which may contain duplicates. As for any dictionary,{} its size is assumed large so that copying (non-destructive) operations are generally to be avoided.


kind: c
name: multiplicativeValuation
exposed: n
type: ()->Category
abbrev: ATMULVA
comment:
The class of all euclidean domains such that \spad{euclideanSize(a*b)=euclideanSize(a)*euclideanSize(b)}.


kind: c
name: MultivariateTaylorSeriesCategory
exposed: x
type: (Ring,OrderedSet)->Category
params: (Coef,Var)
abbrev: MTSCAT
comment:
\spadtype{MultivariateTaylorSeriesCategory} is the most general multivariate Taylor series category.


kind: c
name: NonAssociativeAlgebra
exposed: x
type: (CommutativeRing)->Category
params: (R)
abbrev: NAALG
comment:
NonAssociativeAlgebra is the category of non associative algebras (modules which are themselves non associative rngs). Axioms \indented{3}{\spad{r*}(a*b) = (r*a)\spad{*b} = a*(\spad{r*b})}


kind: c
name: NonAssociativeRing
exposed: x
type: ()->Category
abbrev: NARING
comment:
A NonAssociativeRing is a non associative \spad{rng} which has a unit,{} the multiplication is not necessarily commutative or associative.


kind: c
name: NonAssociativeRng
exposed: x
type: ()->Category
abbrev: NARNG
comment:
NonAssociativeRng is a basic ring-type structure,{} not necessarily commutative or associative,{} and not necessarily with unit. Axioms \indented{2}{\spad{x*}(\spad{y+z}) = x*y + \spad{x*z}} \indented{2}{(x+y)\spad{*z} = \spad{x*z} + \spad{y*z}} Common Additional Axioms \indented{2}{noZeroDivisors\space{2}ab = 0 \spad{=>} \spad{a=0} or \spad{b=0}}


kind: c
name: NonAssociativeSemiRing
exposed: n
type: ()->Category
abbrev: NASRING
comment:
The category of semirings,{} not necessarily associative,{} not necessarily commutative,{} with 0 and 1.


kind: c
name: NonAssociativeSemiRng
exposed: n
type: ()->Category
abbrev: NASRNG
comment:
The category of semirings,{} not necessarily associative,{} not necessarily commutative,{} and not necessarily with a 1.


kind: c
name: NormalizedTriangularSetCategory
exposed: x
type: (R:GcdDomain,E:OrderedAbelianMonoidSup,V:OrderedSet,RecursivePolynomialCategory(R,E,V))->Category
params: (R,E,V,P)
abbrev: NTSCAT
comment:
The category of normalized triangular sets. A triangular set \spad{ts} is said normalized if for every algebraic variable \spad{v} of \spad{ts} the polynomial \spad{select(ts,{} v)} is normalized \spad{w}.\spad{r}.\spad{t}. every polynomial in \spad{collectUnder(ts,{} v)}. A polynomial \spad{p} is said normalized \spad{w}.\spad{r}.\spad{t}. a non-constant polynomial \spad{q} if \spad{p} is constant or \spad{degree(p,{} mdeg(q)) = 0} and \spad{init(p)} is normalized \spad{w}.\spad{r}.\spad{t}. \spad{q}. One of the important features of normalized triangular sets is that they are regular sets.


kind: c
name: noZeroDivisors
exposed: n
type: ()->Category
abbrev: ATNZDIV
comment:
The class of all semirings such that \spad{x * y \~~= 0} implies both \spad{x} and \spad{y} are non-zero


kind: c
name: OctonionCategory
exposed: x
type: (CommutativeRing)->Category
params: (R)
abbrev: OC
comment:
OctonionCategory gives the categorial frame for the octonions,{} and eight-dimensional non-associative algebra,{} doubling the quaternions in the same way as doubling the Complex numbers to get the quaternions.


kind: c
name: OneDimensionalArrayAggregate
exposed: x
type: (Type)->Category
params: (S)
abbrev: A1AGG
comment:
One-dimensional-array aggregates serves as models for one-dimensional arrays. Categorically,{} these aggregates are finite linear aggregates with the \spadtype{shallowlyMutable} property,{} that is,{} any component of the array may be changed without affecting the identity of the overall array. Array data structures are typically represented by a fixed area in storage and therefore cannot efficiently grow or shrink on demand as can list structures (see however \spadtype{FlexibleArray} for a data structure which is a cross between a list and an array). Iteration over,{} and access to,{} elements of arrays is extremely fast (and often can be optimized to open-code). Insertion and deletion however is generally slow since an entirely new data structure must be created for the result.


kind: c
name: OrderedAbelianMonoidSup
exposed: x
type: ()->Category
abbrev: OAMONS
comment:
This domain is an OrderedAbelianMonoid with a \spadfun{sup} operation added. The purpose of the \spadfun{sup} operator in this domain is to act as a supremum with respect to the partial order imposed by \spadop{-},{} rather than with respect to the total \spad{>} order (since that is max). \blankline


kind: c
name: OrderedAbelianSemiGroup
exposed: x
type: ()->Category
abbrev: OASGP
comment:
Ordered sets which are also abelian semigroups,{} such that the addition preserves the ordering. \indented{2}{\spad{ x < y => x+z < y+z}}


kind: c
name: OrderedCancellationAbelianMonoid
exposed: x
type: ()->Category
abbrev: OCAMON
comment:
Ordered sets which are also abelian cancellation monoids,{} such that the addition preserves the ordering.


kind: c
name: OrderedIntegralDomain
exposed: x
type: ()->Category
abbrev: OINTDOM
comment:
The category of ordered commutative integral domains,{} where ordering and the arithmetic operations are compatible.


kind: c
name: OrderedMultisetAggregate
exposed: x
type: (OrderedSet)->Category
params: (S)
abbrev: OMSAGG
comment:
An ordered-multiset aggregate is a multiset built over an ordered set \spad{S} so that the relative sizes of its entries can be assessed. These aggregates serve as models for priority queues.


kind: c
name: OrderedRing
exposed: x
type: ()->Category
abbrev: ORDRING
comment:
Ordered sets which are also rings,{} that is,{} domains where the ring operations are compatible with the ordering. \blankline


kind: c
name: OrderedSet
exposed: x
type: ()->Category
abbrev: ORDSET
comment:
The class of totally ordered sets,{} that is,{} sets such that for each pair of elements \spad{(a,{} b)} exactly one of the following relations holds \spad{a<b or a=b or b<a} and the relation is transitive,{} \spadignore{i.e.} \spad{a<b and b<c => a<c}. This order should be the natural order on given structure.


kind: c
name: PartialOrder
exposed: x
type: ()->Category
abbrev: PORDER
comment:
The class of partially ordered sets,{} that is sets equipped with transitive and reflexive relation \spad{<=}.


kind: c
name: PartialTranscendentalFunctions
exposed: x
type: (Type)->Category
params: (K)
abbrev: PTRANFN
comment:
This is the description of any package which provides partial functions on a domain belonging to TranscendentalFunctionCategory.


kind: c
name: Patternable
exposed: x
type: (Type)->Category
params: (R)
abbrev: PATAB
comment:
An object \spad{S} is Patternable over an object \spad{R} if \spad{S} can lift the conversions from \spad{R} into \spadtype{Pattern(Integer)} and \spadtype{Pattern(Float)} to itself.


kind: c
name: PatternMatchable
exposed: x
type: (SetCategory)->Category
params: (S)
abbrev: PATMAB
comment:
A set \spad{R} is PatternMatchable over \spad{S} if elements of \spad{R} can be matched to patterns over \spad{S}.


kind: c
name: PermutationCategory
exposed: x
type: (SetCategory)->Category
params: (S)
abbrev: PERMCAT
comment:
PermutationCategory provides a categorical environment \indented{1}{for subgroups of bijections of a set (\spadignore{i.e.} permutations)}


kind: c
name: PlottablePlaneCurveCategory
exposed: x
type: ()->Category
abbrev: PPCURVE
comment:
PlottablePlaneCurveCategory is the category of curves in the plane which may be plotted via the graphics facilities. Functions are provided for obtaining lists of lists of points,{} representing the branches of the curve,{} and for determining the ranges of the \spad{x}-coordinates and \spad{y}-coordinates of the points on the curve.


kind: c
name: PlottableSpaceCurveCategory
exposed: x
type: ()->Category
abbrev: PSCURVE
comment:
PlottableSpaceCurveCategory is the category of curves in 3-space which may be plotted via the graphics facilities. Functions are provided for obtaining lists of lists of points,{} representing the branches of the curve,{} and for determining the ranges of the \spad{x-},{} \spad{y-},{} and \spad{z}-coordinates of the points on the curve.


kind: c
name: PointCategory
exposed: x
type: (Ring)->Category
params: (R)
abbrev: PTCAT
comment:
PointCategory is the category of points in space which may be plotted via the graphics facilities. Functions are provided for defining points and handling elements of points.


kind: c
name: PolynomialCategory
exposed: x
type: (Join(SemiRng,etc),OrderedAbelianMonoidSup,OrderedSet)->Category
params: (R,E,VarSet)
abbrev: POLYCAT
comment:
The category for general multi-variate polynomials over a ring \spad{R},{} in variables from VarSet,{} with exponents from the \spadtype{OrderedAbelianMonoidSup}. Here variables commute with the coefficients.


kind: c
name: PolynomialFactorizationExplicit
exposed: x
type: ()->Category
abbrev: PFECAT
comment:
This is the category of domains that know enough about themselves in order to factor univariate polynomials over their fraction field.


kind: c
name: PolynomialSetCategory
exposed: x
params: (R,E,VarSet,P)
abbrev: PSETCAT
type:
(R:Ring,E:OrderedAbelianMonoidSup,VarSet:OrderedSet,RecursivePolynomialCategory(R,E,VarSet))->Category

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


kind: c
name: Poset
exposed: n
type: (SetCategory)->Category
params: (S)
abbrev: POSET
comment:
holds a complete set together with a structure to codify \indented{2}{the partial order.} \indented{2}{for more documentation see:} \indented{2}{\url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.\spad{htm}}}


kind: c
name: PowerSeriesCategory
exposed: x
type: (Ring,OrderedAbelianMonoid,OrderedSet)->Category
params: (Coef,Expon,Var)
abbrev: PSCAT
comment:
\spadtype{PowerSeriesCategory} is the most general power series category with exponents in an ordered abelian monoid.


kind: c
name: Preorder
exposed: n
type: (SetCategory)->Category
params: (S)
abbrev: PREORD
comment:
implies operation with reflexivity and transitivity \indented{2}{for more documentation see:} \indented{2}{\url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.\spad{htm}}}


kind: c
name: PrincipalIdealDomain
exposed: x
type: ()->Category
abbrev: PID
comment:
The category of constructive principal ideal domains,{} \spadignore{i.e.} where a single generator can be constructively found for any ideal given by a finite set of generators. Note that this constructive definition only implies that finitely generated ideals are principal. It is not clear what we would mean by an infinitely generated ideal.


kind: c
name: PriorityQueueAggregate
exposed: x
type: (OrderedSet)->Category
params: (S)
abbrev: PRQAGG
comment:
A priority queue is a bag of items from an ordered set where the item extracted is always the maximum element.


kind: c
name: QuaternionCategory
exposed: x
type: (CommutativeRing)->Category
params: (R)
abbrev: QUATCAT
comment:
\spadtype{QuaternionCategory} describes the category of quaternions and implements functions that are not representation specific.


kind: c
name: RealNumberSystem
exposed: x
type: ()->Category
abbrev: RNS
comment:
The real number system category is intended as a model for the real numbers. The real numbers form an ordered normed field. Note that we have purposely not included \spadtype{DifferentialRing} or the elementary functions (see \spadtype{TranscendentalFunctionCategory}) in the definition.


kind: c
name: RealRootCharacterizationCategory
exposed: x
type: (TheField:Join(OrderedRing,etc),UnivariatePolynomialCategory(TheField))->Category
params: (TheField,ThePols)
abbrev: RRCC
comment:
\spadtype{RealRootCharacterizationCategory} provides common access functions for all real root codings.


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

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


kind: c
name: RecursiveAggregate
exposed: x
type: (Type)->Category
params: (S)
abbrev: RCAGG
comment:
A recursive aggregate over a type \spad{S} is a model for a a directed graph containing values of type \spad{S}. Recursively,{} a recursive aggregate is either empty or a {\em node} consisting of a \spadfun{value} from \spad{S} and 0 or more \spadfun{children} which are also nodes. A node with no children is called a \spadfun{leaf} node. A recursive aggregate may be cyclic for which some operations as noted may go into an infinite loop.


kind: c
name: RecursivePolynomialCategory
exposed: x
type: (Ring,OrderedAbelianMonoidSup,OrderedSet)->Category
params: (R,E,V)
abbrev: RPOLCAT
comment:
A category for general multi-variate polynomials with coefficients in a ring,{} variables in an ordered set,{} and exponents from an ordered abelian monoid,{} with a \spadfun{sup} operation. When not constant,{} such a polynomial is viewed as a univariate polynomial in its main variable \spad{w}. \spad{r}. \spad{t}. to the total ordering on the elements in the ordered set,{} so that some operations usually defined for univariate polynomials make sense here.


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


kind: c
name: RetractableFrom
exposed: n
type: (Type)->Category
params: (S)
abbrev: RETFROM
comment:
\spad{B} is retractable from A means that some elements in A can be converted into elements of \spad{B} and any element of \spad{B} can be converted into an element of A.


kind: c
name: RetractableTo
exposed: x
type: (Type)->Category
params: (S)
abbrev: RETRACT
comment:
A is retractable to \spad{B} means that some elements of A can be converted into elements of \spad{B} and any element of \spad{B} can be converted into an element of A.


kind: c
name: RightModule
exposed: x
type: (SemiRng)->Category
params: (R)
abbrev: RMODULE
comment:
The category of right modules over an \spad{rng} (ring not necessarily with unit). This is an abelian group which supports right multiplation by elements of the \spad{rng}. \blankline


kind: c
name: Rng
exposed: x
type: ()->Category
abbrev: RNG
comment:
The category of associative rings,{} not necessarily commutative,{} and not necessarily with a 1. This is a combination of an abelian group and a semigroup,{} with multiplication distributing over addition. \blankline


kind: c
name: SemiGroup
exposed: x
type: ()->Category
abbrev: SGROUP
comment:
the class of all multiplicative semigroups,{} \spadignore{i.e.} a set with an associative operation \spadop{*}. \blankline


kind: c
name: SemiRng
exposed: n
type: ()->Category
abbrev: SRNG
comment:
The category of associative semirings,{} not necessarily commutative,{} and not necessarily with a 1.


kind: c
name: SetAggregate
exposed: x
type: (SetCategory)->Category
params: (S)
abbrev: SETAGG
comment:
A set category lists a collection of set-theoretic operations useful for both finite sets and multisets. Note however that finite sets are distinct from multisets. Although the operations defined for set categories are common to both,{} the relationship between the two cannot be described by inclusion or inheritance.


kind: c
name: SetCategory
exposed: x
type: ()->Category
abbrev: SETCAT
comment:
\spadtype{SetCategory} is the basic category for describing a collection of elements with \spadop{=} (equality) and \spadfun{coerce} to output form. \blankline Conditional Attributes: \indented{3}{canonical\tab{15}data structure equality is the same as \spadop{=}}


kind: c
name: SolvableSkewPolynomialCategory
exposed: n
type: (Ring,OrderedAbelianMonoidSup)->Category
params: (R,Expon)
abbrev: SSKPOLC
comment:
This is the category of polynomials in noncommutative variables over noncommutative rings. We do not assume that variables and elements of the base ring commute. We assume that the polynomial ring is of solvable type,{} so noncommutative version of Buchberger algorithm works.


kind: c
name: SPointCategory
exposed: n
type: ()->Category
abbrev: SPTCAT
comment:
PointCategory is the category of points and vectors in space. Points may be used to represent shapes in a scenegraph such as: the vertices of a cube or points along a line. Shapes such as these may be defined explicitly or may be plotted. We implement SetCategory to allow us to curry transforms from one point to another.


kind: c
name: SquareFreeNormalizedTriangularSetCategory
exposed: x
type: (R:GcdDomain,E:OrderedAbelianMonoidSup,V:OrderedSet,RecursivePolynomialCategory(R,E,V))->Category
params: (R,E,V,P)
abbrev: SNTSCAT
comment:
The category of square-free and normalized triangular sets. Thus,{} up to the primitivity axiom of [1],{} these sets are Lazard triangular sets.\newline


kind: c
name: SquareFreeRegularTriangularSetCategory
exposed: x
type: (R:GcdDomain,E:OrderedAbelianMonoidSup,V:OrderedSet,RecursivePolynomialCategory(R,E,V))->Category
params: (R,E,V,P)
abbrev: SFRTCAT
comment:
The category of square-free regular triangular sets. A regular triangular set \spad{ts} is square-free if the \spad{gcd} of any polynomial \spad{p} in \spad{ts} and \spad{differentiate(p,{} mvar(p))} \spad{w}.\spad{r}.\spad{t}. \spadopFrom{collectUnder}{TriangularSetCategory}(\spad{ts},{} \spadopFrom{mvar}{RecursivePolynomialCategory}(\spad{p})) has degree zero \spad{w}.\spad{r}.\spad{t}. \spad{mvar(p)}. Thus any square-free regular set defines a tower of square-free simple extensions.\newline


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

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


kind: c
name: StepThrough
exposed: x
type: ()->Category
abbrev: STEP
comment:
A class of objects which can be 'stepped through'. Repeated applications of \spadfun{nextItem} is guaranteed never to return duplicate items and only return failed after exhausting all elements of the domain. This assumes that the sequence starts with \spad{init()}. For infinite domains,{} repeated application of \spadfun{nextItem} is not required to reach all possible domain elements starting from any initial element. \blankline Conditional attributes: \indented{2}{infinite\tab{15}repeated \spad{nextItem}\spad{'s} are never failed.}


kind: c
name: StreamAggregate
exposed: x
type: (Type)->Category
params: (S)
abbrev: STAGG
comment:
A stream aggregate is a linear aggregate which possibly has an infinite number of elements. A basic domain constructor which builds stream aggregates is \spadtype{Stream}. From streams,{} a number of infinite structures such as power series can be built.


kind: c
name: TableAggregate
exposed: x
type: (Type,Type)->Category
params: (Key,Entry)
abbrev: TBAGG
comment:
A table aggregate is a model of a table,{} \spadignore{i.e.} a discrete many-to-one mapping from keys to entries.


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


kind: c
name: ThreeSpaceCategory
exposed: x
type: (Ring)->Category
params: (R)
abbrev: SPACEC
comment:
The category ThreeSpaceCategory is used for creating three dimensional objects using functions for defining points,{} curves,{} polygons,{} constructs and the subspaces containing them.


kind: c
name: TriangularSetCategory
exposed: x
params: (R,E,V,P)
abbrev: TSETCAT
type:
(R:IntegralDomain,E:OrderedAbelianMonoidSup,V:OrderedSet,RecursivePolynomialCategory(R,E,V))->Category

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


kind: c
name: TwoDimensionalArrayCategory
exposed: x
type: (R:Type,IndexedAggregate(Integer,R),IndexedAggregate(Integer,R))->Category
params: (R,Row,Col)
abbrev: ARR2CAT
comment:
\indented{1}{TwoDimensionalArrayCategory is a general array category which} allows different representations and indexing schemes. Rows and columns may be extracted with rows returned as objects of type Row and columns returned as objects of type Col. The index of the 'first' row may be obtained by calling the function 'minRowIndex'. The index of the 'first' column may be obtained by calling the function 'minColIndex'. The index of the first element of a 'Row' is the same as the index of the first column in an array and vice versa.


kind: c
name: UnaryRecursiveAggregate
exposed: x
type: (Type)->Category
params: (S)
abbrev: URAGG
comment:
A unary-recursive aggregate is an aggregate where nodes may have either 0 or 1 children. This aggregate models,{} though not precisely,{} a linked list possibly with a single cycle. A node with one children models a non-empty list,{} with the \spadfun{value} of the list designating the head,{} or \spadfun{first},{} of the list,{} and the child designating the tail,{} or \spadfun{rest},{} of the list. Since these aggregates are recursive aggregates,{} they may be cyclic.


kind: c
name: UniqueFactorizationDomain
exposed: x
type: ()->Category
abbrev: UFD
comment:
A constructive unique factorization domain,{} \spadignore{i.e.} where we can constructively factor members into a product of a finite number of irreducible elements.


kind: c
name: unitsKnown
exposed: n
type: ()->Category
abbrev: ATUNIKN
comment:
The class of all monoids (multiplicative semigroups with a 1) such that the operation \spadfun{recip} can only return failed if its argument is not a unit.


kind: c
name: UnivariateLaurentSeriesConstructorCategory
exposed: x
type: (Coef:Ring,UnivariateTaylorSeriesCategory(Coef))->Category
params: (Coef,UTS)
abbrev: ULSCCAT
comment:
This is a category of univariate Laurent series constructed from univariate Taylor series. A Laurent series is represented by a pair \spad{[n,{} f(x)]},{} where \spad{n} is an arbitrary integer and \spad{f(x)} is a Taylor series. This pair represents the Laurent series \spad{x^n * f(x)}.


kind: c
name: UnivariatePolynomialCategory
exposed: x
type: (Join(SemiRng,etc))->Category
params: (R)
abbrev: UPOLYC
comment:
The category of univariate polynomials over a ring \spad{R}. No particular model is assumed - implementations can be either sparse or dense.


kind: c
name: UnivariatePowerSeriesCategory
exposed: x
type: (Ring,OrderedAbelianMonoid)->Category
params: (Coef,Expon)
abbrev: UPSCAT
comment:
\spadtype{UnivariatePowerSeriesCategory} is the most general univariate power series category with exponents in an ordered abelian monoid. Note: this category exports a substitution function if it is possible to multiply exponents. Note: this category exports a derivative operation if it is possible to multiply coefficients by exponents.


kind: c
name: UnivariatePuiseuxSeriesConstructorCategory
exposed: x
type: (Coef:Ring,UnivariateLaurentSeriesCategory(Coef))->Category
params: (Coef,ULS)
abbrev: UPXSCCA
comment:
This is a category of univariate Puiseux series constructed from univariate Laurent series. A Puiseux series is represented by a pair \spad{[r,{} f(x)]},{} where \spad{r} is a positive rational number and \spad{f(x)} is a Laurent series. This pair represents the Puiseux series \spad{f(x^r)}.


kind: c
name: UnivariateSkewPolynomialCategory
exposed: x
type: (Ring)->Category
params: (R)
abbrev: OREPCAT
comment:
This is the category of univariate skew polynomials over an Ore coefficient ring. The multiplication is given by \spad{x a = \sigma(a) x + \delta a}. This category is an evolution of the types \indented{2}{MonogenicLinearOperator,{} OppositeMonogenicLinearOperator,{} and} \indented{2}{NonCommutativeOperatorDivision} developed by Jean Della Dora and Stephen \spad{M}. Watt.


kind: c
name: VarCat
exposed: n
type: ()->Category
abbrev: VARCAT
comment:
VarCat represents a variable in Lambda and Ski domains. Since we are working in terms of functions then a variable will be a function (possibly a constant function) a variable has a name represented by a String. If the Lambda or Ski calculus is typed then the variable will also have a type.


kind: c
name: VectorCategory
exposed: x
type: (Type)->Category
params: (R)
abbrev: VECTCAT
comment:
\spadtype{VectorCategory} represents the type of vector like objects,{} \spadignore{i.e.} finite sequences indexed by some finite segment of the integers. The operations available on vectors depend on the structure of the underlying components. Many operations from the component domain are defined for vectors componentwise. It can by assumed that extraction or updating components can be done in constant time.


kind: c
name: XAlgebra
exposed: x
type: (Ring)->Category
params: (R)
abbrev: XALG
comment:
This is the category of algebras over non-commutative rings. It is used by constructors of non-commutative algebras such as: \indented{4}{\spadtype{XPolynomialRing}.} \indented{4}{\spadtype{XFreeAlgebra}} Author: Michel Petitot (petitot@lifl.\spad{fr})


kind: c
name: XFreeAlgebra
exposed: x
type: (OrderedSet,Ring)->Category
params: (vl,R)
abbrev: XFALG
comment:
This category specifies operations for polynomials and formal series with non-commutative variables.


kind: c
name: XPolynomialsCat
exposed: x
type: (OrderedSet,Ring)->Category
params: (vl,R)
abbrev: XPOLYC
comment:
The Category of polynomial rings with non-commutative variables. The coefficient ring may be non-commutative too. However coefficients commute with variables.


kind: d
name: AlgebraGivenByStructuralConstants
exposed: x
params: (R,n,ls,gamma)
abbrev: ALGSC
type:
(R:CommutativeRing,n:PositiveInteger,ls:List(Symbol),Vector(Matrix(R)))->Join(FramedNonAssociativeAlgebra(R),etc)

comment:
AlgebraGivenByStructuralConstants implements finite rank algebras over a commutative ring,{} given by the structural constants \spad{gamma} with respect to a fixed basis \spad{[a1,{} ..,{} an]},{} where \spad{gamma} is an \spad{n}-vector of \spad{n} by \spad{n} matrices \spad{[(gammaijk) for k in 1..rank()]} defined by \spad{\spad{ai} * aj = gammaij1 * a1 + ... + gammaijn * an}. The symbols for the fixed basis have to be given as a list of symbols.


kind: d
name: AlgebraicFunctionField
exposed: n
params: (F,UP,UPUP,modulus)
abbrev: ALGFF
comment: Function field defined by \spad{f}(\spad{x},{} \spad{y}) = 0.
type:
(F:Field,UP:UnivariatePolynomialCategory(F),UPUP:UnivariatePolynomialCategory(Fraction(UP)),UPUP)->Join(FunctionFieldCategory(F,UP,UPUP),etc)


kind: d
name: Any
exposed: x
type: ()->Join(SetCategory,etc)
abbrev: ANY
comment:
\spadtype{Any} implements a type that packages up objects and their types in objects of \spadtype{Any}. Roughly speaking that means that if \spad{s : S} then when converted to \spadtype{Any},{} the new object will include both the original object and its type. This is a way of converting arbitrary objects into a single type without losing any of the original information. Any object can be converted to one of \spadtype{Any}.


kind: d
name: AssociatedJordanAlgebra
exposed: x
type: (R:CommutativeRing,A:NonAssociativeAlgebra(R))->Join(NonAssociativeAlgebra(R),etc)
params: (R,A)
abbrev: JORDAN
comment:
\indented{1}{AssociatedJordanAlgebra takes an algebra \spad{A} and uses \spadfun{*\$A}} \indented{1}{to define the new multiplications \spad{a*b := (a *\$A b + b *\$A a)/2}} \indented{1}{(anticommutator).} \indented{1}{The usual notation \spad{{a,{} b}_+} cannot be used due to} \indented{1}{restrictions in the current language.} \indented{1}{This domain only gives a Jordan algebra if the} \indented{1}{Jordan-identity \spad{(a*b)*c + (b*c)*a + (c*a)*b = 0} holds} \indented{1}{for all \spad{a},{} \spad{b},{} \spad{c} in \spad{A}.} \indented{1}{This relation can be checked by} \indented{1}{\spadfun{jordanAdmissible?()\$A}.} \blankline If the underlying algebra is of type \spadtype{FramedNonAssociativeAlgebra(R)} (\spadignore{i.e.} a non associative algebra over \spad{R} which is a free \spad{R}-module of finite rank,{} together with a fixed \spad{R}-module basis),{} then the same is \spad{true} for the associated Jordan algebra. Moreover,{} if the underlying algebra is of type \spadtype{FiniteRankNonAssociativeAlgebra(R)} (\spadignore{i.e.} a non associative algebra over \spad{R} which is a free \spad{R}-module of finite rank),{} then the same \spad{true} for the associated Jordan algebra.


kind: d
name: AssociatedLieAlgebra
exposed: x
type: (R:CommutativeRing,A:NonAssociativeAlgebra(R))->Join(NonAssociativeAlgebra(R),etc)
params: (R,A)
abbrev: LIE
comment:
AssociatedLieAlgebra takes an algebra \spad{A} and uses \spadfun{*\$A} to define the Lie bracket \spad{a*b := (a *\$A b - b *\$A a)} (commutator). Note that the notation \spad{[a,{} b]} cannot be used due to restrictions of the current compiler. This domain only gives a Lie algebra if the Jacobi-identity \spad{(a*b)*c + (b*c)*a + (c*a)*b = 0} holds for all \spad{a},{} \spad{b},{} \spad{c} in \spad{A}. This relation can be checked by \spad{lieAdmissible?()\$A}. \blankline If the underlying algebra is of type \spadtype{FramedNonAssociativeAlgebra(R)} (\spadignore{i.e.} a non associative algebra over \spad{R} which is a free \spad{R}-module of finite rank,{} together with a fixed \spad{R}-module basis),{} then the same is \spad{true} for the associated Lie algebra. Also,{} if the underlying algebra is of type \spadtype{FiniteRankNonAssociativeAlgebra(R)} (\spadignore{i.e.} a non associative algebra over \spad{R} which is a free \spad{R}-module of finite rank),{} then the same is \spad{true} for the associated Lie algebra.


kind: d
name: AssociationList
exposed: n
type: (SetCategory,Entry:Type)->AssociationListAggregate(Key,Entry)
params: (Key,Entry)
abbrev: ALIST
comment:
\spadtype{AssociationList} implements association lists. These may be viewed as lists of pairs where the first part is a key and the second is the stored value. For example,{} the key might be a string with a persons employee identification number and the value might be a record with personnel data.


kind: d
name: BalancedBinaryTree
exposed: x
type: (SetCategory)->Join(BinaryTreeCategory(S),etc)
params: (S)
abbrev: BBTREE
comment:
\spadtype{BalancedBinaryTree(S)} is the domain of balanced binary trees (bbtree). A balanced binary tree of \spad{2^k} leaves,{} for some \spad{k > 0},{} is symmetric,{} that is,{} the left and right subtree of each interior node have identical shape. In general,{} the left and right subtree of a given node can differ by at most one leaf node.


kind: d
name: BalancedPAdicInteger
exposed: n
type: (Integer)->PAdicIntegerCategory(p)
params: (p)
abbrev: BPADIC
comment:
Stream-based implementation of \spad{Zp:} \spad{p}-adic numbers are represented as sum(\spad{i} = 0..,{} a[\spad{i}] * p^i),{} where the a[\spad{i}] lie in -(\spad{p} - 1)\spad{/2},{} ...,{} (\spad{p} - 1)\spad{/2}.


kind: d
name: BalancedPAdicRational
exposed: n
type: (Integer)->Join(QuotientFieldCategory(BalancedPAdicInteger(p)),etc)
params: (p)
abbrev: BPADICRT
comment:
Stream-based implementation of \spad{Qp:} numbers are represented as sum(\spad{i} = \spad{k}..,{} a[\spad{i}] * p^i),{} where the a[\spad{i}] lie in -(\spad{p} - 1)\spad{/2},{} ...,{} (\spad{p} - 1)\spad{/2}.


kind: d
name: BasicOperator
exposed: x
type: ()->Join(OrderedSet,etc)
abbrev: BOP
comment:
A basic operator is an object that can be applied to a list of arguments from a set,{} the result being a kernel over that set.


kind: d
name: BinarySearchTree
exposed: x
type: (OrderedSet)->Join(BinaryTreeCategory(S),etc)
params: (S)
abbrev: BSTREE
comment:
BinarySearchTree(\spad{S}) is the domain of binary trees where elements are ordered across the tree. A binary search tree is either empty or has a value which is an \spad{S},{} and a left and a right which are both BinarySearchTree(\spad{S}).


kind: d
name: BinaryTournament
exposed: x
type: (OrderedSet)->Join(BinaryTreeCategory(S),etc)
params: (S)
abbrev: BTOURN
comment:
\spadtype{BinaryTournament(S)} is the domain of binary trees where elements are ordered down the tree. A binary tournament is either empty or is a node containing a \spadfun{value} of type \spad{S},{} and a \spadfun{left} and a \spadfun{right} which are both \spadtype{BinaryTree(S)}


kind: d
name: BinaryTree
exposed: x
type: (SetCategory)->Join(BinaryTreeCategory(S),etc)
params: (S)
abbrev: BTREE
comment:
\spadtype{BinaryTree(S)} is the domain of all binary trees. A binary tree over \spad{S} is either empty or has a \spadfun{value} which is an \spad{S} and a \spadfun{right} and \spadfun{left} which are both BinaryTree(\spad{S}).


kind: d
name: Boolean
exposed: x
type: ()->Join(OrderedSet,etc)
abbrev: BOOLEAN
comment:
\indented{1}{\spadtype{Boolean} is the elementary logic with 2 values:} \spad{true} and \spad{false}


kind: d
name: CardinalNumber
exposed: x
type: ()->Join(OrderedSet,etc)
abbrev: CARD
comment:
Members of the domain CardinalNumber are values indicating the cardinality of sets,{} both finite and infinite. Arithmetic operations are defined on cardinal numbers as follows. \blankline If \spad{x = \#X} and \spad{y = \#Y} then \indented{2}{\spad{x+y\space{2}= \#(X+Y)}\space{3}\tab{30}disjoint union} \indented{2}{\spad{x-y\space{2}= \#(X-Y)}\space{3}\tab{30}relative complement} \indented{2}{\spad{x*y\space{2}= \#(X*Y)}\space{3}\tab{30}cartesian product} \indented{2}{\spad{x^y = \#(X^Y)}\space{2}\tab{30}\spad{X^Y = \{g| g: Y->X\}}} \blankline The non-negative integers have a natural construction as cardinals \indented{2}{\spad{0 = \#\{\}},{} \spad{1 = \{0\}},{} \spad{2 = \{0,{} 1\}},{} ...,{} \spad{n = \{i| 0 <= i < n\}}.} \blankline That \spad{0} acts as a zero for the multiplication of cardinals is equivalent to the axiom of choice. \blankline The generalized continuum hypothesis asserts \centerline{\spad{2^Aleph i = Aleph(i+1)}} and is independent of the axioms of set theory [Goedel 1940]. \blankline Three commonly encountered cardinal numbers are \indented{3}{\spad{a = \#Z}\space{7}\tab{30}countable infinity} \indented{3}{\spad{c = \#R}\space{7}\tab{30}the continuum} \indented{3}{\spad{f = \#\{g| g: [0,{} 1]->R\}}} \blankline In this domain,{} these values are obtained using \indented{3}{\spad{a := Aleph 0},{} \spad{c := 2^a},{} \spad{f := 2^c}.} \blankline


kind: d
name: CartesianTensor
exposed: x
type: (Integer,dim:NonNegativeInteger,R:CommutativeRing)->Join(GradedAlgebra(R,NonNegativeInteger),etc)
params: (minix,dim,R)
abbrev: CARTEN
comment:
CartesianTensor(minix,{} dim,{} \spad{R}) provides Cartesian tensors with components belonging to a commutative ring \spad{R}. These tensors can have any number of indices. Each index takes values from \spad{minix} to \spad{minix + dim - 1}.


kind: d
name: ChainComplex
exposed: n
type: ()->Join(SetCategory,etc)
abbrev: CHAINC
comment:
\indented{2}{Delta Complexes are defined by a sequence of 'face maps',{} These} \indented{2}{can be represented by a list of matrices.} \indented{2}{for more documentation see:} \indented{2}{http://www.euclideanspace.com/prog/scratchpad/mycode/topology/chain/} Date Created: March 2016 Basic Operations: Related packages: Related categories: Related Domains: CoChainComplex Also See: AMS Classifications:


kind: d
name: CliffordAlgebra
exposed: x
type: (n:PositiveInteger,K:Field,SquareMatrix(n,K))->Join(Ring,etc)
params: (n,K,bLin)
abbrev: CLIF
comment:
CliffordAlgebra(\spad{n},{} \spad{K},{} bLin) defines a module of dimension \spad{2^n} over \spad{K},{} given a bilinear form bLin on \spad{K^n}. \blankline Examples of Clifford Algebras are: gaussians,{} quaternions,{} exterior algebras and spin algebras.


kind: d
name: CoChainComplex
exposed: n
type: (AbelianGroup)->Join(SetCategory,etc)
params: (VS)
abbrev: COCHNC
comment:
\indented{2}{Delta Complexes are defined by a sequence of 'face maps',{} These can} \indented{2}{be represented by a list of matrices.} \indented{2}{for more documentation see:} \indented{2}{http://www.euclideanspace.com/prog/scratchpad/mycode/topology/chain/cochain/} Date Created: Jan 2016 Basic Operations: Related packages: Related categories: Related Domains: ChainComplex Also See: AMS Classifications:


kind: d
name: Color
exposed: x
type: ()->Join(AbelianSemiGroup,etc)
abbrev: COLOR
comment:
Color() specifies a domain of 27 colors provided in the \Language{} system (the colors mix additively).


kind: d
name: Complex
exposed: x
type: (CommutativeRing)->Join(ComplexCategory(R),etc)
params: (R)
abbrev: COMPLEX
comment:
\spadtype {Complex(R)} creates the domain of elements of the form \spad{a + b * i} where \spad{a} and \spad{b} come from the ring \spad{R},{} and \spad{i} is a new element such that \spad{i^2 = -1}.


kind: d
name: ComplexDoubleFloatMatrix
exposed: n
type: ()->MatrixCategory(Complex(DoubleFloat),ComplexDoubleFloatVector,ComplexDoubleFloatVector)
abbrev: CDFMAT
comment:
This is a low-level domain which implements matrices (two dimensional arrays) of complex double precision floating point numbers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).


kind: d
name: ComplexDoubleFloatVector
exposed: n
type: ()->Join(VectorCategory(Complex(DoubleFloat)),etc)
abbrev: CDFVEC
comment:
This is a low-level domain which implements vectors (one dimensional arrays) of complex double precision floating point numbers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).


kind: d
name: ContinuedFraction
exposed: x
type: (EuclideanDomain)->Join(Algebra(R),etc)
params: (R)
abbrev: CONTFRAC
comment:
\spadtype{ContinuedFraction} implements general \indented{1}{continued fractions.\space{2}This version is not restricted to simple,{}} \indented{1}{finite fractions and uses the \spadtype{Stream} as a} \indented{1}{representation.\space{2}The arithmetic functions assume that the} \indented{1}{approximants alternate below/above the convergence point.} \indented{1}{This is enforced by ensuring the partial numerators and partial} \indented{1}{denominators are greater than 0 in the Euclidean domain view of \spad{R}} \indented{1}{(\spadignore{i.e.} \spad{sizeLess?(0,{} x)}).}


kind: d
name: CubicalFacet
exposed: n
type: ()->Join(FacetCategory,etc)
abbrev: CFACET
comment:
\indented{2}{A single vertex,{} edge,{} square,{} cube...} \indented{2}{for more documentation see:} \indented{2}{http://www.euclideanspace.com/prog/scratchpad/mycode/topology/cubical/} Date Created: April 2016 Basic Operations: Related packages: Related categories: FacetCategory Related Domains: Also See: AMS Classifications:


kind: d
name: Database
exposed: x
type: (Join(OrderedSet,etc))->Join(SetCategory,etc)
params: (S)
abbrev: DBASE
comment:
\indented{1}{This domain implements a simple view of a database whose fields are} indexed by symbols


kind: d
name: DeltaComplex
exposed: n
type: (AbelianGroup)->Join(SetCategory,etc)
params: (VS)
abbrev: DELTAC
comment:
\indented{2}{Similar to Simplicial Complex but faces (edges,{} triangles,{} etc.)} \indented{2}{are indexed by 'face maps' into the next lower face map until} \indented{2}{we get down to the vertices.} \indented{2}{for more documentation see:} \indented{2}{http://www.euclideanspace.com/prog/scratchpad/mycode/topology/delta/} Date Created: Feb 2016 Basic Operations: Related packages: Related categories: Related Domains: FiniteSimplicialComplex is a simpler and more \indented{3}{compact representation which can be used if edges,{} triangles,{}} \indented{3}{etc. don\spad{'t} need to be indexed.} Also See: AMS Classifications:


kind: d
name: DenavitHartenbergMatrix
exposed: x
type: (Join(Field,etc))->Join(MatrixCategory(R,Vector(R),Vector(R)),etc)
params: (R)
abbrev: DHMATRIX
comment:
\indented{1}{A Denavit-Hartenberg Matrix is a 4x4 Matrix of the form:} \indented{1}{\spad{nx ox ax px}} \indented{1}{\spad{ny oy ay py}} \indented{1}{\spad{nz oz az pz}} \indented{2}{\spad{0\space{2}0\space{2}0\space{2}1}} (\spad{n},{} \spad{o},{} and a are the direction cosines)


kind: d
name: DeRhamComplex
exposed: n
type: (Join(Ring,etc),List(Symbol))->Join(LeftAlgebra(Expression(CoefRing)),etc)
params: (CoefRing,listIndVar)
abbrev: DERHAM
comment:
The deRham complex of Euclidean space,{} that is,{} the class of differential forms of arbitrary degree over a coefficient ring. See Flanders,{} Harley,{} Differential Forms,{} With Applications to the Physical Sciences,{} New York,{} Academic Press,{} 1963.


kind: d
name: DifferentialSparseMultivariatePolynomial
exposed: n
params: (R,S,V)
abbrev: DSMP
type:
(Ring,S:OrderedSet,V:DifferentialVariableCategory(S))->Join(DifferentialPolynomialCategory(R,S,V,IndexedExponents(V)),etc)

comment:
\spadtype{DifferentialSparseMultivariatePolynomial} implements an ordinary differential polynomial ring by combining a domain belonging to the category \spadtype{DifferentialVariableCategory} with the domain \spadtype{SparseMultivariatePolynomial}. \blankline


kind: d
name: DihedralGroup
exposed: n
type: (PositiveInteger,Symbol,Symbol)->Join(FiniteGroup,etc)
params: (n,a,b)
abbrev: DIHGRP
comment:
\spad{DihedralGroup(n,{} a,{} b)} is the dihedral group generated by a rotation a of order \spad{n} and a reflection \spad{b}.


kind: d
name: DirectProduct
exposed: n
type: (NonNegativeInteger,R:Type)->Join(DirectProductCategory(dim,R),etc)
params: (dim,R)
abbrev: DIRPROD
comment:
\indented{2}{This type represents the finite direct or cartesian product of an} underlying component type. This contrasts with simple vectors in that the members can be viewed as having constant length. Thus many categorical properties can by lifted from the underlying component type. Component extraction operations are provided but no updating operations. Thus new direct product elements can either be created by converting vector elements using the \spadfun{directProduct} function or by taking appropriate linear combinations of basis vectors provided by the \spad{unitVector} operation.


kind: d
name: DirectProductMatrixModule
exposed: n
params: (n,R,M,S)
abbrev: DPMM
comment: This constructor provides a direct product type with a left matrix-module view.
type:
(n:PositiveInteger,R:Ring,M:SquareMatrixCategory(n,R,DirectProduct(n,R),DirectProduct(n,R)),S:LeftModule(R))->Join(DirectProductCategory(n,S),etc)


kind: d
name: DistributedJetBundlePolynomial
exposed: n
params: (R,JB,LJV,E)
abbrev: DJBP
type:
(Ring,JB:JetBundleCategory,LJV:List(JB),E:DirectProductCategory(#(LJV),NonNegativeInteger))->Join(PolynomialCategory(R,E,JB),etc)

comment:
\spadtype{DistributedJetBundlePolynomial} implements polynomials in a distributed representation. The unknowns come from a finite list of jet variables. The implementation is basically a copy of the one of \spadtype{GeneralDistributedMultivariatePolynomial}.


kind: d
name: DistributedMultivariatePolynomial
exposed: n
params: (vl,R)
abbrev: DMP
type:
(List(Symbol),R:Ring)->Join(PolynomialCategory(R,DirectProduct(#(vl),NonNegativeInteger),OrderedVariableList(vl)),etc)

comment:
\indented{2}{This type supports distributed multivariate polynomials} whose variables are from a user specified list of symbols. The coefficient ring may be non commutative,{} but the variables are assumed to commute. The term ordering is lexicographic specified by the variable list parameter with the most significant variable first in the list.


kind: d
name: Distribution
exposed: x
type: (CommutativeRing)->Join(DistributionCategory(R),etc)
params: (R)
abbrev: DISTRO
comment:
Domain for distributions formally given by moments. moments and different kinds of cumulants are stored in streams and computed on demand.


kind: d
name: DoubleFloat
exposed: x
type: ()->Join(FloatingPointSystem,etc)
abbrev: DFLOAT
comment:
\indented{1}{\spadtype{DoubleFloat} is intended to make accessible} hardware floating point arithmetic in \Language{},{} either native double precision,{} or IEEE. On most machines,{} there will be hardware support for the arithmetic operations: \spadfunFrom{+}{DoubleFloat},{} \spadfunFrom{*}{DoubleFloat},{} \spadfunFrom{/}{DoubleFloat} and possibly also the \spadfunFrom{sqrt}{DoubleFloat} operation. The operations \spadfunFrom{exp}{DoubleFloat},{} \spadfunFrom{log}{DoubleFloat},{} \spadfunFrom{sin}{DoubleFloat},{} \spadfunFrom{cos}{DoubleFloat},{} \spadfunFrom{atan}{DoubleFloat} are normally coded in software based on minimax polynomial/rational approximations. Some general comments about the accuracy of the operations: the operations \spadfunFrom{+}{DoubleFloat},{} \spadfunFrom{*}{DoubleFloat},{} \spadfunFrom{/}{DoubleFloat} and \spadfunFrom{sqrt}{DoubleFloat} are expected to be fully accurate. The operations \spadfunFrom{exp}{DoubleFloat},{} \spadfunFrom{log}{DoubleFloat},{} \spadfunFrom{sin}{DoubleFloat},{} \spadfunFrom{cos}{DoubleFloat} and \spadfunFrom{atan}{DoubleFloat} are not expected to be fully accurate. In particular,{} \spadfunFrom{sin}{DoubleFloat} and \spadfunFrom{cos}{DoubleFloat} will lose all precision for large arguments. \blankline The \spadtype{Float} domain provides an alternative to the \spad{DoubleFloat} domain. It provides an arbitrary precision model of floating point arithmetic. This means that accuracy problems like those above are eliminated by increasing the working precision where necessary. \spadtype{Float} provides some special functions such as \spadfunFrom{erf}{\spad{DoubleFloatSpecialFunctions2}},{} the error function in addition to the elementary functions. The disadvantage of \spadtype{Float} is that it is much more expensive than small floats when the latter can be used.


kind: d
name: DoubleFloatMatrix
exposed: n
type: ()->MatrixCategory(DoubleFloat,DoubleFloatVector,DoubleFloatVector)
abbrev: DFMAT
comment:
This is a low-level domain which implements matrices (two dimensional arrays) of double precision floating point numbers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).


kind: d
name: DoubleFloatVector
exposed: n
type: ()->Join(VectorCategory(DoubleFloat),etc)
abbrev: DFVEC
comment:
This is a low-level domain which implements vectors (one dimensional arrays) of double precision floating point numbers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).


kind: d
name: ElementaryFunctionsGeneralizedUnivariatePowerSeries
exposed: n
params: (Coef,Expon,PS)
abbrev: EFGUSER
comment: This package implements elementary functions on general \indented{1}{univariate power series.}
type:
(Coef:Algebra(Fraction(Integer)),Expon:OrderedAbelianMonoid,PS:Join(UnivariatePowerSeriesCategory(Coef,Expon),etc))->Join(PartialTranscendentalFunctions(PS),etc)


kind: d
name: ElementaryFunctionsUnivariateLaurentSeries
exposed: n
params: (Coef,UTS,ULS)
abbrev: EFULS
type:
(Coef:Algebra(Fraction(Integer)),UTS:UnivariateTaylorSeriesCategory(Coef),ULS:UnivariateLaurentSeriesConstructorCategory(Coef,UTS))->Join(PartialTranscendentalFunctions(ULS),etc)

comment:
\indented{1}{This package provides elementary functions on any Laurent series} domain over a field which was constructed from a Taylor series domain. These functions are implemented by calling the corresponding functions on the Taylor series domain. We also provide 'partial functions' which compute transcendental functions of Laurent series when possible and return failed when this is not possible.


kind: d
name: ElementaryFunctionsUnivariatePuiseuxSeries
exposed: n
params: (Coef,ULS,UPXS,EFULS)
abbrev: EFUPXS
type:
(Coef:Algebra(Fraction(Integer)),ULS:UnivariateLaurentSeriesCategory(Coef),UPXS:UnivariatePuiseuxSeriesConstructorCategory(Coef,ULS),PartialTranscendentalFunctions(ULS))->Join(PartialTranscendentalFunctions(UPXS),etc)

comment:
\indented{1}{This package provides elementary functions on any Laurent series} domain over a field which was constructed from a Taylor series domain. These functions are implemented by calling the corresponding functions on the Taylor series domain. We also provide 'partial functions' which compute transcendental functions of Laurent series when possible and return failed when this is not possible.


kind: d
name: Enumeration
exposed: x
type: special
params: (a,b,...,c)
abbrev: ENUM
comment:
\spad{Enumeration(a,b,...,c)} is a primitive type in FriCAS used to represent the object composed of the symbols \spad{a},\spad{b},..., and \spad{c}.


kind: d
name: EqTable
exposed: n
type: (SetCategory,Entry:Type)->Join(TableAggregate(Key,Entry),etc)
params: (Key,Entry)
abbrev: EQTBL
comment:
This domain provides tables where the keys are compared using \spadfun{eq?}. Thus keys are considered equal only if they are the same instance of a structure.


kind: d
name: Equation
exposed: x
type: (Type)->Join(Type,etc)
params: (S)
abbrev: EQ
comment:
Equations as mathematical objects. All properties of the basis domain,{} \spadignore{e.g.} being an abelian group are carried over the equation domain,{} by performing the structural operations on the left and on the right hand side.


kind: d
name: EuclideanModularRing
exposed: n
params: (S,R,Mod,reduction,merge,exactQuo)
abbrev: EMR
type:
(S:CommutativeRing,R:UnivariatePolynomialCategory(S),Mod:AbelianMonoid,(R,Mod)->R,(Mod,Mod)->Union(Mod,failed),(R,R,Mod)->Union(R,failed))->Join(EuclideanDomain,etc)

comment:
These domains are used for the factorization and gcds of univariate polynomials over the integers in order to work modulo different primes. See \spadtype{ModularRing},{} \spadtype{ModularField}


kind: d
name: Exit
exposed: x
type: ()->SetCategory
abbrev: EXIT
comment:
A function which does not return directly to its caller should have Exit as its return type. \blankline Note: It is convenient to have a formal \spad{coerce} into each type from type Exit. This allows,{} for example,{} errors to be raised in one half of a type-balanced \spad{if}.


kind: d
name: ExponentialExpansion
exposed: n
params: (R,FE,var,cen)
abbrev: EXPEXPAN
type:
(R:Join(Comparable,etc),FE:Join(AlgebraicallyClosedField,etc),var:Symbol,cen:FE)->Join(QuotientFieldCategory(UnivariatePuiseuxSeriesWithExponentialSingularity(R,FE,var,cen)),etc)

comment:
UnivariatePuiseuxSeriesWithExponentialSingularity is a domain used to represent essential singularities of functions. Objects in this domain are quotients of sums,{} where each term in the sum is a univariate Puiseux series times the exponential of a univariate Puiseux series.


kind: d
name: ExponentialOfUnivariatePuiseuxSeries
exposed: n
type: (FE:Join(Field,etc),var:Symbol,cen:FE)->Join(UnivariatePuiseuxSeriesCategory(FE),etc)
params: (FE,var,cen)
abbrev: EXPUPXS
comment:
ExponentialOfUnivariatePuiseuxSeries is a domain used to represent essential singularities of functions. An object in this domain is a function of the form \spad{exp(f(x))},{} where \spad{f(x)} is a Puiseux series with no terms of non-negative degree. Objects are ordered according to order of singularity,{} with functions which tend more rapidly to zero or infinity considered to be larger. Thus,{} if \spad{order(f(x)) < order(g(x))},{} \spadignore{i.e.} the first non-zero term of \spad{f(x)} has lower degree than the first non-zero term of \spad{g(x)},{} then \spad{exp(f(x)) > exp(g(x))}. If \spad{order(f(x)) = order(g(x))},{} then the ordering is essentially random. This domain is used in computing limits involving functions with essential singularities.


kind: d
name: ExtAlgBasis
exposed: n
type: ()->Join(OrderedSet,etc)
abbrev: EAB
comment:
A domain used in the construction of the exterior algebra on a set \spad{X} over a ring \spad{R}. This domain represents the set of all ordered subsets of the set \spad{X},{} assumed to be in correspondence with {1,{} 2,{} 3,{} ...}. The ordered subsets are themselves ordered lexicographically and are in bijective correspondence with an ordered basis of the exterior algebra. In this domain we are dealing strictly with the exponents of basis elements which can only be 0 or 1. \blankline The multiplicative identity element of the exterior algebra corresponds to the empty subset of \spad{X}. A coerce from List Integer to an ordered basis element is provided to allow the convenient input of expressions. Another exported function forgets the ordered structure and simply returns the list corresponding to an ordered subset.


kind: d
name: Factored
exposed: x
type: (IntegralDomain)->Join(IntegralDomain,etc)
params: (R)
abbrev: FR
comment:
\spadtype{Factored} creates a domain whose objects are kept in factored form as long as possible. Thus certain operations like multiplication and \spad{gcd} are relatively easy to do. Others,{} like addition require somewhat more work,{} and unless the argument domain provides a factor function,{} the result may not be completely factored. Each object consists of a unit and a list of factors,{} where a factor has a member of \spad{R} (the base),{} and exponent and a flag indicating what is known about the base. A flag may be one of nil,{} sqfr,{} irred or prime,{} which respectively mean that nothing is known about the base,{} it is square-free,{} it is irreducible,{} or it is prime. The current restriction to integral domains allows simplification to be performed without worrying about multiplication order.


kind: d
name: FakePolynomial
exposed: n
type: ()->Join(CoercibleTo(OutputForm),etc)
abbrev: FAKEPOL
comment:
FakePolynomial is a domain of univariate polynomials \indented{1}{with coefficients being fractions of multivariate integer} \indented{1}{polynomials.\space{2}Coefficients are kept in unsimplified form.} \indented{1}{This domain exists to avoid cost of recursive \spad{GCD} calls} \indented{1}{during polynomial evaluation.}


kind: d
name: File
exposed: x
type: (SetCategory)->Join(FileCategory(FileName,S),etc)
params: (S)
abbrev: FILE
comment:
This domain provides a basic model of files to save arbitrary values. The operations provide sequential access to the contents.


kind: d
name: FiniteBiCPO
exposed: n
type: (SetCategory)->BiCPO(S)
params: (S)
abbrev: FBICPO
comment:
Holds a complete set together with a structure to codify the partial order. For more documentation see: \indented{2}{\url{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/logic/index.\spad{htm}}}


kind: d
name: FiniteCubicalComplex
exposed: n
type: (AbelianGroup)->Join(SetCategory,etc)
params: (VS)
abbrev: CUBEC
comment:
\indented{2}{A Finite Cubical Complex} \indented{2}{for more documentation see:} \indented{2}{http://www.euclideanspace.com/prog/scratchpad/mycode/topology/cubical/} Date Created: April 2016 Basic Operations: Related packages: Related categories: Related Domains: Also See: AMS Classifications:


kind: d
name: FiniteDivisor
exposed: n
params: (F,UP,UPUP,R)
abbrev: FDIV
type:
(F:Field,UP:UnivariatePolynomialCategory(F),UPUP:UnivariatePolynomialCategory(Fraction(UP)),R:FunctionFieldCategory(F,UP,UPUP))->Join(FiniteDivisorCategory(F,UP,UPUP,R),etc)

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


kind: d
name: FiniteField
exposed: x
type: (PositiveInteger,PositiveInteger)->FiniteAlgebraicExtensionField(PrimeField(p))
params: (p,n)
abbrev: FF
comment:
FiniteField(\spad{p},{} \spad{n}) implements finite fields with \spad{p^n} elements. This packages checks that \spad{p} is prime. For a non-checking version,{} see \spadtype{InnerFiniteField}.


kind: d
name: FiniteFieldCyclicGroup
exposed: x
type: (PositiveInteger,PositiveInteger)->Join(FiniteAlgebraicExtensionField(PrimeField(p)),etc)
params: (p,extdeg)
abbrev: FFCG
comment:
FiniteFieldCyclicGroup(\spad{p},{} \spad{n}) implements a finite field extension of degee \spad{n} over the prime field with \spad{p} elements. Its elements are represented by powers of a primitive element,{} \spadignore{i.e.} a generator of the multiplicative (cyclic) group. As primitive element we choose the root of the extension polynomial,{} which is created by {\em createPrimitivePoly} from \spadtype{FiniteFieldPolynomialPackage}. The Zech logarithms are stored in a table of size half of the field size,{} and use \spadtype{SingleInteger} for representing field elements,{} hence,{} there are restrictions on the size of the field.


kind: d
name: FiniteFieldCyclicGroupExtension
exposed: n
type: (FiniteFieldCategory,PositiveInteger)->Join(FiniteAlgebraicExtensionField(GF),etc)
params: (GF,extdeg)
abbrev: FFCGX
comment:
FiniteFieldCyclicGroupExtension(\spad{GF},{} \spad{n}) implements a extension of degree \spad{n} over the ground field {\em GF}. Its elements are represented by powers of a primitive element,{} \spadignore{i.e.} a generator of the multiplicative (cyclic) group. As primitive element we choose the root of the extension polynomial,{} which is created by {\em createPrimitivePoly} from \spadtype{FiniteFieldPolynomialPackage}. Zech logarithms are stored in a table of size half of the field size,{} and use \spadtype{SingleInteger} for representing field elements,{} hence,{} there are restrictions on the size of the field.


kind: d
name: FiniteFieldCyclicGroupExtensionByPolynomial
exposed: n
params: (GF,defpol)
abbrev: FFCGP
type:
(GF:FiniteFieldCategory,SparseUnivariatePolynomial(GF))->Join(FiniteAlgebraicExtensionField(GF),etc)

comment:
FiniteFieldCyclicGroupExtensionByPolynomial(\spad{GF},{} defpol) implements a finite extension field of the ground field {\em GF}. Its elements are represented by powers of a primitive element,{} \spadignore{i.e.} a generator of the multiplicative (cyclic) group. As primitive element we choose the root of the extension polynomial {\em defpol},{} which MUST be primitive (user responsibility). Zech logarithms are stored in a table of size half of the field size,{} and use \spadtype{SingleInteger} for representing field elements,{} hence,{} there are restrictions on the size of the field.


kind: d
name: FiniteFieldExtension
exposed: n
type: (FiniteFieldCategory,PositiveInteger)->FiniteAlgebraicExtensionField(GF)
params: (GF,n)
abbrev: FFX
comment:
FiniteFieldExtensionByPolynomial(\spad{GF},{} \spad{n}) implements an extension of the finite field {\em GF} of degree \spad{n} generated by the extension polynomial constructed by \spadfunFrom{createIrreduciblePoly}{FiniteFieldPolynomialPackage} from \spadtype{FiniteFieldPolynomialPackage}.


kind: d
name: FiniteFieldExtensionByPolynomial
exposed: n
type: (GF:FiniteFieldCategory,SparseUnivariatePolynomial(GF))->FiniteAlgebraicExtensionField(GF)
params: (GF,defpol)
abbrev: FFP
comment:
FiniteFieldExtensionByPolynomial(\spad{GF},{} defpol) implements the extension of the finite field {\em GF} generated by the extension polynomial {\em defpol} which MUST be irreducible. Note: the user has the responsibility to ensure that {\em defpol} is irreducible.


kind: d
name: FiniteFieldNormalBasis
exposed: x
type: (PositiveInteger,PositiveInteger)->Join(FiniteAlgebraicExtensionField(PrimeField(p)),etc)
params: (p,extdeg)
abbrev: FFNB
comment:
FiniteFieldNormalBasis(\spad{p},{} \spad{n}) implements a finite extension field of degree \spad{n} over the prime field with \spad{p} elements. The elements are represented by coordinate vectors with respect to a normal basis,{} \spadignore{i.e.} a basis consisting of the conjugates (\spad{q}-powers) of an element,{} in this case called normal element. This is chosen as a root of the extension polynomial created by \spadfunFrom{createNormalPoly}{FiniteFieldPolynomialPackage}.


kind: d
name: FiniteFieldNormalBasisExtension
exposed: n
type: (FiniteFieldCategory,PositiveInteger)->Join(FiniteAlgebraicExtensionField(GF),etc)
params: (GF,extdeg)
abbrev: FFNBX
comment:
FiniteFieldNormalBasisExtensionByPolynomial(\spad{GF},{} \spad{n}) implements a finite extension field of degree \spad{n} over the ground field {\em GF}. The elements are represented by coordinate vectors with respect to a normal basis,{} \spadignore{i.e.} a basis consisting of the conjugates (\spad{q}-powers) of an element,{} in this case called normal element. This is chosen as a root of the extension polynomial,{} created by {\em createNormalPoly} from \spadtype{FiniteFieldPolynomialPackage}


kind: d
name: FiniteFieldNormalBasisExtensionByPolynomial
exposed: n
params: (GF,uni)
abbrev: FFNBP
type:
(GF:FiniteFieldCategory,Union(SparseUnivariatePolynomial(GF),Vector(List(Record(value:GF,index:SingleInteger)))))->Join(FiniteAlgebraicExtensionField(GF),etc)

comment:
FiniteFieldNormalBasisExtensionByPolynomial(\spad{GF},{} uni) implements a finite extension of the ground field {\em GF}. The elements are represented by coordinate vectors with respect to. a normal basis,{} \spadignore{i.e.} a basis consisting of the conjugates (\spad{q}-powers) of an element,{} in this case called normal element,{} where \spad{q} is the size of {\em GF}. The normal element is chosen as a root of the extension polynomial,{} which MUST be normal over {\em GF} (user responsibility)


kind: d
name: FiniteLattice
exposed: n
type: (S:SetCategory,FiniteBiCPO(S))->Join(Lattice,etc)
params: (S,p)
abbrev: FINLAT
comment:
This is the algebration of poset. A big difference between \indented{3}{this lattice domain and the poset domain is that,{} in this domain,{} the} \indented{3}{REP holds a single node whereas in poset REP holds the whole poset.} Date Created: Aug 2015


kind: d
name: FiniteSimplicialComplex
exposed: n
type: (AbelianGroup)->Join(SetCategory,etc)
params: (VS)
abbrev: SIMPC
comment:
\indented{2}{A Finite Simplicial Complex} \indented{2}{for more documentation see:} \indented{2}{http://www.euclideanspace.com/prog/scratchpad/mycode/topology/simplex/} Date Created: Dec 2015 Basic Operations: star,{} link,{} cone,{} product Related packages: Related categories: Related Domains: DeltaComplex is an alternative representation \indented{3}{which is less compact but allows edges,{} triangles,{} etc to be indexed.} Also See: AMS Classifications:


kind: d
name: FlexibleArray
exposed: x
type: (Type)->Join(OneDimensionalArrayAggregate(S),etc)
params: (S)
abbrev: FARRAY
comment:
A FlexibleArray is the notion of an array intended to allow for growth at the end only. Hence the following efficient operations \indented{2}{\spad{concat!(a,{} x)} meaning append item \spad{x} at the end of the array \spad{a}} \indented{2}{\spad{delete!(a,{} n)} meaning delete the last item from the array \spad{a}} Flexible arrays support the other operations inherited from \spadtype{ExtensibleLinearAggregate}. However,{} these are not efficient. Flexible arrays combine the \spad{O(1)} access time property of arrays with growing and shrinking at the end in \spad{O(1)} (average) time. This is done by using an ordinary array which may have zero or more empty slots at the end. When the array becomes full it is copied into a new larger (50\% larger) array. Conversely,{} when the array becomes less than 1/2 full,{} it is copied into a smaller array. Flexible arrays provide for an efficient implementation of many data structures in particular heaps,{} stacks and sets.


kind: d
name: Float
exposed: x
type: ()->Join(FloatingPointSystem,etc)
abbrev: FLOAT
comment:
\spadtype{Float} implements arbitrary precision floating point arithmetic. The number of significant digits of each operation can be set to an arbitrary value (the default is 20 decimal digits). The operation \spadfunFrom{float}{FloatingPointSystem}(mantissa,{} exponent,{} \spadfunFrom{base}{FloatingPointSystem}) for integer \spad{mantissa},{} \spad{exponent} specifies the number \spad{mantissa} * \spadfunFrom{base}{FloatingPointSystem} ^ \spad{exponent} The underlying representation for floats is binary not decimal. The implications of this are described below. \blankline The model adopted is that arithmetic operations are rounded to to nearest unit in the last place,{} that is,{} accurate to within 2^(-\spadfunFrom{bits}{FloatingPointSystem}). Also,{} the elementary functions and constants are accurate to one unit in the last place. A float is represented as a record of two integers,{} the mantissa and the exponent. The \spadfunFrom{base}{FloatingPointSystem} of the representation is binary,{} hence a \spad{Record(m: mantissa,{} e: exponent)} represents the number \spad{m * 2 ^ e}. Though it is not assumed that the underlying integers are represented with a binary \spadfunFrom{base}{FloatingPointSystem},{} the code will be most efficient when this is the the case (this is \spad{true} in most implementations of Lisp). The decision to choose the \spadfunFrom{base}{FloatingPointSystem} to be binary has some unfortunate consequences. First,{} decimal numbers like 0.3 cannot be represented exactly. Second,{} there is a further loss of accuracy during conversion to decimal for output. To compensate for this,{} if \spad{d} digits of precision are specified,{} \spad{1 + ceiling(log2(10^d))} bits are used. Two numbers that are displayed identically may therefore be not equal. On the other hand,{} a significant efficiency loss would be incurred if we chose to use a decimal \spadfunFrom{base}{FloatingPointSystem} when the underlying integer base is binary. \blankline Algorithms used: For the elementary functions,{} the general approach is to apply identities so that the taylor series can be used,{} and,{} so that it will converge within \spad{O( sqrt n )} steps. For example,{} using the identity \spad{exp(x) = exp(x/2)^2},{} we can compute \spad{exp(1/3)} to \spad{n} digits of precision as follows. We have \spad{exp(1/3) = exp(2 ^ (-sqrt s) / 3) ^ (2 ^ sqrt s)}. The taylor series will converge in less than sqrt \spad{n} steps and the exponentiation requires sqrt \spad{n} multiplications for a total of \spad{2 sqrt n} multiplications. Assuming integer multiplication costs \spad{O( n^2 )} the overall running time is \spad{O( sqrt(n) n^2 )}. This approach is the best known approach for precisions up to about 10,{} 000 digits at which point the methods of Brent which are \spad{O( log(n) n^2 )} become competitive. Note also that summing the terms of the taylor series for the elementary functions is done using integer operations. This avoids the overhead of floating point operations and results in efficient code at low precisions. This implementation makes no attempt to reuse storage,{} relying on the underlying system to do \spadgloss{garbage collection}. \spad{I} estimate that the efficiency of this package at low precisions could be improved by a factor of 2 if in-place operations were available. \blankline Running times: in the following,{} \spad{n} is the number of bits of precision \indented{5}{\spad{*},{} \spad{/},{} \spad{sqrt},{} \spad{\spad{pi}},{} \spad{exp1},{} \spad{log2},{} \spad{log10}: \spad{ O( n^2 )}} \indented{5}{\spad{exp},{} \spad{log},{} \spad{sin},{} \spad{atan}:\space{2}\spad{ O( sqrt(n) n^2 )}} The other elementary functions are coded in terms of the ones above.


kind: d
name: Format1D
exposed: n
type: ()->FormatterCategory
abbrev: FMT1D
comment:
\indented{1}{\spadtype{Format1D} provides a coercion from \spadtype{OutputForm}} to a one-dimensional format such that the output can be pasted back as input,{}


kind: d
name: Format2D
exposed: n
type: ()->FormatterCategory
abbrev: FMT2D
comment:
\indented{1}{\spadtype{Format2D} provides a coercion from} \spadtype{OutputForm} to two-dimensional format.


kind: d
name: FormatLaTeX
exposed: n
type: ()->Join(FormatterCategory,etc)
abbrev: FMTLATEX
comment:
\indented{1}{\spadtype{FormatLaTeX} provides a coercion from} \spadtype{OutputForm} to \LaTeX{} format. The particular dialect of \TeX{} used is \LaTeX{},{} but for flexibility reasons \spadtype{FormatLaTeX} outputs everything into a fricasmath environment in which certain additional commands are available. These commands are defined in a .sty file that is distributed with the source code of FriCAS.


kind: d
name: FormatMathJax
exposed: n
type: ()->Join(FormatterCategory,etc)
abbrev: FMTMJAX
comment:
\indented{1}{\spadtype{FormatMathJax} provides a coercion from} \spadtype{OutputForm} to a \LaTeX{} format in a variant that can be understood by MahtJax (https://www.mathjax.org).


kind: d
name: FormattedOutput
exposed: n
type: ()->Join(OutputFormatterCategory,etc)
abbrev: FMTOUT
comment:
\indented{1}{The domain \spad{FormattedOutput} is used when} )set output formatted on is issued on the command line. Then for each formatter that is stored in the internal data structure of \spad{FormattedOutput}


kind: d
name: FortranExpression
exposed: n
type: (List(Symbol),List(Symbol),R:FortranMachineTypeCategory)->Join(ExpressionSpace,etc)
params: (basicSymbols,subscriptedSymbols,R)
abbrev: FEXPR
comment:
A domain of expressions involving functions which can be translated into standard Fortran-77,{} with some extra extensions from the NAG Fortran Library.


kind: d
name: FortranProgram
exposed: n
params: (name,returnType,arguments,symbols)
abbrev: FORTRAN
type:
(Symbol,Union(fst:FortranScalarType,void:void),List(Symbol),SymbolTable)->Join(FortranProgramCategory,etc)

comment:
\spadtype{FortranProgram} allows the user to build and manipulate simple models of FORTRAN subprograms. These can then be transformed into actual FORTRAN notation.


kind: d
name: FortranScalarType
exposed: n
type: ()->Join(CoercibleTo(OutputForm),etc)
abbrev: FST
comment:
Creates and manipulates objects which correspond to the basic FORTRAN data types: REAL,{} INTEGER,{} COMPLEX,{} LOGICAL and CHARACTER


kind: d
name: FortranType
exposed: n
type: ()->Join(SetCategory,etc)
abbrev: FT
comment:
Creates and manipulates objects which correspond to FORTRAN data types,{} including array dimensions.


kind: d
name: Fraction
exposed: x
type: (IntegralDomain)->Join(QuotientFieldCategory(S),etc)
params: (S)
abbrev: FRAC
comment:
Fraction takes an IntegralDomain \spad{S} and produces the domain of Fractions with numerators and denominators from \spad{S}. If \spad{S} is also a GcdDomain,{} then \spad{gcd}\spad{'s} between numerator and denominator will be cancelled during all operations.


kind: d
name: FractionalIdeal
exposed: n
params: (R,F,UP,A)
abbrev: FRIDEAL
comment: Fractional ideals in a framed algebra.
type:
(R:EuclideanDomain,F:QuotientFieldCategory(R),UP:UnivariatePolynomialCategory(F),A:Join(FramedAlgebra(F,UP),etc))->Join(Group,etc)


kind: d
name: FractionalIdealAsModule
exposed: n
params: (R,F,UP,A,ibasis)
abbrev: FRIMOD
comment: Module representation of fractional ideals.
type:
(R:EuclideanDomain,F:QuotientFieldCategory(R),UP:UnivariatePolynomialCategory(F),A:FramedAlgebra(F,UP),Vector(A))->Join(Monoid,etc)


kind: d
name: FreeDivisionAlgebra
exposed: n
type: (OrderedSet,F:Field)->Join(DivisionRing,etc)
params: (VAR,F)
abbrev: FDALG
comment:
The elements of the Free Field are represented by Admissible Linear Systems (ALS) in standard form ...


kind: d
name: FreeGroup
exposed: n
type: (SetCategory)->Join(Group,etc)
params: (S)
abbrev: FGROUP
comment:
The free group on a set \spad{S} is the group of finite products of the form \spad{reduce(*,{} [\spad{si} ^ \spad{ni}])} where the \spad{si}\spad{'s} are in \spad{S},{} and the \spad{ni}\spad{'s} are integers. The multiplication is not commutative.


kind: d
name: FreeMagma
exposed: n
type: (OrderedSet)->Join(OrderedSet,etc)
params: (VarSet)
abbrev: FMAGMA
comment:
This type is the basic representation of parenthesized words (binary trees over arbitrary symbols) useful in \spadtype{LiePolynomial}. \newline Author: Michel Petitot (petitot@lifl.\spad{fr}).


kind: d
name: FreeModule
exposed: n
type: (Join(SemiRng,etc),S:SetCategory)->Join(BiModule(R,R),etc)
params: (R,S)
abbrev: FM
comment:
A \spad{bi}-module is a free module over a ring with generators indexed by an ordered set. Each element can be expressed as a finite linear combination of generators. Only non-zero terms are stored. old domain \spad{FreeModule1} was merged to it in May 2009 The description of the latter: \indented{2}{This domain implements linear combinations} \indented{2}{of elements from the domain \spad{S} with coefficients} \indented{2}{in the domain \spad{R} where \spad{S} is an ordered set} \indented{2}{and \spad{R} is a ring (which may be non-commutative).} \indented{2}{This domain is used by domains of non-commutative algebra such as:} \indented{6}{\spadtype{XDistributedPolynomial},{}} \indented{6}{\spadtype{XRecursivePolynomial}.} \indented{2}{Author: Michel Petitot (petitot@lifl.\spad{fr})}


kind: d
name: FreeMonoid
exposed: n
type: (SetCategory)->Join(Monoid,etc)
params: (S)
abbrev: FMONOID
comment:
The free monoid on a set \spad{S} is the monoid of finite products of the form \spad{reduce(*,{} [\spad{si} ^ \spad{ni}])} where the \spad{si}\spad{'s} are in \spad{S},{} and the \spad{ni}\spad{'s} are nonnegative integers. The multiplication is not commutative. When \spad{S} is an OrderedSet,{} then FreeMonoid(\spad{S}) has order: for two elements \spad{x} and \spad{y} the relation \spad{x < y} holds if either \spad{length(x) < length(y)} holds or if these lengths are equal and if \spad{x} is smaller than \spad{y} \spad{w}.\spad{r}.\spad{t}. the lexicographical ordering induced by \spad{S}.


kind: d
name: FreeNilpotentLie
exposed: x
type: (NonNegativeInteger,NonNegativeInteger,R:CommutativeRing)->Join(NonAssociativeAlgebra(R),etc)
params: (n,class,R)
abbrev: FNLA
comment:
Generate the Free Lie Algebra over a ring \spad{R} with identity; A \spad{P}. Hall basis is generated by a package call to HallBasis.


kind: d
name: GeneralDistributedMultivariatePolynomial
exposed: n
params: (vl,R,E)
abbrev: GDMP
type:
(vl:List(Symbol),R:Ring,E:DirectProductCategory(#(vl),NonNegativeInteger))->Join(PolynomialCategory(R,E,OrderedVariableList(vl)),etc)

comment:
\indented{2}{This type supports distributed multivariate polynomials} whose variables are from a user specified list of symbols. The coefficient ring may be non commutative,{} but the variables are assumed to commute. The term ordering is specified by its third parameter. Suggested types which define term orderings include: \spadtype{DirectProduct},{} \spadtype{HomogeneousDirectProduct},{} \spadtype{SplitHomogeneousDirectProduct} and finally \spadtype{OrderedDirectProduct} which accepts an arbitrary user function to define a term ordering.


kind: d
name: GeneralizedUnivariatePowerSeries
exposed: n
params: (Coef,Expon,var,cen)
abbrev: GENUSER
comment: Domain for univariate power series with variable \indented{1}{coefficients.}
type:
(Coef:Ring,Expon:Join(OrderedAbelianMonoid,etc),Symbol,Coef)->Join(UnivariatePowerSeriesCategory(Coef,Expon),etc)


kind: d
name: GeneralModulePolynomial
exposed: n
params: (vl,R,IS,E,ff,P)
abbrev: GMODPOL
comment: This package \undocumented
type:
(vl:List(Symbol),R:CommutativeRing,IS:OrderedSet,E:DirectProductCategory(#(vl),NonNegativeInteger),ff:(Record(index:IS,exponent:E),Record(index:IS,exponent:E))->Boolean,P:PolynomialCategory(R,E,OrderedVariableList(vl)))->Join(Module(P),etc)


kind: d
name: GeneralPolynomialSet
exposed: n
params: (R,E,VarSet,P)
abbrev: GPOLSET
comment: A domain for polynomial sets.
type:
(R:Ring,E:OrderedAbelianMonoidSup,VarSet:OrderedSet,P:RecursivePolynomialCategory(R,E,VarSet))->Join(PolynomialSetCategory(R,E,VarSet,P),etc)


kind: d
name: GeneralQuaternion
exposed: n
type: (R:CommutativeRing,R,R)->QuaternionCategory(R)
params: (R,p,q)
abbrev: QUAT2
comment:
\spadtype{GeneralQuaternion} implements general quaternions \indented{2}{over a commutative ring. The main constructor function is} \indented{2}{\spadfun{quatern} which takes 4 arguments: the real part,{}} \indented{2}{the \spad{i} imaginary part,{} the \spad{j} imaginary part and the \spad{k} imaginary part.}


kind: d
name: GeneralSparseTable
exposed: n
type: (Key:SetCategory,Entry:BasicType,TableAggregate(Key,Entry),Entry)->TableAggregate(Key,Entry)
params: (Key,Entry,Tbl,dent)
abbrev: GSTBL
comment:
A sparse table has a default entry,{} which is returned if no other value has been explicitly stored for a key.


kind: d
name: GeneralTriangularSet
exposed: n
params: (R,E,V,P)
abbrev: GTSET
type:
(R:IntegralDomain,E:OrderedAbelianMonoidSup,V:OrderedSet,P:RecursivePolynomialCategory(R,E,V))->TriangularSetCategory(R,E,V,P)

comment:
A domain constructor of the category \spadtype{TriangularSetCategory}. The only requirement for a list of polynomials to be a member of such a domain is the following: no polynomial is constant and two distinct polynomials have distinct main variables. Such a triangular set may not be auto-reduced or consistent. Triangular sets are stored as sorted lists \spad{w}.\spad{r}.\spad{t}. the main variables of their members but they are displayed in reverse order.\newline


kind: d
name: GeneralUnivariatePowerSeries
exposed: x
type: (Coef:Ring,var:Symbol,cen:Coef)->Join(UnivariatePuiseuxSeriesCategory(Coef),etc)
params: (Coef,var,cen)
abbrev: GSERIES
comment:
This is a category of univariate Puiseux series constructed from univariate Laurent series. A Puiseux series is represented by a pair \spad{[r,{} f(x)]},{} where \spad{r} is a positive rational number and \spad{f(x)} is a Laurent series. This pair represents the Puiseux series \spad{f(x\^r)}.


kind: d
name: GenericNonAssociativeAlgebra
exposed: n
params: (R,n,ls,gamma)
abbrev: GCNAALG
type:
(R:CommutativeRing,n:PositiveInteger,List(Symbol),Vector(Matrix(R)))->Join(FramedNonAssociativeAlgebra(Fraction(Polynomial(R))),etc)

comment:
AlgebraGenericElementPackage allows you to create generic elements of an algebra,{} \spadignore{i.e.} the scalars are extended to include symbolic coefficients


kind: d
name: GraphImage
exposed: n
type: ()->Join(SetCategory,etc)
abbrev: GRIMAGE
comment:
TwoDimensionalGraph creates virtual two dimensional graphs (to be displayed on TwoDimensionalViewports).


kind: d
name: GroupPresentation
exposed: n
type: ()->Join(SetCategory,etc)
abbrev: GROUPP
comment:
\indented{2}{Group represented by its generators and relations.} \indented{2}{Here we use it to hold homotopy group such as fundamental group.} \indented{2}{for more documentation see:} \indented{2}{http://www.euclideanspace.com/prog/scratchpad/mycode/discrete/finiteGroup/presentation/} Date Created: Jan 2016 Basic Operations: Related packages: Related categories: Related Domains: PermutationGroup Also See: AMS Classifications:


kind: d
name: GuessOptionFunctions0
exposed: n
type: ()->Join(SetCategory,etc)
abbrev: GOPT0
comment:
\spad{GuessOptionFunctions0} provides operations that extract the values of options for \spadtype{Guess}.


kind: d
name: HashTable
exposed: n
type: (SetCategory,Entry:Type,String)->Join(TableAggregate(Key,Entry),etc)
params: (Key,Entry,hashfn)
abbrev: HASHTBL
comment:
This domain provides access to the underlying Lisp hash tables. By varying the hashfn parameter,{} tables suited for different purposes can be obtained.


kind: d
name: HomogeneousDirectProduct
exposed: n
type: (NonNegativeInteger,S:OrderedAbelianMonoid)->DirectProductCategory(dim,S)
params: (dim,S)
abbrev: HDP
comment:
\indented{2}{This type represents the finite direct or cartesian product of an} underlying ordered component type. The vectors are ordered first by the sum of their components,{} and then refined using a reverse lexicographic ordering. This type is a suitable third argument for \spadtype{GeneralDistributedMultivariatePolynomial}.


kind: d
name: HomogeneousDistributedMultivariatePolynomial
exposed: n
params: (vl,R)
abbrev: HDMP
type:
(List(Symbol),R:Ring)->Join(PolynomialCategory(R,HomogeneousDirectProduct(#(vl),NonNegativeInteger),OrderedVariableList(vl)),etc)

comment:
\indented{2}{This type supports distributed multivariate polynomials} whose variables are from a user specified list of symbols. The coefficient ring may be non commutative,{} but the variables are assumed to commute. The term ordering is total degree ordering refined by reverse lexicographic ordering with respect to the position that the variables appear in the list of variables parameter.


kind: d
name: Homology
exposed: n
type: ()->Join(SetCategory,etc)
abbrev: HOMOL
comment:
\indented{2}{Intended to hold homology which is calculated using SmithNormalForm:} \indented{2}{http://www.euclideanspace.com/prog/scratchpad/mycode/topology/homology/} Date Created: June 2016 Basic Operations: Related packages: Related categories: Related Domains: FreeModule,{} FiniteSimplicialComplex Also See: AMS Classifications:


kind: d
name: HyperellipticFiniteDivisor
exposed: n
params: (F,UP,UPUP,R)
abbrev: HELLFDIV
type:
(F:Field,UP:UnivariatePolynomialCategory(F),UPUP:UnivariatePolynomialCategory(Fraction(UP)),R:FunctionFieldCategory(F,UP,UPUP))->FiniteDivisorCategory(F,UP,UPUP,R)

comment:
This domains implements finite rational divisors on an hyperelliptic curve,{} that is finite formal sums SUM(\spad{n} * \spad{P}) where the \spad{n}\spad{'s} are integers and the \spad{P}\spad{'s} are finite rational points on the curve. The equation of the curve must be \spad{y^2} = \spad{f}(\spad{x}) and \spad{f} must have odd degree.


kind: d
name: I16Matrix
exposed: n
type: ()->MatrixCategory(Integer,I16Vector,I16Vector)
abbrev: I16MAT
comment:
This is a low-level domain which implements matrices (two dimensional arrays) of 16-bit signed integers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).


kind: d
name: I16Vector
exposed: n
type: ()->OneDimensionalArrayAggregate(Integer)
abbrev: I16VEC
comment:
This is a low-level domain which implements vectors (one dimensional arrays) of signed 16-bit numbers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).


kind: d
name: I32Matrix
exposed: n
type: ()->MatrixCategory(Integer,I32Vector,I32Vector)
abbrev: I32MAT
comment:
This is a low-level domain which implements matrices (two dimensional arrays) of signed 32-bit integers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).


kind: d
name: I32Vector
exposed: n
type: ()->OneDimensionalArrayAggregate(Integer)
abbrev: I32VEC
comment:
This is a low-level domain which implements vectors (one dimensional arrays) of signed 32-bit numbers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).


kind: d
name: I8Matrix
exposed: n
type: ()->MatrixCategory(Integer,I8Vector,I8Vector)
abbrev: I8MAT
comment:
This is a low-level domain which implements matrices (two dimensional arrays) of 8-bit signed integers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).


kind: d
name: I8Vector
exposed: n
type: ()->OneDimensionalArrayAggregate(Integer)
abbrev: I8VEC
comment:
This is a low-level domain which implements vectors (one dimensional arrays) of signed 8-bit numbers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).


kind: d
name: IndexedDirectProductObject
exposed: n
type: (SetCategory,S:SetCategory)->Join(IndexedDirectProductCategory(A,S),etc)
params: (A,S)
abbrev: IDPO
comment:
Indexed direct products of objects over a set \spad{A} of generators indexed by an ordered set \spad{S}. It currently provides the ground for,{} \spadignore{e.g.} \spadtype{FreeModule} which lies at the basis of polynomials of all sorts. All items have finite support. If A is a monoid,{} then only non-zero terms are stored. If A has additive structure,{} it is propagated coordinatewise to the product. Similarly,{} comparisons are propagated using lexicographic ordering.


kind: d
name: IndexedExponents
exposed: n
type: (OrderedSet)->Join(OrderedAbelianMonoidSup,etc)
params: (Varset)
abbrev: INDE
comment:
\indented{2}{IndexedExponents of an ordered set of variables gives a representation} for the degree of polynomials in commuting variables. It gives an ordered pairing of non negative integer exponents with variables


kind: d
name: IndexedJetBundle
exposed: n
type: (Symbol,Symbol,Symbol,PositiveInteger,PositiveInteger)->JetBundleCategory
params: (x,u,p,n,m)
abbrev: IJB
comment:
\spadtype{JetBundle} provides the standard implementation for a jet bundle with a given number of dependent and independent variables.


kind: d
name: IndexedList
exposed: n
type: (Type,Integer)->ListAggregate(S)
params: (S,mn)
abbrev: ILIST
comment:
\spadtype{IndexedList} is an implementation of \spadtype{ListAggregate},{} the beginning index of the list is the second parameter to the constructor (\spad{mn}). That is,{} if \spad{l} is a list,{} then \spad{elt(l,{} mn)} is the first value.


kind: d
name: IndexedMatrix
exposed: n
params: (R,mnRow,mnCol)
abbrev: IMATRIX
type:
(AbelianMonoid,mnRow:Integer,mnCol:Integer)->MatrixCategory(R,IndexedVector(R,mnCol),IndexedVector(R,mnRow))

comment:
An \spad{IndexedMatrix} is a matrix where the minimal row and column indices are parameters of the type. The domains Row and Col are both IndexedVectors. The index of the 'first' row may be obtained by calling the function \spadfun{minRowIndex}. The index of the 'first' column may be obtained by calling the function \spadfun{minColIndex}. The index of the first element of a 'Row' is the same as the index of the first column in a matrix and vice versa.


kind: d
name: IndexedTwoDimensionalArray
exposed: n
params: (R,mnRow,mnCol)
abbrev: IARRAY2
type:
(Type,mnRow:Integer,mnCol:Integer)->TwoDimensionalArrayCategory(R,IndexedOneDimensionalArray(R,mnCol),IndexedOneDimensionalArray(R,mnRow))

comment:
\indented{1}{An IndexedTwoDimensionalArray is a 2-dimensional array where} the minimal row and column indices are parameters of the type. Rows and columns are returned as IndexedOneDimensionalArray\spad{'s} with minimal indices matching those of the IndexedTwoDimensionalArray. The index of the 'first' row may be obtained by calling the function 'minRowIndex'. The index of the 'first' column may be obtained by calling the function 'minColIndex'. The index of the first element of a 'Row' is the same as the index of the first column in an array and vice versa.


kind: d
name: IndexedVector
exposed: n
type: (Type,Integer)->VectorCategory(R)
params: (R,mn)
abbrev: IVECTOR
comment:
\indented{2}{This type represents vector like objects with varying lengths} and a user-specified initial index.


kind: d
name: InfiniteTuple
exposed: x
type: (Type)->Join(CoercibleTo(OutputForm),etc)
params: (S)
abbrev: ITUPLE
comment:
\indented{1}{This package implements 'infinite tuples' for the interpreter.} The representation is a stream.


kind: d
name: InnerFiniteField
exposed: n
type: (PositiveInteger,PositiveInteger)->FiniteAlgebraicExtensionField(InnerPrimeField(p))
params: (p,n)
abbrev: IFF
comment:
InnerFiniteField(\spad{p},{} \spad{n}) implements finite fields with \spad{p^n} elements where \spad{p} is assumed prime but does not check. For a version which checks that \spad{p} is prime,{} see \spadtype{FiniteField}.


kind: d
name: InnerIndexedTwoDimensionalArray
exposed: n
params: (R,mnRow,mnCol,Row,Col)
abbrev: IIARRAY2
type:
(R:Type,Integer,Integer,Row:FiniteLinearAggregate(R),Col:FiniteLinearAggregate(R))->TwoDimensionalArrayCategory(R,Row,Col)

comment:
\indented{1}{This is an internal type which provides an implementation of} 2-dimensional arrays as PrimitiveArray\spad{'s} of PrimitiveArray\spad{'s}.


kind: d
name: InnerPAdicInteger
exposed: n
type: (Integer,Boolean)->PAdicIntegerCategory(p)
params: (p,unBalanced?)
abbrev: IPADIC
comment:
This domain implements \spad{Zp},{} the \spad{p}-adic completion of the integers. This is an internal domain.


kind: d
name: InnerPrimeField
exposed: n
type: (PositiveInteger)->Join(FiniteFieldCategory,etc)
params: (p)
abbrev: IPF
comment:
InnerPrimeField(\spad{p}) implements the field with \spad{p} elements by using IntegerMod \spad{p}. Note: argument \spad{p} MUST be a prime (this domain does not check). See \spadtype{PrimeField} for a domain that does check. In addition to the inherited operations of IntegerMod \spad{p},{} the domain provides exploits the structure of the cyclic group of its invertible elements. It stores a primitive element \spad{w},{} \spad{i}.a. generator of this group and it stores a logarithm table for \spad{w} as soon as this is required. sqrt was added in 2018.


kind: d
name: InnerSparseUnivariatePowerSeries
exposed: n
type: (Ring)->Join(UnivariatePowerSeriesCategory(Coef,Integer),etc)
params: (Coef)
abbrev: ISUPS
comment:
InnerSparseUnivariatePowerSeries is an internal domain \indented{2}{used for creating sparse Taylor and Laurent series.}


kind: d
name: InnerTable
exposed: n
params: (Key,Entry,addDom)
abbrev: INTABL
comment: This domain is used to provide a conditional add domain for the implementation of \spadtype{Table}.
type:
(Key:SetCategory,Entry:Type,Join(TableAggregate(Key,Entry),etc))->Join(TableAggregate(Key,Entry),etc)


kind: d
name: InnerTaylorSeries
exposed: n
type: (Ring)->Join(Ring,etc)
params: (Coef)
abbrev: ITAYLOR
comment:
Internal package for dense Taylor series. This is an internal Taylor series type in which Taylor series are represented by a \spadtype{Stream} of \spadtype{Ring} elements. For univariate series,{} the \spad{Stream} elements are the Taylor coefficients. For multivariate series,{} the \spad{n}th Stream element is a form of degree \spad{n} in the power series variables.


kind: d
name: InputForm
exposed: n
type: ()->Join(SExpressionCategory(String,Symbol,Integer,DoubleFloat),etc)
abbrev: INFORM
comment:
Domain of parsed forms which can be passed to the interpreter. This is also the interface between algebra code and facilities in the interpreter.


kind: d
name: IntegerLocalizedAtPrime
exposed: n
type: (PositiveInteger)->Join(EuclideanDomain,etc)
params: (p)
abbrev: INTLOCP
comment:
IntegerLocalizedAtPrime(\spad{p}) represents the Euclidean domain of integers localized at a prime \spad{p},{} \spadignore{i.e.} the set of rational numbers whose denominator is not divisible by \spad{p}.


kind: d
name: IntegrationResult
exposed: n
type: (Field)->Join(Module(Fraction(Integer)),etc)
params: (F)
abbrev: IR
comment:
If a function \spad{f} has an elementary integral \spad{g},{} then \spad{g} can be written in the form \spad{g = h + c1 log(u1) + c2 log(u2) + ... + cn log(un)} where \spad{h},{} which is in the same field as \spad{f},{} is called the rational part of the integral,{} and \spad{c1 log(u1) + ... cn log(un)} is called the logarithmic part of the integral. This domain manipulates integrals represented in that form,{} by keeping both parts separately. The logs are not explicitly computed.


kind: d
name: Interval
exposed: x
type: (Join(FloatingPointSystem,etc))->IntervalCategory(R)
params: (R)
abbrev: INTRVL
comment:
\indented{1}{+ Author: Mike Dewar} + Date Created: November 1996 + Basic Functions: + Related Constructors: + Also See: + AMS Classifications: + Keywords: + References: + Description: + This domain is an implementation of interval arithmetic and transcendental + functions over intervals.


kind: d
name: JetBundle
exposed: n
type: (List(Symbol),List(Symbol))->Join(JetBundleCategory,etc)
params: (IVar,DVar)
abbrev: JBUNDLE
comment:
\spad{JetBundle} implements a jet bundle of arbitrary order with given names for the independent and dependent variables. It supports only repeated index notation.


kind: d
name: JetBundleExpression
exposed: n
type: (JetBundleCategory)->Join(JetBundleFunctionCategory(JB),etc)
params: (JB)
abbrev: JBE
comment:
\spadtype{JetBundleExpression} defines expressions over a jet bundle based on \spadtype{Expression Integer}. It allows all kind of algebraic operations. \spad{simplify} is implemented using Groebner bases in polynomials over kernels. Thus it might not work correctly for general expressions. This also affects \spad{dimension}.


kind: d
name: JetBundleLinearFunction
exposed: n
type: (JB:JetBundleCategory,D:JetBundleBaseFunctionCategory(JB))->Join(JetBundleFunctionCategory(JB),etc)
params: (JB,D)
abbrev: JBLF
comment:
\spadtype{JetBundleLinearFunction} implements linear functions over a jet bundle. The coefficients are functions of the independent variables only.


kind: d
name: JetBundlePolynomial
exposed: n
type: (Ring,JB:JetBundleCategory)->Join(JetBundleFunctionCategory(JB),etc)
params: (R,JB)
abbrev: JBP
comment:
\spadtype{JetBundlePolynomial} implements polynomial sections over a jet bundle. The order is not fixed,{} thus jet variables of any order can appear.


kind: d
name: JetBundleSymAna
exposed: n
params: (JB1,xi,eta)
abbrev: JBSA
type:
(JetBundleCategory,Union(Symbol,List(Symbol)),Union(Symbol,List(Symbol)))->Join(JetBundleCategory,etc)

comment:
\spad{JetBundleSymAna} is only necessary to have a valid return type for some procedures in \spad{SymmetryAnalysis}. It is essentially identical with \spad{JetBundle} but computes its parameters in a more complicated way.


kind: d
name: JetBundleXExpression
exposed: n
type: (JetBundleCategory)->Join(JetBundleFunctionCategory(JB),etc)
params: (JB)
abbrev: JBX
comment:
\spadtype{JetBundleXExpression} implements arbitrary functions in a jet bundle which depend only on the independent variables \spad{x}. Otherwise it is identical with \spadtype{JetBundleExpression}. Such a domain is needed for \spadtype{JetLinearFunction}.


kind: d
name: JetDifferential
exposed: n
type: (JB:JetBundleCategory,D:JetBundleFunctionCategory(JB))->Join(Module(D),etc)
params: (JB,D)
abbrev: JDIFF
comment:
\spad{JetDifferential(JB,{} D)} implements differentials (one-forms) \indented{1}{over the jet bundle \spad{JB} with coefficients from \spad{D}.} \indented{1}{The differentials operate on \spad{JetVectorField(JB,{} D)}.}


kind: d
name: JetDifferentialEquation
exposed: n
type: (JB:JetBundleCategory,D:JetBundleFunctionCategory(JB))->etc
params: (JB,D)
abbrev: JDE
comment:
\spadtype{JetDifferentialEquation} provides the basic data structures and procedures for differential equations as needed in the geometric theory. Differential equation means here always a submanifold in the jet bundle. The concrete equations which define this submanifold are called system. In an object of the type \spadtype{JetDifferentialEquation} much more than only the system is stored. \spad{D} denotes the class of functions allowed as equations. It is assumed that the \spad{simplify} procedure of \spad{D} returns only independent equations and a system with symbol in row echelon form.


kind: d
name: JetLazyFunction
exposed: n
type: (JB:JetBundleCategory,D:JetBundleFunctionCategory(JB))->Join(JetBundleFunctionCategory(JB),etc)
params: (JB,D)
abbrev: JLF
comment:
\spadtype{JetLazyFunction} takes as argument a domain in \spadtype{JetBundleFunctionCategory} and returns another domain in the same category. This domain has basically the same properties as the argument domain,{} but there is a lazy evaluation mechanism for derivatives. This means that differentiations are not immediately performed. Instead a pointer is established to the function to be differentiated. Only when the exact value of the derivative is needed,{} the differentiation is executed. Special care is taken for leading derivatives and jet variables to avoid as much as possible the need to evaluate expressions. This entails that the result of \spad{jetVariables} may contain spurious variables. Furthermore many functions in \spadtype{JetLazyFunction} destructively change their arguments. This affects,{} however,{} only their internal representation,{} not the value obtained after full evaluation.


kind: d
name: JetVectorField
exposed: n
type: (JB:JetBundleCategory,D:JetBundleFunctionCategory(JB))->Join(Module(D),etc)
params: (JB,D)
abbrev: JVF
comment:
\spad{JetVectorField(JB,{} D)} implements vector fields over the jet bundle \spad{JB} with coefficients from \spad{D}. The fields operate on functions from \spad{D}.


kind: d
name: LieExponentials
exposed: n
type: (OrderedSet,R:Join(CommutativeRing,etc),PositiveInteger)->Join(Group,etc)
params: (VarSet,R,Order)
abbrev: LEXP
comment:
Management of the Lie Group associated with a free nilpotent Lie algebra. Every Lie bracket with length greater than \spad{Order} are assumed to be null. The implementation inherits from the \spadtype{XPBWPolynomial} domain constructor: Lyndon coordinates are exponential coordinates of the second kind. \newline Author: Michel Petitot (petitot@lifl.\spad{fr}).


kind: d
name: LiePolynomial
exposed: n
type: (OrderedSet,R:CommutativeRing)->Join(FreeLieAlgebra(VarSet,R),etc)
params: (VarSet,R)
abbrev: LPOLY
comment:
This type supports Lie polynomials in Lyndon basis see Free Lie Algebras by \spad{C}. Reutenauer (Oxford science publications). \newline Author: Michel Petitot (petitot@lifl.\spad{fr}).


kind: d
name: LieSquareMatrix
exposed: x
type: (PositiveInteger,R:CommutativeRing)->Join(CoercibleTo(SquareMatrix(n,R)),etc)
params: (n,R)
abbrev: LSQM
comment:
LieSquareMatrix(\spad{n},{} \spad{R}) implements the Lie algebra of the \spad{n} by \spad{n} matrices over the commutative ring \spad{R}. The Lie bracket (commutator) of the algebra is given by \spad{a*b := (a *\$SQMATRIX(n,{} R) b - b *\$SQMATRIX(n,{} R) a)},{} where \spadfun{*\$SQMATRIX(\spad{n},{} \spad{R})} is the usual matrix multiplication.


kind: d
name: LinearOrdinaryDifferentialOperator1
exposed: n
type: (DifferentialRing)->LinearOrdinaryDifferentialOperatorCategory(A)
params: (A)
abbrev: LODO1
comment:
\spad{LinearOrdinaryDifferentialOperator1} defines a ring of differential operators with coefficients in a differential ring A. Multiplication of operators corresponds to functional composition: \indented{4}{\spad{(L1 * L2).(f) = L1 L2 f}}


kind: d
name: LinearOrdinaryDifferentialOperator2
exposed: n
params: (A,M)
abbrev: LODO2
type:
(A:DifferentialRing,M:Join(LeftModule(A),etc))->Join(LinearOrdinaryDifferentialOperatorCategory(A),etc)

comment:
\spad{LinearOrdinaryDifferentialOperator2} defines a ring of differential operators with coefficients in a differential ring A and acting on an A-module \spad{M}. Multiplication of operators corresponds to functional composition: \indented{4}{\spad{(L1 * L2).(f) = L1 L2 f}}


kind: d
name: LinearOrdinaryDifferentialOperator
exposed: x
type: (A:Ring,(A)->A)->LinearOrdinaryDifferentialOperatorCategory(A)
params: (A,diff)
abbrev: LODO
comment:
\spad{LinearOrdinaryDifferentialOperator} defines a ring of differential operators with coefficients in a ring A with a given derivation. Multiplication of operators corresponds to functional composition: \indented{4}{\spad{(L1 * L2).(f) = L1 L2 f}}


kind: d
name: LinearOrdinaryDifferentialOperator3
exposed: n
params: (Coeff,A,R)
abbrev: LODO3
type:
(Coeff:Ring,A:AbelianMonoidRing(Coeff,NonNegativeInteger),R:Join(DifferentialRing,etc))->LinearOrdinaryDifferentialOperatorCategory(R)

comment:
\spad{LinearOrdinaryDifferentialOperator3} is a ring \indented{1}{differential operators with coefficients in a differential ring \spad{R}.} \indented{1}{Basic derivative is derivative in \spad{R} times variable (monomial} \indented{1}{of degree 1).}


kind: d
name: List
exposed: x
type: (Type)->Join(ListAggregate(S),etc)
params: (S)
abbrev: LIST
comment:
\spadtype{List} implements singly-linked lists that are addressable by indices; the index of the first element is 1. In addition to the operations provided by \spadtype{ListAggregate},{} this constructor provides some LISP-like functions such as \spadfun{cons} and \spadfun{append}.


kind: d
name: ListMonoidOps
exposed: n
type: (SetCategory,E:AbelianMonoid,E)->Join(SetCategory,etc)
params: (S,E,un)
abbrev: LMOPS
comment:
This internal package represents monoid (abelian or not,{} with or without inverses) as lists and provides some common operations to the various flavors of monoids.


kind: d
name: ListMultiDictionary
exposed: n
type: (SetCategory)->Join(MultiDictionary(S),etc)
params: (S)
abbrev: LMDICT
comment:
The \spadtype{ListMultiDictionary} domain implements a dictionary with duplicates allowed. The representation is a list with duplicates represented explicitly. Hence most operations will be relatively inefficient when the number of entries in the dictionary becomes large. If the objects in the dictionary belong to an ordered set,{} the entries are maintained in ascending order.


kind: d
name: LocalAlgebra
exposed: n
type: (Algebra(R),R:CommutativeRing)->Join(Algebra(R),etc)
params: (A,R)
abbrev: LA
comment:
LocalAlgebra produces the localization of an algebra,{} \spadignore{i.e.} fractions whose numerators come from some \spad{R} algebra.


kind: d
name: Localize
exposed: n
type: (Module(R),R:CommutativeRing)->Join(Module(R),etc)
params: (M,R)
abbrev: LO
comment:
Localize(\spad{M},{} \spad{R}) produces fractions with numerators from an \spad{R} module \spad{M} and denominators being the nonzero elements of \spad{R}.


kind: d
name: Loop
exposed: n
type: ()->Join(SetCategory,etc)
abbrev: LOOP
comment:
This is used with graph theory code (FiniteGraph,{} DirectedGraph. FunctionGraph,{} and so on) to represent a loop as either a sequence of vertex or arrow indexes depending on context. The main benefit is that the loop is stored in a canonical way so that loops can be quickly compared using \spad{'='}.


kind: d
name: LyndonWord
exposed: n
type: (OrderedSet)->Join(OrderedSet,etc)
params: (VarSet)
abbrev: LWORD
comment:
Lyndon words over arbitrary (ordered) symbols: see Free Lie Algebras by \spad{C}. Reutenauer (Oxford science publications). A Lyndon word is a word which is smaller than any of its right factors \spad{w}.\spad{r}.\spad{t}. the pure lexicographical ordering. If \spad{a} and \spad{b} are two Lyndon words such that \spad{a < b} holds \spad{w}.\spad{r}.\spad{t} lexicographical ordering then \spad{a*b} is a Lyndon word. Parenthesized Lyndon words can be generated from symbols by using the following rule: \spad{[[a,{} b],{} c]} is a Lyndon word iff \spad{a*b < c <= b} holds. Lyndon words are internally represented by binary trees using the \spadtype{FreeMagma} domain constructor. Two ordering are provided: lexicographic and length-lexicographic. \newline Author : Michel Petitot (petitot@lifl.\spad{fr}).


kind: d
name: Mapping
exposed: x
type: special
params: (T,S)
abbrev: MAPPING
comment:
\spad{Mapping(T,S)} is a primitive type in FriCAS used to represent mappings from source type \spad{S} to target type \spad{T}. Similarly, \spad{Mapping(T,A,B)} denotes a mapping from source type \spad{(A,B)} to target type \spad{T}.


kind: d
name: ModMonic
exposed: n
type: (R:Ring,Rep:UnivariatePolynomialCategory(R))->Join(Ring,etc)
params: (R,Rep)
abbrev: MODMON
comment:
This domain implements quotient of ring of univariate polynomials by ideal generated by modulus polynomial. Modulus must be monic. Before performing any operations you need to set modulus,{} subsequent operations use this modulus.


kind: d
name: ModularAlgebraicGcdTools2
exposed: n
abbrev: MAGCDT2
type:
()->ModularAlgebraicGcdOperations(Polynomial(Integer),PrimitiveArray(U32Vector),Record(svz:Symbol,sm:U32Vector,sp:Integer))


kind: d
name: ModularAlgebraicGcdTools3
exposed: n
abbrev: MAGCDT3
type:
()->Join(ModularAlgebraicGcdOperations(Polynomial(Integer),SparseUnivariatePolynomial(Polynomial(Integer)),Record(svz:List(Symbol),sm:List(Polynomial(Integer)),msizes:List(Integer),sp:Integer)),etc)


kind: d
name: ModularAlgebraicGcdTools4
exposed: n
abbrev: MAGCDT4
type:
()->ModularAlgebraicGcdOperations(FakePolynomial,SparseUnivariatePolynomial(Polynomial(Integer)),Record(svz:List(Symbol),sm:List(Polynomial(Integer)),msizes:List(Integer),sp:Integer))


kind: d
name: ModularEvaluation2
exposed: n
abbrev: MEVAL2
type:
()->ModularEvaluationCategory(Record(var:Symbol,coef:SparseUnivariatePolynomial(Fraction(Polynomial(Integer)))),FakePolynomial)


kind: d
name: ModularFactorizationTools1
exposed: n
abbrev: MODFT1
type:
()->ModularFactorizationOperations(U32Vector,U32Matrix,Integer,List(Record(ind:NonNegativeInteger,poly:U32Vector)))


kind: d
name: ModularFactorizationTools3
exposed: n
params: (K)
abbrev: MODFT3
type:
(FiniteFieldCategory)->Join(ModularFactorizationOperations(PrimitiveArray(K),PrimitiveTwoDimensionalArray(K),Record(i_mod:Integer,deg:Integer),Record(mod_data:Record(i_mod:Integer,deg:Integer),p_mod:PrimitiveArray(K))),etc)


kind: d
name: ModularField
exposed: n
params: (R,Mod,reduction,merge,exactQuo)
abbrev: MODFIELD
type:
(R:CommutativeRing,Mod:AbelianMonoid,(R,Mod)->R,(Mod,Mod)->Union(Mod,failed),(R,R,Mod)->Union(R,failed))->Join(Field,etc)

comment:
\indented{1}{These domains are used for the factorization and gcds} of univariate polynomials over the integers in order to work modulo different primes. See \spadtype{ModularRing},{} \spadtype{EuclideanModularRing}


kind: d
name: ModularRing
exposed: n
params: (R,Mod,reduction,merge,exactQuo)
abbrev: MODRING
type:
(R:CommutativeRing,Mod:AbelianMonoid,(R,Mod)->R,(Mod,Mod)->Union(Mod,failed),(R,R,Mod)->Union(R,failed))->Join(Ring,etc)

comment:
These domains are used for the factorization and gcds of univariate polynomials over the integers in order to work modulo different primes. See \spadtype{EuclideanModularRing} ,{} \spadtype{ModularField}


kind: d
name: ModuleMonomial
exposed: n
params: (IS,E,ff)
abbrev: MODMONOM
comment: This package \undocumented
type:
(IS:OrderedSet,E:SetCategory,(Record(index:IS,exponent:E),Record(index:IS,exponent:E))->Boolean)->Join(OrderedSet,etc)


kind: d
name: MoebiusTransform
exposed: n
type: (Field)->Join(Group,etc)
params: (F)
abbrev: MOEBIUS
comment:
\indented{1}{MoebiusTransform(\spad{F}) is the domain of fractional linear (Moebius)} transformations over \spad{F}.


kind: d
name: MonoidRing
exposed: n
type: (Ring,M:Monoid)->MonoidRingCategory(R,M)
params: (R,M)
abbrev: MRING
comment:
\spadtype{MonoidRing}(\spad{R},{} \spad{M}),{} implements the algebra of all maps from the monoid \spad{M} to the commutative ring \spad{R} with finite support. Multiplication of two maps \spad{f} and \spad{g} is defined to map an element \spad{c} of \spad{M} to the (convolution) sum over {\em f(a)g(b)} such that {\em ab = c}. Thus \spad{M} can be identified with a canonical basis and the maps can also be considered as formal linear combinations of the elements in \spad{M}. Scalar multiples of a basis element are called monomials. A prominent example is the class of polynomials where the monoid is a direct product of the natural numbers with pointwise addition. When \spad{M} is \spadtype{FreeMonoid Symbol},{} one gets polynomials in infinitely many non-commuting variables. Another application area is representation theory of finite groups \spad{G},{} where modules over \spadtype{MonoidRing}(\spad{R},{} \spad{G}) are studied.


kind: d
name: MultivariatePolynomial
exposed: x
params: (vl,R)
abbrev: MPOLY
type:
(List(Symbol),R:Ring)->PolynomialCategory(R,IndexedExponents(OrderedVariableList(vl)),OrderedVariableList(vl))

comment:
\indented{2}{This type is the basic representation of sparse recursive multivariate} polynomials whose variables are from a user specified list of symbols. The ordering is specified by the position of the variable in the list. The coefficient ring may be non commutative,{} but the variables are assumed to commute.


kind: d
name: NewSparseMultivariatePolynomial
exposed: n
type: (Ring,VarSet:OrderedSet)->Join(RecursivePolynomialCategory(R,IndexedExponents(VarSet),VarSet),etc)
params: (R,VarSet)
abbrev: NSMP
comment:
A post-facto extension for \spadtype{SMP} in order to speed up operations related to pseudo-division and \spad{gcd}. This domain is based on the \spadtype{NSUP} constructor which is itself a post-facto extension of the \spadtype{SUP} constructor.


kind: d
name: NewSparseUnivariatePolynomial
exposed: n
type: (Ring)->Join(UnivariatePolynomialCategory(R),etc)
params: (R)
abbrev: NSUP
comment:
A post-facto extension for \spadtype{SUP} in order to speed up operations related to pseudo-division and \spad{gcd} for both \spadtype{SUP} and,{} consequently,{} \spadtype{NSMP}.


kind: d
name: None
exposed: n
type: ()->SetCategory
abbrev: NONE
comment:
\spadtype{None} implements an universal type,{} that is type which can represent values of any normal type. It is mainly used in technical situations where such a thing is needed (\spadignore{e.g.} the interpreter and some of the internal \spadtype{Expression} code).


kind: d
name: Octonion
exposed: x
type: (CommutativeRing)->Join(OctonionCategory(R),etc)
params: (R)
abbrev: OCT
comment:
Octonion implements octonions (Cayley-Dixon algebra) over a commutative ring,{} an eight-dimensional non-associative algebra,{} doubling the quaternions in the same way as doubling the complex numbers to get the quaternions the main constructor function is {\em octon} which takes 8 arguments: the real part,{} the \spad{i} imaginary part,{} the \spad{j} imaginary part,{} the \spad{k} imaginary part,{} (as with quaternions) and in addition the imaginary parts \spad{E},{} \spad{I},{} \spad{J},{} \spad{K}.


kind: d
name: OpenMathConnection
exposed: x
type: ()->etc
abbrev: OMCONN
comment:
\spadtype{OpenMathConnection} provides low-level functions for handling connections to and from \spadtype{OpenMathDevice}\spad{s}.


kind: d
name: OpenMathDevice
exposed: x
type: ()->etc
abbrev: OMDEV
comment:
\spadtype{OpenMathDevice} provides support for reading and writing openMath objects to files,{} strings etc. It also provides access to low-level operations from within the interpreter.


kind: d
name: OpenMathErrorKind
exposed: x
type: ()->Join(SetCategory,etc)
abbrev: OMERRK
comment:
\spadtype{OpenMathErrorKind} represents different kinds of OpenMath errors: specifically parse errors,{} unknown \spad{CD} or symbol errors,{} and read errors.


kind: d
name: OperatorHandlers
exposed: n
type: (Type)->etc
params: (HANDLER)
abbrev: OPHANDL
comment:
\indented{1}{OperatorHandlers is an auxiliary domain. It is used holds functions} for each operator of \spad{OutputForm},{} classified by the arity and the name of that operator.


kind: d
name: OrderedDirectProduct
exposed: n
params: (dim,S,f)
abbrev: ODP
type:
(NonNegativeInteger,S:OrderedAbelianMonoid,(Vector(S),Vector(S))->Boolean)->DirectProductCategory(dim,S)

comment:
\indented{2}{This type represents the finite direct or cartesian product of an} underlying ordered component type. The ordering on the type is determined by its third argument which represents the less than function on vectors. This type is a suitable third argument for \spadtype{GeneralDistributedMultivariatePolynomial}.


kind: d
name: OrderlyDifferentialPolynomial
exposed: n
params: (R)
abbrev: ODPOL
type:
(Ring)->Join(DifferentialPolynomialCategory(R,Symbol,OrderlyDifferentialVariable(Symbol),IndexedExponents(OrderlyDifferentialVariable(Symbol))),etc)

comment:
\spadtype{OrderlyDifferentialPolynomial} implements an ordinary differential polynomial ring in arbitrary number of differential indeterminates,{} with coefficients in a ring. The ranking on the differential indeterminate is orderly. This is analogous to the domain \spadtype{Polynomial}. \blankline


kind: d
name: OrderlyDifferentialVariable
exposed: n
type: (OrderedSet)->DifferentialVariableCategory(S)
params: (S)
abbrev: ODVAR
comment:
\spadtype{OrderlyDifferentialVariable} adds a commonly used orderly ranking to the set of derivatives of an ordered list of differential indeterminates. An orderly ranking is a ranking \spadfun{<} of the derivatives with the property that for two derivatives \spad{u} and \spad{v},{} \spad{u} \spadfun{<} \spad{v} if the \spadfun{order} of \spad{u} is less than that of \spad{v}. This domain belongs to \spadtype{DifferentialVariableCategory}. It defines \spadfun{weight} to be just \spadfun{order},{} and it defines an orderly ranking \spadfun{<} on derivatives \spad{u} via the lexicographic order on the pair (\spadfun{order}(\spad{u}),{} \spadfun{variable}(\spad{u})).


kind: d
name: OrdinaryDifferentialRing
exposed: x
type: (Kernels:SetCategory,R:PartialDifferentialRing(Kernels),Kernels)->Join(BiModule(%,%),etc)
params: (Kernels,R,var)
abbrev: ODR
comment:
This constructor produces an ordinary differential ring from a partial differential ring by specifying a variable.


kind: d
name: OrdinaryWeightedPolynomials
exposed: n
type: (Ring,List(Symbol),List(NonNegativeInteger),NonNegativeInteger)->Join(Ring,etc)
params: (R,vl,wl,wtlevel)
abbrev: OWP
comment:
This domain represents truncated weighted polynomials over the Polynomial type. The variables must be specified,{} as must the weights. The representation is sparse in the sense that only non-zero terms are represented.


kind: d
name: OrdSetInts
exposed: x
type: ()->Join(OrderedSet,etc)
abbrev: OSI
comment:
A domain used in order to take the free \spad{R}-module on the \indented{1}{Integers \spad{I}.\space{2}This is actually the forgetful functor from OrderedRings} \indented{1}{to OrderedSets applied to \spad{I}.}


kind: d
name: OrientedFacet
exposed: n
type: ()->Join(FacetCategory,etc)
abbrev: OFACET
comment:
\indented{2}{A single vertex,{} edge,{} triangle...} \indented{2}{for more documentation see:} \indented{2}{http://www.euclideanspace.com/prog/scratchpad/mycode/topology/simplex/} Date Created: March 2016 Basic Operations: Related packages: Related categories: FacetCategory Related Domains: Also See: AMS Classifications:


kind: d
name: OutputBox
exposed: n
type: ()->Join(CoercibleTo(OutputForm),etc)
abbrev: OUTBOX
comment:
\indented{1}{The domain \spad{OutputBox} represents the two-dimensional form of} an expression by a number of strings (lines). Such a box has a baseline (at which such boxes will be horizontally aligned,{} a height (size above and including the baseline),{} a depth (size below the baseline),{} and a width (horizontal size).


kind: d
name: OutputForm
exposed: n
type: ()->Join(SetCategory,etc)
abbrev: OUTFORM
comment:
This domain is used to create and manipulate mathematical expressions for output. It is intended to provide an insulating layer between the expression rendering software (\spadignore{e.g.} TeX,{} or Script) and the output coercions in the various domains.


kind: d
name: PAdicInteger
exposed: n
type: (Integer)->PAdicIntegerCategory(p)
params: (p)
abbrev: PADIC
comment:
Stream-based implementation of \spad{Zp:} \spad{p}-adic numbers are represented as sum(\spad{i} = 0..,{} a[\spad{i}] * p^i),{} where the a[\spad{i}] lie in 0,{} 1,{} ...,{} (\spad{p} - 1).


kind: d
name: PAdicRational
exposed: n
type: (Integer)->Join(QuotientFieldCategory(PAdicInteger(p)),etc)
params: (p)
abbrev: PADICRAT
comment:
Stream-based implementation of \spad{Qp:} numbers are represented as sum(\spad{i} = \spad{k}..,{} a[\spad{i}] * p^i) where the a[\spad{i}] lie in 0,{} 1,{} ...,{} (\spad{p} - 1).


kind: d
name: ParametricComplexCurve
exposed: x
type: (Type)->etc
params: (VT)
abbrev: PARCCURV
comment:
ParametricComplexCurve is used for drawing complex \indented{1}{curves on the plane.\space{2}Its main effect is on function selection,{}} \indented{1}{namely introducing \spad{complex_curve} in the middle} \indented{1}{disambiguates between expression defining real function} \indented{1}{(default) and expression defining complex function.}


kind: d
name: PartialDifferentialOperator
exposed: n
params: (R,Var)
abbrev: PDO
type:
(PartialDifferentialRing(Var),Var:OrderedSet)->Join(MultivariateSkewPolynomialCategory(R,IndexedExponents(Var),Var),etc)

comment:
PartialDifferentialOperator(\spad{R},{} \spad{V}) defines a ring of partial differential operators in variables from \spad{V} and with coefficients in a partial differential ring \spad{R}. Multiplication of operators corresponds to composition of operators. \blankline


kind: d
name: PartialFraction
exposed: x
type: (EuclideanDomain)->Join(Field,etc)
params: (R)
abbrev: PFR
comment:
The domain \spadtype{PartialFraction} implements partial fractions over a euclidean domain \spad{R}. This requirement on the argument domain allows us to normalize the fractions. Of particular interest are the 2 forms for these fractions. The


kind: d
name: Partition
exposed: n
type: ()->Join(OrderedCancellationAbelianMonoid,etc)
abbrev: PRTITION
comment:
\indented{1}{Partition is an OrderedCancellationAbelianMonoid which is used} as the basis for symmetric polynomial representation of the sums of powers in SymmetricPolynomial. Thus,{} \spad{(5 2 2 1)} will represent \spad{s5 * s2^2 * s1}.


kind: d
name: PatternMatchListResult
exposed: n
type: (SetCategory,S:SetCategory,L:ListAggregate(S))->Join(SetCategory,etc)
params: (R,S,L)
abbrev: PATLRES
comment:
A PatternMatchListResult is an object internally returned by the pattern matcher when matching on lists. It is either a failed match,{} or a pair of PatternMatchResult,{} one for atoms (elements of the list),{} and one for lists.


kind: d
name: PatternMatchResult
exposed: n
type: (SetCategory,S:SetCategory)->Join(SetCategory,etc)
params: (R,S)
abbrev: PATRES
comment:
A PatternMatchResult is an object internally returned by the pattern matcher; It is either a failed match,{} or a list of matches of the form (var,{} expr) meaning that the variable var matches the expression expr.


kind: d
name: PendantTree
exposed: x
type: (SetCategory)->Join(BinaryRecursiveAggregate(S),etc)
params: (S)
abbrev: PENDTREE
comment:
\indented{1}{A PendantTree(\spad{S}) is either a leaf? and is an \spad{S} or has} a left and a right are both PendantTree(\spad{S}).


kind: d
name: Permutation
exposed: x
type: (SetCategory)->Join(PermutationCategory(S),etc)
params: (S)
abbrev: PERM
comment:
Permutation(\spad{S}) implements the group of all bijections \indented{2}{on a set \spad{S},{} which move only a finite number of points.} \indented{2}{A permutation is considered as a map from \spad{S} into \spad{S}. In particular} \indented{2}{multiplication is defined as composition of maps:} \indented{2}{{\em pi1 * pi2 = pi1 o pi2}.} \indented{2}{The internal representation of permutations are two lists} \indented{2}{of equal length representing preimages and images.}


kind: d
name: PermutationGroup
exposed: x
type: (SetCategory)->Join(SetCategory,etc)
params: (S)
abbrev: PERMGRP
comment:
PermutationGroup implements permutation groups acting on a set \spad{S},{} \spadignore{i.e.} all subgroups of the symmetric group of \spad{S},{} represented as a list of permutations (generators). Note that therefore the objects are not members of the \Language category \spadtype{Group}. Using the idea of base and strong generators by Sims,{} basic routines and algorithms are implemented so that the word problem for permutation groups can be solved.


kind: d
name: PiDomain
exposed: x
type: ()->Join(Field,etc)
abbrev: HACKPI
comment:
\indented{1}{Symbolic fractions in \%\spad{pi} with integer coefficients;} \indented{1}{The point for using PiDomain as the default domain for those fractions} \indented{1}{is that PiDomain is coercible to the float types,{} and not Expression.} Date Created: 21 Feb 1990


kind: d
name: Plot
exposed: n
type: ()->Join(PlottablePlaneCurveCategory,etc)
abbrev: PLOT
comment:
The Plot domain supports plotting of functions defined over a real number system. A real number system is a model for the real numbers and as such may be an approximation. For example floating point numbers and infinite continued fractions. The facilities at this point are limited to 2-dimensional plots or either a single function or a parametric function.


kind: d
name: Plot3D
exposed: n
type: ()->Join(PlottableSpaceCurveCategory,etc)
abbrev: PLOT3D
comment:
Plot3D supports parametric plots defined over a real number system. A real number system is a model for the real numbers and as such may be an approximation. For example,{} floating point numbers and infinite continued fractions are real number systems. The facilities at this point are limited to 3-dimensional parametric plots.


kind: d
name: PoincareBirkhoffWittLyndonBasis
exposed: n
type: (OrderedSet)->Join(OrderedSet,etc)
params: (VarSet)
abbrev: PBWLB
comment:
This domain provides the internal representation of polynomials in non-commutative variables written over the Poincare-Birkhoff-Witt basis. See the \spadtype{XPBWPolynomial} domain constructor. See Free Lie Algebras by \spad{C}. Reutenauer (Oxford science publications). \newline Author: Michel Petitot (petitot@lifl.\spad{fr}).


kind: d
name: Polynomial
exposed: x
type: (Ring)->Join(PolynomialCategory(R,IndexedExponents(Symbol),Symbol),etc)
params: (R)
abbrev: POLY
comment:
\indented{2}{This type is the basic representation of sparse recursive multivariate} polynomials whose variables are arbitrary symbols. The ordering is alphabetic determined by the Symbol type. The coefficient ring may be non commutative,{} but the variables are assumed to commute.


kind: d
name: PolynomialIdeal
exposed: x
params: (F,Expon,VarSet,DPoly)
abbrev: IDEAL
type:
(F:Field,Expon:OrderedAbelianMonoidSup,VarSet:OrderedSet,DPoly:PolynomialCategory(F,Expon,VarSet))->Join(SetCategory,etc)

comment:
This domain represents polynomial ideals with coefficients in any field and supports the basic ideal operations,{} including intersection,{} sum and quotient. An ideal is represented by a list of polynomials (the generators of the ideal) and a boolean that is \spad{true} if the generators are a Groebner basis. The algorithms used are based on Groebner basis computations. The ordering is determined by the datatype of the input polynomials. Users may use refinements of total degree orderings.


kind: d
name: PolynomialRing
exposed: n
type: (Join(SemiRng,etc),E:OrderedAbelianMonoid)->Join(FiniteAbelianMonoidRing(R,E),etc)
params: (R,E)
abbrev: PR
comment:
This domain represents generalized polynomials with coefficients (from a not necessarily commutative ring),{} and terms indexed by their exponents (from an arbitrary ordered abelian monoid). This type is used,{} for example,{} by the \spadtype{DistributedMultivariatePolynomial} domain where the exponent domain is a direct product of non negative integers.


kind: d
name: PrimeField
exposed: x
type: (PositiveInteger)->Join(FiniteFieldCategory,etc)
params: (p)
abbrev: PF
comment:
PrimeField(\spad{p}) implements the field with \spad{p} elements if \spad{p} is a prime number. Error: if \spad{p} is not prime.


kind: d
name: PrimitiveArray
exposed: n
type: (Type)->OneDimensionalArrayAggregate(S)
params: (S)
abbrev: PRIMARR
comment:
This provides a fast array type with no bound checking on elt\spad{'s}. Minimum index is 0 in this type,{} cannot be changed.


kind: d
name: PrimitiveTwoDimensionalArray
exposed: n
type: (Type)->Join(TwoDimensionalArrayCategory(S,PrimitiveArray(S),PrimitiveArray(S)),etc)
params: (S)
abbrev: PRIMMAT2
comment:
This is a low-level domain which implements matrices \indented{1}{(two dimensional arrays) of general values.} \indented{1}{Indexing is 0 based,{} there is no bound checking (unless} \indented{1}{provided by lower level).}


kind: d
name: Product
exposed: n
type: (SetCategory,B:SetCategory)->Join(SetCategory,etc)
params: (A,B)
abbrev: PRODUCT
comment:
This domain implements cartesian product. If the underlying domains are both Finite then the resulting Product is also Finite and can be enumerated via size(),{} index(),{} location(),{} etc. The index of the second component (\spad{B}) varies most quickly.


kind: d
name: ProductFacet
exposed: n
type: ()->Join(FacetCategory,etc)
abbrev: PFACET
comment:
\indented{2}{Holds the product of two simplexes} \indented{2}{for more documentation see:} \indented{2}{http://www.euclideanspace.com/prog/scratchpad/mycode/topology/simplex/product/} Date Created: April 2016 Basic Operations: Related packages: Related categories: FacetCategory Related Domains: Also See: AMS Classifications:


kind: d
name: QuasiAlgebraicSet
exposed: n
params: (R,Var,Expon,Dpoly)
abbrev: QALGSET
type:
(R:GcdDomain,Var:OrderedSet,Expon:OrderedAbelianMonoidSup,Dpoly:PolynomialCategory(R,Expon,Var))->Join(SetCategory,etc)

comment:
\spadtype{QuasiAlgebraicSet} constructs a domain representing quasi-algebraic sets,{} which is the intersection of a Zariski closed set,{} defined as the common zeros of a given list of polynomials (the defining polynomials for equations),{} and a principal Zariski open set,{} defined as the complement of the common zeros of a polynomial \spad{f} (the defining polynomial for the inequation). This domain provides simplification of a user-given representation using groebner basis computations. There are two simplification routines: the first function \spadfun{idealSimplify} uses groebner basis of ideals alone,{} while the second,{} \spadfun{simplify} uses both groebner basis and factorization. The resulting defining equations \spad{L} always form a groebner basis,{} and the resulting defining inequation \spad{f} is always reduced. The function \spadfun{simplify} may be applied several times if desired. A third simplification routine \spadfun{radicalSimplify} is provided in \spadtype{QuasiAlgebraicSet2} for comparison study only,{} as it is inefficient compared to the other two,{} as well as is restricted to only certain coefficient domains. For detail analysis and a comparison of the three methods,{} please consult the reference cited. \blankline A polynomial function \spad{q} defined on the quasi-algebraic set is equivalent to its reduced form with respect to \spad{L}. While this may be obtained using the usual normal form algorithm,{} there is no canonical form for \spad{q}. \blankline The ordering in groebner basis computation is determined by the data type of the input polynomials. If it is possible we suggest to use refinements of total degree orderings.


kind: d
name: RadicalFunctionField
exposed: n
params: (F,UP,UPUP,radicnd,n)
abbrev: RADFF
comment: Function field defined by \spad{y^n} = \spad{f}(\spad{x}).
type:
(F:UniqueFactorizationDomain,UP:UnivariatePolynomialCategory(F),UPUP:UnivariatePolynomialCategory(Fraction(UP)),Fraction(UP),NonNegativeInteger)->FunctionFieldCategory(F,UP,UPUP)


kind: d
name: RadixExpansion
exposed: x
type: (Integer)->Join(QuotientFieldCategory(Integer),etc)
params: (bb)
abbrev: RADIX
comment:
This domain allows rational numbers to be presented as repeating decimal expansions or more generally as repeating expansions in any base.


kind: d
name: Record
exposed: x
type: special
params: (a:A,b:B,...,c:C)
abbrev: RECORD
comment:
\spad{Record(a:A,b:B,...,c:C)} is a primitive type in FriCAS used to represent composite objects made up of objects of type \spad{A}, \spad{B},..., \spad{C} which are indexed by keys (identifiers) \spad{a},\spad{b},...,\spad{c}.


kind: d
name: RectangularMatrix
exposed: n
params: (m,n,R)
abbrev: RMATRIX
type:
(NonNegativeInteger,n:NonNegativeInteger,R:Join(SemiRng,etc))->Join(RectangularMatrixCategory(m,n,R,DirectProduct(n,R),DirectProduct(m,R)),etc)

comment:
\spadtype{RectangularMatrix} is a matrix domain where the number of rows and the number of columns are parameters of the domain.


kind: d
name: RegularChain
exposed: x
params: (R,ls)
abbrev: RGCHAIN
type:
(GcdDomain,ls:List(Symbol))->Join(RegularTriangularSetCategory(R,IndexedExponents(OrderedVariableList(ls)),OrderedVariableList(ls),NewSparseMultivariatePolynomial(R,OrderedVariableList(ls))),etc)

comment:
A domain for regular chains (\spadignore{i.e.} regular triangular sets) over a \spad{Gcd}-Domain and with a fix list of variables. This is just a front-end for the \spadtype{RegularTriangularSet} domain constructor.


kind: d
name: RegularTriangularSet
exposed: x
params: (R,E,V,P)
abbrev: REGSET
type:
(R:GcdDomain,E:OrderedAbelianMonoidSup,V:OrderedSet,P:RecursivePolynomialCategory(R,E,V))->Join(RegularTriangularSetCategory(R,E,V,P),etc)

comment:
This domain provides an implementation of regular chains. Moreover,{} the operation \spadopFrom{zeroSetSplit}{RegularTriangularSetCategory} is an implementation of a new algorithm for solving polynomial systems by means of regular chains.\newline


kind: d
name: ResidueRing
exposed: n
params: (F,Expon,VarSet,FPol,LFPol)
abbrev: RESRING
type:
(F:Field,Expon:OrderedAbelianMonoidSup,VarSet:OrderedSet,FPol:PolynomialCategory(F,Expon,VarSet),List(FPol))->Join(CommutativeRing,etc)

comment:
ResidueRing is the quotient of a polynomial ring by an ideal. The ideal is given as a list of generators. The elements of the domain are equivalence classes expressed in terms of reduced elements


kind: d
name: Result
exposed: n
type: ()->Join(TableAggregate(Symbol,Any),etc)
abbrev: RESULT
comment:
A domain used to return the results from a call to the NAG Library. It prints as a list of names and types,{} though the user may choose to display values automatically if he or she wishes.


kind: d
name: RightOpenIntervalRootCharacterization
exposed: x
params: (TheField,ThePolDom)
abbrev: ROIRC
comment: \spadtype{RightOpenIntervalRootCharacterization} provides work with interval root coding.
type:
(TheField:Join(OrderedRing,etc),ThePolDom:UnivariatePolynomialCategory(TheField))->Join(RealRootCharacterizationCategory(TheField,ThePolDom),etc)


kind: d
name: SArgand
exposed: n
type: ()->Join(SPointCategory,etc)
abbrev: SARGND
comment:
\indented{1}{Domain for representing points,{} vectors,{} subspaces and properties} of components in a subspace as complex numbers


kind: d
name: SBoundary
exposed: n
type: (SPointCategory)->etc
params: (PT)
abbrev: SBOUND
comment:
\indented{1}{SBoundary implements boundaries for use in scene graph} This defines the outer extent of the scene,{} or of an element in the scene,{} or of some branch in the scene. The difference between this boundary and an \spad{n}-dimensional surface,{} such as IFS,{} is that boundary must always have a well defined inside and an outside. SBoundary does not necessarily follow the exact outer contours of the shape but just constructs a simple boundary shape where all points of the shape are guaranteed to be inside the boundary. Currently there are the following boundary forms: \indented{1}{Simple types:} \indented{2}{box::Symbol which is a \spad{n}-dimensional axis-aligned rectangle.} \indented{2}{ellipoid::Symbol which is a \spad{n}-dimensional axis-aligned ellipse.} \indented{1}{Compound types:} \indented{2}{This is a combination of simple and other compound types such} \indented{2}{as union or intersection.} \indented{3}{union::Symbol represents union of supplied list} \indented{3}{intersection::Symbol represents intersection of supplied list} \indented{1}{Null types:} \indented{2}{none is used for a node which does not have a boundary in} \indented{6}{space,{} for example,{} when the boundary of a material node} \indented{6}{is requested.} The uses of SBoundary are: 1) So we know how much to scale a given scene to fit in a \indented{3}{given size.} 2) So that we know where to terminate arrows going in out out of \indented{3}{of the shape.} 3) To detect if objects intersect (collision detect),{} or if one \indented{3}{object is contained completely inside another.}


kind: d
name: SCartesian
exposed: n
type: (PositiveInteger)->SPointCategory
params: (n)
abbrev: SCRT
comment:
an implementation of PointCategory to represent points and vectors in three dimensional coordinate space


kind: d
name: SceneIFS
exposed: n
type: (SPointCategory)->etc
params: (PT)
abbrev: SCIFS
comment:
Generates various surfaces (2 dimensional subsets of 3D space). When 1 dimensional subspace (a line) needs to be represented in a 3D editor then we convert the line into a tube. Many of the functions here are from NumericTubePlot and related packages. However \spad{I} needed them to be defined over SPointCategory so \spad{I} adapted them here.


kind: d
name: SceneNamedPoints
exposed: n
type: (SPointCategory)->Join(SetCategory,etc)
params: (PT)
abbrev: SCNP
comment:
Associates points or nodes in Scene structure with names (or a hierarchy of names). The aim is,{} where a point or node is used in several different constructions,{} it only needs to be specified once.


kind: d
name: SegmentBinding
exposed: x
type: (Type)->Join(Type,etc)
params: (S)
abbrev: SEGBIND
comment:
This domain is used to provide the function argument syntax \spad{v=a..b}. This is used,{} for example,{} by the top-level \spadfun{draw} functions.


kind: d
name: Sequence
exposed: x
type: (CommutativeRing)->SequenceCategory(R)
params: (R)
abbrev: SEQU
comment:
A domain for infinite sequences over a commutative ring. It is implemented as stream with arithmetics.


kind: d
name: SequentialDifferentialPolynomial
exposed: n
params: (R)
abbrev: SDPOL
type:
(Ring)->Join(DifferentialPolynomialCategory(R,Symbol,SequentialDifferentialVariable(Symbol),IndexedExponents(SequentialDifferentialVariable(Symbol))),etc)

comment:
\spadtype{SequentialDifferentialPolynomial} implements an ordinary differential polynomial ring in arbitrary number of differential indeterminates,{} with coefficients in a ring. The ranking on the differential indeterminate is sequential. \blankline


kind: d
name: SequentialDifferentialVariable
exposed: n
type: (OrderedSet)->DifferentialVariableCategory(S)
params: (S)
abbrev: SDVAR
comment:
\spadtype{OrderlyDifferentialVariable} adds a commonly used sequential ranking to the set of derivatives of an ordered list of differential indeterminates. A sequential ranking is a ranking \spadfun{<} of the derivatives with the property that for any derivative \spad{v},{} there are only a finite number of derivatives \spad{u} with \spad{u} \spadfun{<} \spad{v}. This domain belongs to \spadtype{DifferentialVariableCategory}. It defines \spadfun{weight} to be just \spadfun{order},{} and it defines a sequential ranking \spadfun{<} on derivatives \spad{u} by the lexicographic order on the pair (\spadfun{variable}(\spad{u}),{} \spadfun{order}(\spad{u})).


kind: d
name: Set
exposed: x
type: (SetCategory)->FiniteSetAggregate(S)
params: (S)
abbrev: SET
comment:
A set over a domain \spad{S} models the usual mathematical notion of a finite set of elements from \spad{S}. Sets are unordered collections of distinct elements (that is,{} order and duplication does not matter). The notation \spad{set [a,{} b,{} c]} can be used to create a set and the usual operations such as union and intersection are available to form new sets. If \spad{S} has OrderdSet,{} \Language{} maintains the entries in sorted order. Specifically,{} the parts function returns the entries as a list in ascending order and the \spadfun{extract!} operation returns the maximum entry. Given two sets \spad{s} and \spad{t} where \spad{\#s = m} and \spad{\#t = n},{} the complexity of \indented{2}{\spad{s = t} is \spad{O(min(n,{} m))}} \indented{2}{\spad{s < t} is \spad{O(max(n,{} m))}} \indented{2}{\spad{union(s,{} t)},{} \spad{intersect(s,{} t)},{} \spad{minus(s,{} t)},{} \spad{symmetricDifference(s,{} t)} is \spad{O(max(n,{} m))}} \indented{2}{\spad{member?(x,{} t)} is \spad{O(n log n)}} \indented{2}{\spad{insert!(x,{} t)} and \spad{remove!(x,{} t)} is \spad{O(n)}}


kind: d
name: SetOfMIntegersInOneToN
exposed: n
type: (PositiveInteger,PositiveInteger)->Join(Finite,etc)
params: (m,n)
abbrev: SETMN
comment:
\spadtype{SetOfMIntegersInOneToN} implements the subsets of \spad{M} integers in the interval \spad{[1..n]}


kind: d
name: SimpleAlgebraicExtension
exposed: n
type: (R:CommutativeRing,UP:UnivariatePolynomialCategory(R),UP)->Join(MonogenicAlgebra(R,UP),etc)
params: (R,UP,M)
abbrev: SAE
comment:
Domain which represents simple algebraic extensions of arbitrary rings. The first argument to the domain,{} \spad{R},{} is the underlying ring,{} the second argument is a domain of univariate polynomials over \spad{R},{} while the last argument specifies the defining minimal polynomial. The elements of the domain are canonically represented as polynomials of degree less than that of the minimal polynomial with coefficients in \spad{R}. The second argument is both the type of the third argument and the underlying representation used by \spadtype{SAE} itself.


kind: d
name: SimpleCell
exposed: n
params: (TheField,ThePols)
abbrev: SCELL
type:
(TheField:RealClosedField,ThePols:UnivariatePolynomialCategory(TheField))->Join(CoercibleTo(OutputForm),etc)


kind: d
name: SimpleFortranProgram
exposed: n
type: (R:OrderedSet,FS:FunctionSpace(R))->Join(FortranProgramCategory,etc)
params: (R,FS)
abbrev: SFORT
comment:
\spadtype{SimpleFortranProgram} provides a simple model of some FORTRAN subprograms,{} making it possible to coerce objects of various domains into a FORTRAN subprogram called \spad{f}. These can then be translated into legal FORTRAN code.


kind: d
name: SKICombinators
exposed: n
type: (VarCat)->Join(SetCategory,etc)
params: (UT)
abbrev: SKICOMB
comment:
This domain implements SKI combinators. Ski combinators were introduced by Moses Schoenfinkel and Haskell Curry with the aim of eliminating the need for variables in mathematical logic. It is equivalent to lambda calculus but it can be used for doing,{} without variables,{} anything that would require variables in other systems.


kind: d
name: SmallOrdinal
exposed: n
type: ()->Join(OrderedAbelianMonoid,etc)
abbrev: SORD
comment:
SmallOrdinal implements ordinal numbers up to \spad{epsilon_0}. \spad{+} and \spad{*} are natural addition and multiplication of ordinals. Available separately are ordered operataions.


kind: d
name: SparseEchelonMatrix
exposed: n
type: (OrderedSet,D:Ring)->Join(CoercibleTo(OutputForm),etc)
params: (C,D)
abbrev: SEM
comment:
\spad{SparseEchelonMatrix(C,{} D)} implements sparse matrices whose columns are enumerated by the \spadtype{OrderedSet} \spad{C} and whose entries belong to the \spadtype{GcdDomain} \spad{D}. The basic operation of this domain is the computation of an row echelon form. The algorithm used tries to maintain the sparsity and is especially adapted to matrices which are already close to a row echelon form.


kind: d
name: SparseMultivariatePolynomial
exposed: n
type: (Join(SemiRng,etc),VarSet:OrderedSet)->PolynomialCategory(R,IndexedExponents(VarSet),VarSet)
params: (R,VarSet)
abbrev: SMP
comment:
\indented{2}{This type is the basic representation of sparse recursive multivariate} polynomials. It is parameterized by the coefficient ring and the variable set which may be infinite. The variable ordering is determined by the variable set parameter. The coefficient ring may be non-commutative,{} but the variables are assumed to commute.


kind: d
name: SparseMultivariateSkewPolynomial
exposed: n
params: (R,Var,sigma,delta)
abbrev: SKSMP
type:
(R:Ring,Var:OrderedSet,(Var)->Automorphism(R),(Var)->(R)->R)->Join(MultivariateSkewPolynomialCategory(R,IndexedExponents(Var),Var),etc)

comment:
SparseMultivariateSkewPolynomial(\spad{R},{} Var,{} sigma,{} delta) defines a mutivariate Ore ring over \spad{R} in variables from \spad{V}. \spad{sigma(v)} gives automorphism of \spad{R} corresponding to variable \spad{v} and \spad{delta(v)} gives corresponding derivative. \blankline


kind: d
name: SparseMultivariateTaylorSeries
exposed: n
params: (Coef,Var,SMP)
abbrev: SMTS
type:
(Coef:Ring,Var:OrderedSet,SMP:PolynomialCategory(Coef,IndexedExponents(Var),Var))->Join(MultivariateTaylorSeriesCategory(Coef,Var),etc)

comment:
This domain provides multivariate Taylor series with variables from an arbitrary ordered set. A Taylor series is represented by a stream of polynomials from the polynomial domain \spad{SMP}. The \spad{n}th element of the stream is a form of degree \spad{n}. SMTS is an internal domain.


kind: d
name: SparseUnivariateLaurentSeries
exposed: n
params: (Coef,var,cen)
abbrev: SULS
type:
(Coef:Ring,var:Symbol,cen:Coef)->Join(UnivariateLaurentSeriesConstructorCategory(Coef,SparseUnivariateTaylorSeries(Coef,var,cen)),etc)

comment:
Sparse Laurent series in one variable \indented{2}{\spadtype{SparseUnivariateLaurentSeries} is a domain representing Laurent} \indented{2}{series in one variable with coefficients in an arbitrary ring.\space{2}The} \indented{2}{parameters of the type specify the coefficient ring,{} the power series} \indented{2}{variable,{} and the center of the power series expansion.\space{2}For example,{}} \indented{2}{\spad{SparseUnivariateLaurentSeries(Integer,{} x,{} 3)} represents Laurent} \indented{2}{series in \spad{(x - 3)} with integer coefficients.}


kind: d
name: SparseUnivariatePolynomial
exposed: n
type: (Join(SemiRng,etc))->Join(UnivariatePolynomialCategory(R),etc)
params: (R)
abbrev: SUP
comment:
This domain represents univariate polynomials over arbitrary (not necessarily commutative) coefficient rings. The variable is unspecified so that the variable displays as \spad{?} in output. If it is necessary to specify the variable name,{} use type \spadtype{UnivariatePolynomial}. The representation is sparse in the sense that only non-zero terms are represented.


kind: d
name: SparseUnivariatePuiseuxSeries
exposed: n
params: (Coef,var,cen)
abbrev: SUPXS
type:
(Coef:Ring,var:Symbol,cen:Coef)->Join(UnivariatePuiseuxSeriesConstructorCategory(Coef,SparseUnivariateLaurentSeries(Coef,var,cen)),etc)

comment:
Sparse Puiseux series in one variable \indented{2}{\spadtype{SparseUnivariatePuiseuxSeries} is a domain representing Puiseux} \indented{2}{series in one variable with coefficients in an arbitrary ring.\space{2}The} \indented{2}{parameters of the type specify the coefficient ring,{} the power series} \indented{2}{variable,{} and the center of the power series expansion.\space{2}For example,{}} \indented{2}{\spad{SparseUnivariatePuiseuxSeries(Integer,{} x,{} 3)} represents Puiseux} \indented{2}{series in \spad{(x - 3)} with \spadtype{Integer} coefficients.}


kind: d
name: SparseUnivariateSkewPolynomial
exposed: n
type: (R:Ring,Automorphism(R),(R)->R)->Join(UnivariateSkewPolynomialCategory(R),etc)
params: (R,sigma,delta)
abbrev: ORESUP
comment:
This is the domain of sparse univariate skew polynomials over an Ore coefficient field. The multiplication is given by \spad{x a = \sigma(a) x + \delta a}.


kind: d
name: SparseUnivariateTaylorSeries
exposed: n
type: (Coef:Ring,var:Symbol,Coef)->Join(UnivariateTaylorSeriesCategory(Coef),etc)
params: (Coef,var,cen)
abbrev: SUTS
comment:
Sparse Taylor series in one variable \indented{2}{\spadtype{SparseUnivariateTaylorSeries} is a domain representing Taylor} \indented{2}{series in one variable with coefficients in an arbitrary ring.\space{2}The} \indented{2}{parameters of the type specify the coefficient ring,{} the power series} \indented{2}{variable,{} and the center of the power series expansion.\space{2}For example,{}} \indented{2}{\spadtype{SparseUnivariateTaylorSeries}(Integer,{} \spad{x},{} 3) represents Taylor} \indented{2}{series in \spad{(x - 3)} with \spadtype{Integer} coefficients.}


kind: d
name: SplitHomogeneousDirectProduct
exposed: n
type: (NonNegativeInteger,NonNegativeInteger,S:OrderedAbelianMonoid)->DirectProductCategory(dimtot,S)
params: (dimtot,dim1,S)
abbrev: SHDP
comment:
\indented{2}{This type represents the finite direct or cartesian product of an} underlying ordered component type. The vectors are ordered as if they were split into two blocks. The \spad{dim1} parameter specifies the length of the first block. The ordering is lexicographic between the blocks but acts like \spadtype{HomogeneousDirectProduct} within each block. This type is a suitable third argument for \spadtype{GeneralDistributedMultivariatePolynomial}.


kind: d
name: SplittingNode
exposed: n
type: (Join(SetCategory,etc),C:Join(SetCategory,etc))->Join(SetCategory,etc)
params: (V,C)
abbrev: SPLNODE
comment:
This domain exports a modest implementation for the vertices of splitting trees. These vertices are called here splitting nodes. Every of these nodes store 3 informations. The first one is its value,{} that is the current expression to evaluate. The second one is its condition,{} that is the hypothesis under which the value has to be evaluated. The last one is its status,{} that is a boolean flag which is \spad{true} iff the value is the result of its evaluation under its condition. Two splitting vertices are equal iff they have the sane values and the same conditions (so their status do not matter).


kind: d
name: SplittingTree
exposed: n
type: (Join(SetCategory,etc),C:Join(SetCategory,etc))->Join(RecursiveAggregate(SplittingNode(V,C)),etc)
params: (V,C)
abbrev: SPLTREE
comment:
This domain exports a modest implementation of splitting trees. Splitting trees are needed when the evaluation of some quantity under some hypothesis requires to split the hypothesis into sub-cases. For instance by adding some new hypothesis on one hand and its negation on another hand. The computations are terminated for a splitting tree \spad{a} when \spad{status(value(a))} is \spad{true}. Thus,{} if for the splitting tree \spad{a} the flag \spad{status(value(a))} is \spad{true},{} then \spad{status(value(d))} is \spad{true} for any subtree \spad{d} of \spad{a}. This property of splitting trees is called the termination condition. If no vertex in a splitting tree \spad{a} is equal to another,{} \spad{a} is said to satisfy the no-duplicates condition. The splitting tree \spad{a} will satisfy this condition if nodes are added to \spad{a} by means of \spad{splitNodeOf!} and if \spad{construct} is only used to create the root of \spad{a} with no children.


kind: d
name: SquareFreeRegularTriangularSet
exposed: x
params: (R,E,V,P)
abbrev: SREGSET
type:
(R:GcdDomain,E:OrderedAbelianMonoidSup,V:OrderedSet,P:RecursivePolynomialCategory(R,E,V))->Join(SquareFreeRegularTriangularSetCategory(R,E,V,P),etc)

comment:
This domain provides an implementation of square-free regular chains. Moreover,{} the operation \spadopFrom{zeroSetSplit}{SquareFreeRegularTriangularSetCategory} is an implementation of a new algorithm for solving polynomial systems by means of regular chains.\newline


kind: d
name: SquareMatrix
exposed: n
params: (ndim,R)
abbrev: SQMATRIX
type:
(NonNegativeInteger,R:Join(SemiRng,etc))->Join(SquareMatrixCategory(ndim,R,DirectProduct(ndim,R),DirectProduct(ndim,R)),etc)

comment:
\spadtype{SquareMatrix} is a matrix domain of square matrices,{} where the number of rows (= number of columns) is a parameter of the type.


kind: d
name: STransform
exposed: n
type: (SPointCategory)->etc
params: (PT)
abbrev: STR
comment:
\indented{1}{Domains for transform from SPoint to SPoint} STransform transform domain can by used to represent linear transforms for instance when working with SCartesian where its Representation is a matrix of DoubleFloat Other transform domains may not necessarily be linear and will have different representations


kind: d
name: Stream
exposed: x
type: (Type)->Join(LazyStreamAggregate(S),etc)
params: (S)
abbrev: STREAM
comment:
A stream is an implementation of a possibly infinite sequence using a list of terms that have been computed and a function closure to compute additional terms when needed.


kind: d
name: StringTable
exposed: n
type: (Type)->Join(TableAggregate(String,Entry),etc)
params: (Entry)
abbrev: STRTBL
comment:
This domain provides tables where the keys are strings. A specialized hash function for strings is used.


kind: d
name: SubsetLattice
exposed: n
type: (S:SetCategory,List(S))->Join(Lattice,etc)
params: (S,top)
abbrev: SETLAT
comment:
Implementation of subset logic. \indented{3}{implements pseudo complement} \indented{3}{subset of powerset} \indented{3}{related to 'containment order'} \indented{3}{REP holds a single node and complete set (representing 'top')} Date Created: Oct 2015


kind: d
name: Switch
exposed: n
type: ()->Join(CoercibleTo(OutputForm),etc)
abbrev: SWITCH
comment:
This domain builds representations of boolean expressions for use with the \spadtype{FortranCode} domain.


kind: d
name: Table
exposed: n
type: (SetCategory,Entry:Type)->Join(TableAggregate(Key,Entry),etc)
params: (Key,Entry)
abbrev: TABLE
comment:
This is the general purpose table type. The keys are hashed to look up the entries. This creates a \spadtype{HashTable} if equal for the Key domain is consistent with Lisp EQUAL otherwise an \spadtype{AssociationList}


kind: d
name: Tableau
exposed: x
type: (SetCategory)->Join(CoercibleTo(OutputForm),etc)
params: (S)
abbrev: TABLEAU
comment:
The tableau domain is for printing Young tableaux,{} and coercions to and from List List \spad{S} where \spad{S} is a set.


kind: d
name: TaylorSeries
exposed: x
type: (Ring)->Join(MultivariateTaylorSeriesCategory(Coef,Symbol),etc)
params: (Coef)
abbrev: TS
comment:
\spadtype{TaylorSeries} is a general multivariate Taylor series domain over the ring Coef and with variables of type Symbol.


kind: d
name: TaylorSeriesExpansionGeneralized
exposed: n
params: (Coef,Expon,UPS,UTS)
abbrev: TSEREXPG
type:
(Coef:Algebra(Fraction(Integer)),Expon:OrderedAbelianMonoid,UPS:Join(UnivariatePowerSeriesCategory(Coef,Expon),etc),UTS:UnivariateTaylorSeriesCategory(Coef))->TaylorSeriesExpansion(Coef,Expon,SingletonAsOrderedSet,UPS,UTS)


kind: d
name: TaylorSeriesExpansionLaurent
exposed: n
params: (Coef,UTS,ULS)
abbrev: TSEREXPL
type:
(Coef:Algebra(Fraction(Integer)),UTS:UnivariateTaylorSeriesCategory(Coef),ULS:UnivariateLaurentSeriesConstructorCategory(Coef,UTS))->TaylorSeriesExpansion(Coef,Integer,SingletonAsOrderedSet,ULS,UTS)


kind: d
name: TaylorSeriesExpansionPuiseux
exposed: n
params: (Coef,UTS,ULS,UPS)
abbrev: TSEREXPP
type:
(Coef:Algebra(Fraction(Integer)),UTS:UnivariateTaylorSeriesCategory(Coef),ULS:UnivariateLaurentSeriesConstructorCategory(Coef,UTS),UPS:UnivariatePuiseuxSeriesConstructorCategory(Coef,ULS))->TaylorSeriesExpansion(Coef,Fraction(Integer),SingletonAsOrderedSet,UPS,UTS)


kind: d
name: TaylorSeriesExpansionTaylor
exposed: n
params: (Coef,UTS)
abbrev: TSEREXPT
type:
(Coef:Algebra(Fraction(Integer)),UTS:UnivariateTaylorSeriesCategory(Coef))->TaylorSeriesExpansion(Coef,NonNegativeInteger,SingletonAsOrderedSet,UTS,UTS)


kind: d
name: TensorPower
exposed: n
params: (n,R,B,M)
abbrev: TENSPOW
type:
(NonNegativeInteger,R:CommutativeRing,B:OrderedSet,M:FreeModuleCategory(R,B))->Join(TensorPowerCategory(n,R,M),etc)

comment:
Tensor powers of a free module over a commutative ring. It is represented as a free module over the cartesian power of the basis.


kind: d
name: TensorProduct
exposed: n
params: (R,B1,B2,M1,M2)
abbrev: TENSOR
type:
(R:CommutativeRing,B1:OrderedSet,B2:OrderedSet,M1:FreeModuleCategory(R,B1),M2:FreeModuleCategory(R,B2))->Join(TensorProductCategory(R,M1,M2),etc)

comment:
Tensor product of free modules over a commutative ring. It is represented as a free module over the direct product of the respective bases. The factor domains must provide operations \spad{listOfTerms},{} whose result is assumed to be stored in reverse order.


kind: d
name: TexFormat
exposed: n
type: ()->Join(SetCategory,etc)
abbrev: TEX
comment:
\spadtype{TexFormat} provides a coercion from \spadtype{OutputForm} to \TeX{} format. The particular dialect of \TeX{} used is \LaTeX{}. The basic object consists of three parts: a prologue,{} a tex part and an epilogue. The functions \spadfun{prologue},{} \spadfun{tex} and \spadfun{epilogue} extract these parts,{} respectively. The main guts of the expression go into the tex part. The other parts can be set (\spadfun{setPrologue!},{} \spadfun{setEpilogue!}) so that contain the appropriate tags for printing. For example,{} the prologue and epilogue might simply contain \spad{


kind: d
name: TextFile
exposed: x
type: ()->Join(FileCategory(FileName,String),etc)
abbrev: TEXTFILE
comment:
This domain provides an implementation of text files. Text is stored in these files using the native character set of the computer.


kind: d
name: TheSymbolTable
exposed: n
type: ()->Join(CoercibleTo(OutputForm),etc)
abbrev: SYMS
comment:
Creates and manipulates one global symbol table for FORTRAN code generation,{} containing details of types,{} dimensions,{} and argument lists.


kind: d
name: ThreeSpace
exposed: x
type: (Ring)->ThreeSpaceCategory(R)
params: (R)
abbrev: SPACE3
comment:
The domain ThreeSpace is used for creating three dimensional objects using functions for defining points,{} curves,{} polygons,{} constructs and the subspaces containing them.


kind: d
name: Tree
exposed: x
type: (SetCategory)->Join(RecursiveAggregate(S),etc)
params: (S)
abbrev: TREE
comment:
\spadtype{Tree(S)} is a basic domain of tree structures. Each tree is either empty or has a {\it node} consisting of a value and a list of (sub)trees.


kind: d
name: TubePlot
exposed: n
type: (PlottableSpaceCurveCategory)->etc
params: (Curve)
abbrev: TUBE
comment:
\indented{2}{Package for constructing tubes around 3-dimensional parametric curves.} Domain of tubes around 3-dimensional parametric curves.


kind: d
name: Tuple
exposed: n
type: (Type)->Join(CoercibleTo(PrimitiveArray(S)),etc)
params: (S)
abbrev: TUPLE
comment:
This domain is used to interface with the interpreter\spad{'s} notion of comma-delimited sequences of values.


kind: d
name: TwoDimensionalArray
exposed: n
type: (Type)->TwoDimensionalArrayCategory(R,OneDimensionalArray(R),OneDimensionalArray(R))
params: (R)
abbrev: ARRAY2
comment:
\indented{1}{A TwoDimensionalArray is a two dimensional array with} 1-based indexing for both rows and columns.


kind: d
name: Typed
exposed: n
type: ()->VarCat
abbrev: TYPED
comment:
Typed represents an typed variable in Lambda and Ski domains,{} a variable has a name represented by a String and a type represented by intutionistic logic.


kind: d
name: U16Matrix
exposed: n
type: ()->MatrixCategory(Integer,U16Vector,U16Vector)
abbrev: U16MAT
comment:
This is a low-level domain which implements matrices (two dimensional arrays) of unsigned 16-bit integers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).


kind: d
name: U16Vector
exposed: n
type: ()->OneDimensionalArrayAggregate(Integer)
abbrev: U16VEC
comment:
This is a low-level domain which implements vectors (one dimensional arrays) of unsigned 16-bit numbers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).


kind: d
name: U32Matrix
exposed: n
type: ()->MatrixCategory(Integer,U32Vector,U32Vector)
abbrev: U32MAT
comment:
This is a low-level domain which implements matrices (two dimensional arrays) of unsigned 32-bit integers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).


kind: d
name: U32Vector
exposed: n
type: ()->OneDimensionalArrayAggregate(Integer)
abbrev: U32VEC
comment:
This is a low-level domain which implements vectors (one dimensional arrays) of unsigned 32-bit numbers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).


kind: d
name: U64Int
exposed: n
type: ()->Join(Ring,etc)
abbrev: U64INT
comment:
Domain of unsigned 64-bit integers. It is used \indented{1}{to declare that values of local variables fit into 64 bits.}


kind: d
name: U8Matrix
exposed: n
type: ()->MatrixCategory(Integer,U8Vector,U8Vector)
abbrev: U8MAT
comment:
This is a low-level domain which implements matrices (two dimensional arrays) of unsigned 8-bit integers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).


kind: d
name: U8Vector
exposed: n
type: ()->OneDimensionalArrayAggregate(Integer)
abbrev: U8VEC
comment:
This is a low-level domain which implements vectors (one dimensional arrays) of unsigned 8-bit numbers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).


kind: d
name: Union
exposed: x
type: special
params: (A,B,...,C)
abbrev: UNION
comment:
\spad{Union(A,B,...,C)} is a primitive type in FriCAS used to represent objects of type \spad{A} or of type \spad{B} or...or of type \spad{C}.


kind: d
name: UnivariateLaurentSeries
exposed: n
params: (Coef,var,cen)
abbrev: ULS
type:
(Coef:Ring,var:Symbol,cen:Coef)->Join(UnivariateLaurentSeriesConstructorCategory(Coef,UnivariateTaylorSeries(Coef,var,cen)),etc)

comment:
Dense Laurent series in one variable \indented{2}{\spadtype{UnivariateLaurentSeries} is a domain representing Laurent} \indented{2}{series in one variable with coefficients in an arbitrary ring.\space{2}The} \indented{2}{parameters of the type specify the coefficient ring,{} the power series} \indented{2}{variable,{} and the center of the power series expansion.\space{2}For example,{}} \indented{2}{\spad{UnivariateLaurentSeries(Integer,{} x,{} 3)} represents Laurent series in} \indented{2}{\spad{(x - 3)} with integer coefficients.}


kind: d
name: UnivariateLaurentSeriesConstructor
exposed: n
params: (Coef,UTS)
abbrev: ULSCONS
type:
(Coef:Ring,UTS:UnivariateTaylorSeriesCategory(Coef))->UnivariateLaurentSeriesConstructorCategory(Coef,UTS)

comment:
This package enables one to construct a univariate Laurent series domain from a univariate Taylor series domain. Univariate Laurent series are represented by a pair \spad{[n,{} f(x)]},{} where \spad{n} is an arbitrary integer and \spad{f(x)} is a Taylor series. This pair represents the Laurent series \spad{x^n * f(x)}.


kind: d
name: UnivariatePolynomial
exposed: x
type: (Symbol,R:Ring)->Join(UnivariatePolynomialCategory(R),etc)
params: (x,R)
abbrev: UP
comment:
This domain represents univariate polynomials in some symbol over arbitrary (not necessarily commutative) coefficient rings. The representation is sparse in the sense that only non-zero terms are represented.


kind: d
name: UnivariatePuiseuxSeries
exposed: n
params: (Coef,var,cen)
abbrev: UPXS
type:
(Coef:Ring,var:Symbol,cen:Coef)->Join(UnivariatePuiseuxSeriesConstructorCategory(Coef,UnivariateLaurentSeries(Coef,var,cen)),etc)

comment:
Dense Puiseux series in one variable \indented{2}{\spadtype{UnivariatePuiseuxSeries} is a domain representing Puiseux} \indented{2}{series in one variable with coefficients in an arbitrary ring.\space{2}The} \indented{2}{parameters of the type specify the coefficient ring,{} the power series} \indented{2}{variable,{} and the center of the power series expansion.\space{2}For example,{}} \indented{2}{\spad{UnivariatePuiseuxSeries(Integer,{} x,{} 3)} represents Puiseux series in} \indented{2}{\spad{(x - 3)} with \spadtype{Integer} coefficients.}


kind: d
name: UnivariatePuiseuxSeriesConstructor
exposed: n
params: (Coef,ULS)
abbrev: UPXSCONS
type:
(Coef:Ring,ULS:UnivariateLaurentSeriesCategory(Coef))->UnivariatePuiseuxSeriesConstructorCategory(Coef,ULS)

comment:
This package enables one to construct a univariate Puiseux series domain from a univariate Laurent series domain. Univariate Puiseux series are represented by a pair \spad{[r,{} f(x)]},{} where \spad{r} is a positive rational number and \spad{f(x)} is a Laurent series. This pair represents the Puiseux series \spad{f(x^r)}.


kind: d
name: UnivariatePuiseuxSeriesWithExponentialSingularity
exposed: n
params: (R,FE,var,cen)
abbrev: UPXSSING
type:
(R:Join(Comparable,etc),FE:Join(AlgebraicallyClosedField,etc),var:Symbol,cen:FE)->Join(FiniteAbelianMonoidRing(UnivariatePuiseuxSeries(FE,var,cen),ExponentialOfUnivariatePuiseuxSeries(FE,var,cen)),etc)

comment:
UnivariatePuiseuxSeriesWithExponentialSingularity is a domain used to represent functions with essential singularities. Objects in this domain are sums,{} where each term in the sum is a univariate Puiseux series times the exponential of a univariate Puiseux series. Thus,{} the elements of this domain are sums of expressions of the form \spad{g(x) * exp(f(x))},{} where \spad{g}(\spad{x}) is a univariate Puiseux series and \spad{f}(\spad{x}) is a univariate Puiseux series with no terms of non-negative degree.


kind: d
name: UnivariateSkewPolynomial
exposed: n
type: (Symbol,R:Ring,Automorphism(R),(R)->R)->Join(UnivariateSkewPolynomialCategory(R),etc)
params: (x,R,sigma,delta)
abbrev: OREUP
comment:
This is the domain of univariate skew polynomials over an Ore coefficient field in a named variable. The multiplication is given by \spad{x a = \sigma(a) x + \delta a}.


kind: d
name: UnivariateTaylorSeries
exposed: n
type: (Coef:Ring,var:Symbol,Coef)->Join(UnivariateTaylorSeriesCategory(Coef),etc)
params: (Coef,var,cen)
abbrev: UTS
comment:
Dense Taylor series in one variable \spadtype{UnivariateTaylorSeries} is a domain representing Taylor series in one variable with coefficients in an arbitrary ring. The parameters of the type specify the coefficient ring,{} the power series variable,{} and the center of the power series expansion. For example,{} \spadtype{UnivariateTaylorSeries}(Integer,{} \spad{x},{} 3) represents Taylor series in \spad{(x - 3)} with \spadtype{Integer} coefficients.


kind: d
name: UniversalSegment
exposed: x
type: (Type)->Join(SegmentCategory(S),etc)
params: (S)
abbrev: UNISEG
comment:
This domain provides segments which may be half open. That is,{} ranges of the form \spad{a..} or \spad{a..b}.


kind: d
name: Untyped
exposed: n
type: ()->VarCat
abbrev: UNTYPED
comment:
Untyped represents an untyped variable in Lambda and Ski domains,{} a variable has a name represented by a String.


kind: d
name: Vector
exposed: x
type: (Type)->Join(VectorCategory(R),etc)
params: (R)
abbrev: VECTOR
comment:
This type represents vector like objects with varying lengths and indexed by a finite segment of integers starting at 1.


kind: d
name: VectorIntegerReconstructor
exposed: n
type: ()->etc
abbrev: VECREC2
comment:
This domain supports modular methods based on \indented{1}{evaluation and rational reconstruction.\space{2}Each evaluation} \indented{1}{is done modulo machine sized prime \spad{p}.\space{2}Both Chinese} \indented{1}{remaindering and (linear) Hensel lift are supported.} \indented{1}{Once enough evaluations are known rational reconstruction} \indented{1}{produces vector of rational numbers or integers.}


kind: d
name: VectorModularReconstructor
exposed: n
type: ()->etc
abbrev: VECREC1
comment:
This domain supports modular methods based on \indented{1}{evaluation and rational reconstruction.\space{2}All computation} \indented{1}{are done on polynomials modulo machine sized prime \spad{p} \spad{--} \spad{p} must} \indented{1}{be chosen small enough to avoid overflow in intermediate} \indented{1}{calculations. Each evaluation is supposed to produce vector of} \indented{1}{values. Once enough evaluations are known rational reconstruction} \indented{1}{produces vector of rational functions or multivariate polynomials.}


kind: d
name: VectorSpaceBasis
exposed: n
type: (Field)->Join(BasicType,etc)
params: (R)
abbrev: VSBASIS
comment:
The domain \spad{VectorSpaceBasis F} implements subspaces of finite dimensional vector spaces over a field \spad{F}. A subspace is represented by a list of linearly independent coordinate vectors which constitute a basis. The empty list represents the space of dimension 0.


kind: d
name: Void
exposed: x
type: ()->etc
abbrev: VOID
comment:
This type is used when no value is needed,{} \spadignore{e.g.} in the \spad{then} part of a one armed \spad{if}. All values can be coerced to type Void. Once a value has been coerced to Void,{} it cannot be recovered.


kind: d
name: WeightedGraph
exposed: n
type: (SetCategory,W:OrderedAbelianMonoid)->Join(FiniteGraph(S),etc)
params: (S,W)
abbrev: WGRPH
comment:
allows us to model weighted graphs This graph assigns a weight to each arrow. This is used when calculating say,{} lowest 'cost' routes. An arrow with a higher weight is more 'costly' in some way and therefore we try to choose the minimum weight. For arrows in series the overall weight is the sum of the individual weights. For arrows in parallel the overall weight is the minimum of the individual weights. \spad{I} may change this in future to allow different cost metrics to be plugged in. \blankline


kind: d
name: WeightedPolynomials
exposed: n
params: (R,VarSet,E,P,vl,wl,wtlevel)
abbrev: WP
type:
(R:Ring,VarSet:OrderedSet,E:OrderedAbelianMonoidSup,P:PolynomialCategory(R,E,VarSet),List(VarSet),List(NonNegativeInteger),NonNegativeInteger)->Join(Ring,etc)

comment:
This domain represents truncated weighted polynomials over a general (not necessarily commutative) polynomial type. The variables must be specified,{} as must the weights. The representation is sparse in the sense that only non-zero terms are represented.


kind: d
name: WuWenTsunTriangularSet
exposed: x
params: (R,E,V,P)
abbrev: WUTSET
type:
(R:IntegralDomain,E:OrderedAbelianMonoidSup,V:OrderedSet,P:RecursivePolynomialCategory(R,E,V))->Join(TriangularSetCategory(R,E,V,P),etc)

comment:
A domain constructor of the category \spadtype{GeneralTriangularSet}. The only requirement for a list of polynomials to be a member of such a domain is the following: no polynomial is constant and two distinct polynomials have distinct main variables. Such a triangular set may not be auto-reduced or consistent. The \spadopFrom{construct}{WuWenTsunTriangularSet} operation does not check the previous requirement. Triangular sets are stored as sorted lists \spad{w}.\spad{r}.\spad{t}. the main variables of their members. Furthermore,{} this domain exports operations dealing with the characteristic set method of Wu Wen Tsun and some optimizations mainly proposed by Dong Ming Wang.\newline


kind: d
name: XDistributedPolynomial
exposed: n
type: (OrderedSet,R:Ring)->Join(XPolynomialsCat(vl,R),etc)
params: (vl,R)
abbrev: XDPOLY
comment:
\indented{2}{This type supports distributed multivariate polynomials} whose variables do not commute. The coefficient ring may be non-commutative too. However,{} coefficients and variables commute.


kind: d
name: XHashTable
exposed: n
type: (Hashable,Entry:Type)->Join(TableAggregate(Key,Entry),etc)
params: (Key,Entry)
abbrev: XHASHTBL
comment:
An implementation of a hash table that uses equality of the key domain to decide upon equality of keys.


kind: d
name: XmlAttribute
exposed: n
type: ()->etc
abbrev: XMLAT
comment:
This package provides support for \spad{XML} files \spad{XML} attributes are inside the opening tag: <tagname attributes> and usually have the form: name=value


kind: d
name: XmlElement
exposed: n
type: ()->etc
abbrev: XMLEL
comment:
This package provides support for \spad{XML} files an \spad{XML} element is something which either has the form: <tagname attributes> content </tagname> or <tagname attributes/> where content may be a sequence of sub-elements or unstructured text


kind: d
name: XPBWPolynomial
exposed: n
type: (OrderedSet,R:CommutativeRing)->Join(XPolynomialsCat(VarSet,R),etc)
params: (VarSet,R)
abbrev: XPBWPOLY
comment:
This domain constructor implements polynomials in non-commutative variables written in the Poincare-Birkhoff-Witt basis from the Lyndon basis. These polynomials can be used to compute Baker-Campbell-Hausdorff relations. \newline Author: Michel Petitot (petitot@lifl.\spad{fr}).


kind: d
name: XPolynomial
exposed: n
type: (Ring)->Join(XPolynomialsCat(Symbol,R),etc)
params: (R)
abbrev: XPOLY
comment:
\indented{2}{This type supports multivariate polynomials} whose set of variables is \spadtype{Symbol}. The representation is recursive. The coefficient ring may be non-commutative and the variables do not commute. However,{} coefficients and variables commute.


kind: d
name: XPolynomialRing
exposed: n
type: (Ring,E:OrderedMonoid)->Join(XAlgebra(R),etc)
params: (R,E)
abbrev: XPR
comment:
This domain represents generalized polynomials with coefficients (from a not necessarily commutative ring),{} and words belonging to an arbitrary \spadtype{OrderedMonoid}. This type is used,{} for instance,{} by the \spadtype{XDistributedPolynomial} domain constructor where the Monoid is free.


kind: d
name: XRecursivePolynomial
exposed: n
type: (OrderedSet,R:Ring)->Join(XPolynomialsCat(VarSet,R),etc)
params: (VarSet,R)
abbrev: XRPOLY
comment:
\indented{2}{This type supports multivariate polynomials} whose variables do not commute. The representation is recursive. The coefficient ring may be non-commutative. Coefficients and variables commute.


kind: o
name: ~
exposed: n
type: (%)->%
params: dDirectedGraph(S)
comment:
The complement or inverse of a graph is a graph on the same vertices such that there is an arrow if and only if there is not an arrow in its compliment. That is,{} it is the compliment of the arrows but is not the set complement. for more information see: http://en.wikipedia.org/wiki/Complement_graph


kind: o
name: ~
exposed: n
type: (%)->%
params: dILogic
comment:
\spad{~(x)} returns the logical complement of \spad{x}. TODO not sure if complement should be included here? intuitionistic logic can have complement but has different axioms to complement in Boolean algebra. Equivalent capability can be provided by implication.


kind: o
name: -
exposed: n
type: (Stream(A))->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{- a} returns the power series negative of \spad{a}: \spad{- [a0,{} a1,{} ...] = [- a0,{} - a1,{} ...]}


kind: o
name: -
exposed: x
type: (%)->%
params: cGradedModule(R,E)
comment:
\spad{-g} is the additive inverse of \spad{g} in the module of elements of the same grade as \spad{g}.


kind: o
name: *
exposed: n
type: (A,Stream(A))->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{r * a} returns the power series scalar multiplication of \spad{r} by \spad{a}: \spad{r * [a0,{} a1,{} ...] = [r * a0,{} r * a1,{} ...]}


kind: o
name: =
exposed: n
type: (%,%)->Boolean
params: cVarCat
comment:
return \spad{true} if equal,{} that is names are equal and if there is a type then they must also be equal


kind: o
name: =
exposed: n
type: (%,%)->Boolean
params: dILogic
comment:
returns \spad{true} (boolean \spad{true}) if Intuitionistic Logic values are the same. Translates from Intuitionistic Logic to Boolean Logic


kind: o
name: =
exposed: n
type: (%,%)->Boolean
params: dLambda(UT)
comment:
return \spad{true} if equal (deep search) that is: all terms at all levels in tree must be alpha-equivalent to return \spad{true} That is the names,{} but not the deBruijn index,{} of the bound variables can be different. beta-equivalence is not implemented because it is not decidable.


kind: o
name: =
exposed: n
type: (%,%)->Boolean
params: dLatticeJoinOfMeets
comment:
returns \spad{true} (boolean \spad{true}) if intuitionisticLogic values are the same. Translates from Intuitionistic Logic to Boolean Logic


kind: o
name: =
exposed: n
type: (%,%)->Boolean
params: dSKICombinators(UT)
comment:
return \spad{true} if equal (deep search) that is: all terms at all levels in tree must be equal to return \spad{true} all terms must be exactly equal,{} not just equivalent,{} that is SKK=I will return \spad{false} even though 'SKK' and 'I' have the same effect


kind: o
name: +
exposed: n
type: (%,%)->%
params: cFiniteGraph(S)
comment:
\spad{x+y} computes sum of \spad{x} and \spad{y},{} that is disjoint union of nodes with arrows from appropriate input


kind: o
name: +
exposed: n
type: (%,%)->%
params: cSPointCategory
comment:
+(\spad{x},{} \spad{y}) gives addition add the corresponding elements of the vector or point. The type (vector or point) depends on the following table: vector + vector = vector point + vector = point point + point = invalid (but interpret as vector) Although,{} adding two points is not strictly a valid operation,{} we allow it here by interpreting the point as a vector relative to the origin. We do that because there are some useful short cuts,{} for instance,{} to find the central point between two points we can add them together and scalar multiply by 0.5.


kind: o
name: -
exposed: n
type: (%,%)->%
params: cSPointCategory
comment:
\spad{-(x,{} y)} gives subtraction subtract the corresponding elements of the vector or point. The type (vector or point) depends on the following table: vector - vector = vector point - vector = point vector - point = invalid (but interpret as point) point - point = invalid (but interpret as vector) Although,{} subtracting two points is not strictly a valid operation,{} we allow it here by interpreting the result as the vector distance between the two points.


kind: o
name: *
exposed: n
type: (D,%)->%
params: dJetLazyFunction(JB,D)
comment:
\spad{d*exp} is provided mainly for internal use,{} as basically all calculations should be performed within \spadtype{JetLazyFunction}.


kind: o
name: *
exposed: n
type: (%,%)->%
params: dIncidenceAlgebra(R,S)
comment:
\spad{x * y} is the product of the matrices \spad{x} and \spad{y}. Error: if the dimensions are incompatible.


kind: o
name: +
exposed: n
type: (%,%)->%
params: dIncidenceAlgebra(R,S)
comment:
\spad{x + y} is the sum of the matrices \spad{x} and \spad{y}. Error: if the dimensions are incompatible.


kind: o
name: *
exposed: n
type: (%,%)->DirectedGraph(Product(S,S))
params: dDirectedGraph(S)
comment:
\spad{*}(a,{}\spad{b}) returns a tensor product : the tensor product \spad{G*H} of graphs \spad{G} and \spad{H} is a graph such that the vertex set of \spad{G*H} is the Cartesian product \spad{V}(\spad{G}) \times \spad{V}(\spad{H}); and any two vertices (\spad{u},{} u') and (\spad{v},{} \spad{v'}) are adjacent in \spad{G} \times \spad{H} if and only if u' is adjacent with \spad{v'} and \spad{u} is adjacent with \spad{v}.


kind: o
name: *
exposed: n
type: (DoubleFloat,%)->%
params: cSPointCategory
comment:
*(\spad{s},{} \spad{x}) gives scalar multiplication Although,{} scalar multiplication is strictly only a valid operation for vectors and not points,{} we allow it here because there are some useful short cuts,{} for instance,{} to find the central point between two points we can add them together and scalar multiply by 0.5.


kind: o
name: *
exposed: n
type: (DoubleFloat,Point(DoubleFloat))->Point(DoubleFloat)
params: pTubePlotTools
comment:
\spad{s * p} returns a point whose coordinates are the scalar multiple of the point \spad{p} by the scalar \spad{s},{} preserving the color,{} or fourth coordinate,{} of \spad{p}.


kind: o
name: ^
exposed: n
type: (%,%)->%
params: dSmallOrdinal
comment:
\spad{o1^o2} returns \spad{o1} to power \spad{o2},{} where power is inductively defined using successive natural multiplication from the left


kind: o
name: *
exposed: n
type: (%,%)->FunctionGraph(Product(S,S))
params: dFunctionGraph(S)
comment:
tensor product : the tensor product \spad{G*H} of graphs \spad{G} and \spad{H} is a graph such that the vertex set of \spad{G*H} is the Cartesian product \spad{V}(\spad{G}) \times \spad{V}(\spad{H}); and any two vertices (\spad{u},{} u') and (\spad{v},{} \spad{v'}) are adjacent in \spad{G} \times \spad{H} if and only if u' is adjacent with \spad{v'} and \spad{u} is adjacent with \spad{v}. Cartesian product does apply to function graph produces two arrows out of every node


kind: o
name: ^
exposed: n
type: (Matrix(R),NonNegativeInteger)->Matrix(R)
params: pStorageEfficientMatrixOperations(R)
comment:
\spad{x ^ n} computes the \spad{n}-th power of a square matrix. The power \spad{n} is assumed greater than 1.


kind: o
name: *
exposed: n
type: (%,%)->MultifunctionGraph(Product(S,S))
params: dMultifunctionGraph(S)
comment:
tensor product : the tensor product \spad{G*H} of graphs \spad{G} and \spad{H} is a graph such that the vertex set of \spad{G*H} is the Cartesian product \spad{V}(\spad{G}) \times \spad{V}(\spad{H}); and any two vertices (\spad{u},{} u') and (\spad{v},{} \spad{v'}) are adjacent in \spad{G} \times \spad{H} if and only if u' is adjacent with \spad{v'} and \spad{u} is adjacent with \spad{v}.


kind: o
name: ^
exposed: n
type: (%,NonNegativeInteger)->%
params: dIncidenceAlgebra(R,S)
comment:
\spad{x ^ n} computes a non-negative integral power of the matrix \spad{x}. Error: if the matrix is not square.


kind: o
name: -
exposed: n
type: (Point(DoubleFloat),Point(DoubleFloat))->Point(DoubleFloat)
params: pTubePlotTools
comment:
\spad{p - q} computes and returns a point whose coordinates are the differences of the coordinates of two points \spad{p} and \spad{q},{} using the color,{} or fourth coordinate,{} of the first point \spad{p} as the color also of the point \spad{q}.


kind: o
name: +
exposed: n
type: (Point(DoubleFloat),Point(DoubleFloat))->Point(DoubleFloat)
params: pTubePlotTools
comment:
\spad{p + q} computes and returns a point whose coordinates are the sums of the coordinates of the two points \spad{p} and \spad{q},{} using the color,{} or fourth coordinate,{} of the first point \spad{p} as the color also of the point \spad{q}.


kind: o
name: ^
exposed: n
type: (%,PositiveInteger)->%
params: cDistributionCategory(R)
comment:
\spad{x^k} constructs the distribution of the \spad{k}th power of the random variable with distribution \spad{X} by picking every \spad{k}-th moment.


kind: o
name: *
exposed: n
type: (Stream(A),A)->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{a * r} returns the power series scalar multiplication of \spad{a} by \spad{r:} \spad{[a0,{} a1,{} ...] * r = [a0 * r,{} a1 * r,{} ...]}


kind: o
name: *
exposed: n
type: (Stream(A),Stream(A))->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{a * b} returns the power series (Cauchy) product of \spad{a} and \spad{b:} \spad{[a0,{} a1,{} ...] * [b0,{} b1,{} ...] = [c0,{} c1,{} ...]} where \spad{ck = sum(i + j = k,{} \spad{ai} * bk)}.


kind: o
name: -
exposed: n
type: (Stream(A),Stream(A))->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{a - b} returns the power series difference of \spad{a} and \spad{b}: \spad{[a0,{} a1,{} ..] - [b0,{} b1,{} ..] = [a0 - b0,{} a1 - b1,{} ..]}


kind: o
name: /
exposed: n
type: (Stream(A),Stream(A))->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{a / b} returns the power series quotient of \spad{a} by \spad{b}. An error message is returned if \spad{b} is not invertible. This function is used in fixed point computations.


kind: o
name: +
exposed: n
type: (Stream(A),Stream(A))->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{a + b} returns the power series sum of \spad{a} and \spad{b}: \spad{[a0,{} a1,{} ..] + [b0,{} b1,{} ..] = [a0 + b0,{} a1 + b1,{} ..]}


kind: o
name: *
exposed: n
type: (Stream(Coef),Stream(Coef))->Stream(Coef)
params: pStreamExponentialSeriesOperations(Coef)
comment:
\spad{a * b} returns the power series (Cauchy) product of \spad{a} and \spad{b:} \spad{[a0,{} a1,{} ...] * [b0,{} b1,{} ...] = [c0,{} c1,{} ...]} where \spad{ck = sum(i + j = k,{} binomial(k,{} i) * \spad{ai} * bj)}.


kind: o
name: ^
exposed: n
type: (Stream(Coef),Stream(Coef))->Stream(Coef)
params: pStreamTranscendentalFunctions(Coef)
comment:
\spad{st1 ^ st2} computes the power of a power series \spad{st1} by another power series \spad{st2}.


kind: o
name: <
exposed: x
type: (%,%)->Boolean
params: cPermutationCategory(S)
comment:
\spad{p < q} is an order relation on permutations. Note: this order is only total if and only if \spad{S} is totally ordered or \spad{S} is finite.


kind: o
name: <=
exposed: x
type: (%,%)->Boolean
params: dPermutationGroup(S)
comment:
\spad{gp1 <= gp2} returns \spad{true} if and only if {\em gp1} is a subgroup of {\em gp2}. Note: because of a bug in the parser you have to call this function explicitly by {\em gp1 <=\$(PERMGRP S) gp2}.


kind: o
name: -
exposed: x
type: (%,%)->%
params: cGradedModule(R,E)
comment:
\spad{g-h} is the difference of \spad{g} and \spad{h} in the module of elements of the same degree as \spad{g} and \spad{h}. Error: if \spad{g} and \spad{h} have different degrees.


kind: o
name: +
exposed: x
type: (%,%)->%
params: cGradedModule(R,E)
comment:
\spad{g+h} is the sum of \spad{g} and \spad{h} in the module of elements of the same degree as \spad{g} and \spad{h}. Error: if \spad{g} and \spad{h} have different degrees.


kind: o
name: -
exposed: x
type: (%,%)->%
params: cMatrixCategory(R,Row,Col)
abbrev: has(R,AbelianGroup)
comment:
\spad{x - y} is the difference of the matrices \spad{x} and \spad{y}. Error: if the dimensions are incompatible.


kind: o
name: ^
exposed: x
type: (%,Coef)->%
params: cUnivariateTaylorSeriesCategory(Coef)
abbrev: has(Coef,Field)
comment:
\spad{f(x) ^ a} computes a power of a power series. When the coefficient ring is a field,{} we may raise a series to an exponent from the coefficient ring provided that the constant coefficient of the series is 1.


kind: o
name: *
exposed: x
type: (%,Col)->Col
params: cMatrixCategory(R,Row,Col)
abbrev: has(R,SemiRng)
comment:
\spad{x * c} is the product of the matrix \spad{x} and the column vector \spad{c}. Error: if the dimensions are incompatible.


kind: o
name: -
exposed: x
type: (%,%)->%
params: cVectorCategory(R)
abbrev: has(R,AbelianGroup)
comment:
\spad{x - y} returns the component-wise difference of the vectors \spad{x} and \spad{y}. Error: if \spad{x} and \spad{y} are not of the same length.


kind: o
name: +
exposed: x
type: (%,%)->%
params: cVectorCategory(R)
abbrev: has(R,AbelianSemiGroup)
comment:
\spad{x + y} returns the component-wise sum of the vectors \spad{x} and \spad{y}. Error: if \spad{x} and \spad{y} are not of the same length.


kind: o
name: ^
exposed: x
type: (%,%)->%
params: dCardinalNumber
comment:
\spad{x^y} returns \spad{\#(X^Y)} where \spad{X^Y} is defined \indented{1}{as \spad{\{g| g: Y->X\}}.}


kind: o
name: *
exposed: x
type: (%,%)->%
params: dCartesianTensor(minix,dim,R)
comment:
\spad{s*t} is the inner product of the tensors \spad{s} and \spad{t} which contracts the last index of \spad{s} with the first index of \spad{t},{} \spadignore{i.e.} \indented{4}{\spad{t*s = contract(t,{} rank t,{} s,{} 1)}} \indented{4}{\spad{t*s = sum(k=1..N,{} t[i1,{} ..,{} iN,{} k]*s[k,{} j1,{} ..,{} jM])}} This is compatible with the use of \spad{M*v} to denote the matrix-vector inner product.


kind: o
name: /\
exposed: x
type: (%,%)->%
params: dCliffordAlgebra(n,K,bLin)
comment:
Implement exterior grassmann product operator need to check precedence when used as an infix operator


kind: o
name: \/
exposed: x
type: (%,%)->%
params: dCliffordAlgebra(n,K,bLin)
comment:
Implement regressive inner,{} meet product operator need to check precedence when used as an infix operator


kind: o
name: -
exposed: x
type: (%,%)->%
params: dDatabase(S)
comment:
\spad{db1-db2} returns the difference of databases \spad{db1} and \spad{db2} \spadignore{i.e.} consisting of elements in \spad{db1} but not in \spad{db2}


kind: o
name: /
exposed: x
type: (%,%)->%
params: dEquation(S)
abbrev: has(S,Field)
comment:
\spad{e1/e2} produces a new equation by dividing the left and right hand sides of equations \spad{e1} and \spad{e2}.


kind: o
name: /\
exposed: x
type: (%,%)->%
params: dSingleInteger
comment:
\spad{n} \spad{/\} \spad{m} returns the bit-by-bit logical {\em and} of the single integers \spad{n} and \spad{m}.


kind: o
name: \/
exposed: x
type: (%,%)->%
params: dSingleInteger
comment:
\spad{n} \spad{\/} \spad{m} returns the bit-by-bit logical {\em or} of the single integers \spad{n} and \spad{m}.


kind: o
name: ^
exposed: x
type: (%,Integer)->%
params: cMatrixCategory(R,Row,Col)
abbrev: has(R,Field)
comment:
\spad{m^n} computes an integral power of the matrix \spad{m}. Error: if matrix is not square or if the matrix is square but not invertible.


kind: o
name: ^
exposed: x
type: (%,Integer)->%
params: cSquareMatrixCategory(ndim,R,Row,Col)
abbrev: has(R,Field)
comment:
\spad{m^n} computes an integral power of the matrix \spad{m}. Error: if the matrix is not invertible.


kind: o
name: *
exposed: x
type: (PositiveInteger,%)->%
params: cAbelianSemiGroup
comment:
\spad{n*x} computes the left-multiplication of \spad{x} by the positive integer \spad{n}. This is equivalent to adding \spad{x} to itself \spad{n} times.


kind: o
name: *
exposed: x
type: (R,%)->%
params: cLeftModule(R)
comment:
\spad{r*x} returns the left multiplication of the module element \spad{x} by the ring element \spad{r}.


kind: o
name: *
exposed: x
type: (%,R)->%
params: cRightModule(R)
comment:
\spad{x*r} returns the right multiplication of the module element \spad{x} by the ring element \spad{r}.


kind: o
name: *
exposed: x
type: (%,R)->%
params: cXFreeAlgebra(vl,R)
comment:
\spad{x * r} returns the product of \spad{x} by \spad{r}. Useful if \spad{R} is a non-commutative Ring.


kind: o
name: *
exposed: x
type: (Row,%)->Row
params: cMatrixCategory(R,Row,Col)
abbrev: has(R,SemiRng)
comment:
\spad{r * x} is the product of the row vector \spad{r} and the matrix \spad{x}. Error: if the dimensions are incompatible.


kind: o
name: -
exposed: x
type: (%,%)->Union(%,failed)
params: dCardinalNumber
comment:
\spad{x - y} returns an element \spad{z} such that \spad{z+y=x} or failed if no such element exists.


kind: o
name: abelianGroup
exposed: x
type: (List(PositiveInteger))->PermutationGroup(Integer)
params: pPermutationGroupExamples
comment:
\spad{abelianGroup([n1,{} ...,{} nk])} constructs the abelian group that is the direct product of cyclic groups with order {\em \spad{ni}}.


kind: o
name: abs
exposed: x
type: (%)->R
params: cOctonionCategory(R)
abbrev: has(R,RealNumberSystem)
comment:
\spad{abs(o)} computes the absolute value of an octonion,{} equal to the square root of the \spadfunFrom{norm}{Octonion}.


kind: o
name: acos
exposed: x
type: (%)->%
params: cArcTrigonometricFunctionCategory
comment:
\spad{acos(x)} returns the arc-cosine of \spad{x}. When evaluated into some subset of the complex numbers,{} one branch cut for acos lies along the negative real axis to the left of \spad{-1} (inclusive),{} continuous with the upper half plane,{} the other along the positive real axis to the right of 1 (inclusive),{} continuous with the lower half plane.


kind: o
name: adaptive
exposed: x
type: (Boolean)->Boolean
params: pGraphicsDefaults
comment:
\spad{adaptive(true)} turns adaptive plotting on; \spad{adaptive(false)} turns adaptive plotting off.


kind: o
name: adaptive
exposed: x
type: (Boolean)->%
params: dDrawOption
comment:
\spad{adaptive(b)} turns adaptive 2D plotting on if \spad{b} is \spad{true},{} or off if \spad{b} is \spad{false}. This option is expressed in the form \spad{adaptive == b}.


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


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


kind: o
name: addArrow!
exposed: n
params: xFiniteGraph&(A,S)
type:
(A,Record(name:String,arrType:NonNegativeInteger,fromOb:NonNegativeInteger,toOb:NonNegativeInteger,xOffset:Integer,yOffset:Integer,map:List(NonNegativeInteger)))->A


kind: o
name: addArrow!
exposed: n
params: cFiniteGraph(S)
comment: \spad{addArrow!(s,{} ar)} adds an arrow ar to the graph \spad{s}
type:
(%,Record(name:String,arrType:NonNegativeInteger,fromOb:NonNegativeInteger,toOb:NonNegativeInteger,xOffset:Integer,yOffset:Integer,map:List(NonNegativeInteger)))->%


kind: o
name: addArrow
exposed: n
type: (%,S,S)->%
params: cPoset(S)
comment:
\spad{addArrow(s,{} nm,{} n1,{} n2)} constructs new poset by adding to the poset \spad{s} arrow from \spad{n1} to \spad{n2}.


kind: o
name: addArrow!
exposed: n
type: (%,String,NonNegativeInteger,NonNegativeInteger)->%
params: cFiniteGraph(S)
comment:
\spad{addArrow!(s,{} nm,{} n1,{} n2)} adds an arrow to the graph \spad{s},{} where: \spad{nm} is the name of the arrow \spad{n1} is the index of the start object \spad{n2} is the index of the end object


kind: o
name: addArrow!
exposed: n
type: (%,String,S,S)->%
params: cFiniteGraph(S)
comment:
\spad{addArrow!(s,{} nm,{} o1,{} o2)} adds an arrow to the graph \spad{s},{} where: \spad{nm} is the name of the arrow \spad{o1} is the start object \spad{o2} is the end object


kind: o
name: addArrow!
exposed: n
type: (%,String,NonNegativeInteger,NonNegativeInteger,List(NonNegativeInteger))->%
params: cFiniteGraph(S)
comment:
\spad{addArrow!(s,{} nm,{} n1,{} n2,{} mp)} adds an arrow to the graph \spad{s},{} where: \spad{nm} is the name of the arrow \spad{n1} is the index of the start object \spad{n2} is the index of the end object \spad{mp} is a map represented by this arrow


kind: o
name: addArrows2Din2D
exposed: n
type: (%,(PT)->PT,Segment(DoubleFloat),Segment(DoubleFloat),NonNegativeInteger)->%
params: dScene(PT)
comment:
\spad{addArrows2Din2D(n,{} ptFun,{} uSeg,{} vSeg,{} numPts)} is a convenience function which combines createArrows2Din2D with addChild!


kind: o
name: addBadValue
exposed: n
type: (%,Any)->%
params: dPattern(R)
comment:
\spad{addBadValue(p,{} v)} adds \spad{v} to the list of bad values for \spad{p}. Note: \spad{p} is not allowed to match any of its bad values.


kind: o
name: addBadValue
exposed: n
type: (Pattern(R),D)->Pattern(R)
params: pPatternFunctions1(R,D)
comment:
\spad{addBadValue(p,{} v)} adds \spad{v} to the list of bad values for \spad{p}; \spad{p} is not allowed to match any of its bad values.


kind: o
name: addColumns!
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger,F)->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{addColumns!(f,{} i,{} j,{} alpha)} adds alpha*column(\spad{i}) to column(\spad{j}) in A and subtracts row(\spad{j}) from row(\spad{i}) in \spad{s} (in the ALS of \spad{f}),{} \spadignore{i.e.} (A*U)(U^-1*s) = \spad{v}.


kind: o
name: addColumns!
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger,R)->%
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{addColumns!(p,{} i,{} j,{} alpha)} adds alpha*column(\spad{i}) to column(\spad{j}) in all matrices of the linear pencil \spad{p}.


kind: o
name: addColumnsRows!
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger,F)->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{addColumnsRows!(f,{} i,{} j,{} alpha)} adds alpha*column(\spad{i}) to column(\spad{j}) and subtracts alpha*row(\spad{j}) from row(\spad{i}) in the ALS of \spad{f}.


kind: o
name: addCube
exposed: n
type: (%,CubicalFacet)->%
params: dFiniteCubicalComplex(VS)
comment:
Add a facet to this simplex If the facet is also in the list then,{} do not append,{} instead change the multiplier.


kind: o
name: addiag
exposed: n
type: (Stream(Stream(A)))->Stream(A)
params: pStreamTaylorSeriesOperations(A)
comment:
\spad{addiag(x)} performs diagonal addition of a stream of streams. if \spad{x} = \spad{[[a<0,{} 0>,{} a<0,{} 1>,{} ..],{} [a<1,{} 0>,{} a<1,{} 1>,{} ..],{} [a<2,{} 0>,{} a<2,{} 1>,{} ..],{} ..]} and \spad{addiag(x) = [b<0,{} b<1>,{} ...],{} then b<k> = sum(i+j=k,{} a<i,{} j>)}.


kind: o
name: addImpliedFaces
exposed: n
type: (%)->List(List(CubicalFacet))
params: dFiniteCubicalComplex(VS)
comment:
a function to take a set of faces and add those that are implied by the cubicalComplex conventions (if they don\spad{'t} already exist). For example,{} if the input is a square [1..2,{} 1..2] then we would add its edges [1..1,{} 1..2],{} [2..2,{} 1..2],{} [1..2,{} 1..1],{} and [1..2,{} 2..2].


kind: o
name: addImpliedFaces
exposed: n
type: (%)->List(List(OrientedFacet))
params: dFiniteSimplicialComplex(VS)
comment:
a function to take a set of faces and add those that are implied by the simplecicalComplex conventions (if they don\spad{'t} already exist). For example,{} if the input is a triangle ((1,{} 2,{} 3)) then we would add: its points ((1),{} (2),{} (3)). and its edges ((1,{} 2),{} (1,{} 3),{} (2,{} 3)).


kind: o
name: addMatch
exposed: n
type: (Pattern(R),S,%)->%
params: dPatternMatchResult(R,S)
comment:
\spad{addMatch(var,{} expr,{} r)} adds the match (\spad{var},{} \spad{expr}) in \spad{r},{} provided that \spad{expr} satisfies the predicates attached to \spad{var},{} and that \spad{var} is not matched to another expression already.


kind: o
name: addMatchRestricted
exposed: n
type: (Pattern(R),S,%,S)->%
params: dPatternMatchResult(R,S)
comment:
\spad{addMatchRestricted(var,{} expr,{} r,{} val)} adds the match (\spad{var},{} \spad{expr}) in \spad{r},{} provided that \spad{expr} satisfies the predicates attached to \spad{var},{} that \spad{var} is not matched to another expression already,{} and that either \spad{var} is an optional pattern variable or that \spad{expr} is not equal to val (usually an identity).


kind: o
name: addObject!
exposed: n
type: (%,S)->%
params: cFiniteGraph(S)
comment:
\spad{addObject!(s,{} n)} adds object \spad{n} to the graph \spad{s}. Use this version if you don\spad{'t} intend to create diagrams and therefore don\spad{'t} care about \spad{x},{} \spad{y} coordinates.


kind: o
name: addPlot1Din2D
exposed: n
type: (%,(DoubleFloat)->DoubleFloat,Segment(DoubleFloat),NonNegativeInteger)->%
params: dScene(PT)
comment:
\spad{addPlot1Din2D(n,{} f,{} tRange,{} numPts)} is a convenience function which combines createPlot1Din2D with addChild!


kind: o
name: addPlot1Din2Dparametric
exposed: n
type: (%,ParametricPlaneCurve((DoubleFloat)->DoubleFloat),Segment(DoubleFloat),NonNegativeInteger)->%
params: dScene(PT)
comment:
\spad{addPlot1Din2Dparametric(n,{} ppc,{} tRange,{} numPts)} is a convenience function which combines createPlot1Din2Dparametric with addChild!


kind: o
name: addPlot1Din3Dparametric
exposed: n
type: (%,(DoubleFloat)->PT,Segment(DoubleFloat),NonNegativeInteger)->%
params: dScene(PT)
comment:
\spad{addPlot1Din3Dparametric(n,{} pcfun,{} tRange,{} numPts)} is a convenience function which combines createPlot1Din3Dparametric with addChild!


kind: o
name: addPlot1Din3Dparametric
exposed: n
type: (%,ParametricSpaceCurve((DoubleFloat)->DoubleFloat),Segment(DoubleFloat),NonNegativeInteger)->%
params: dScene(PT)
comment:
\spad{addPlot1Din3Dparametric(n,{} psc,{} tRange,{} numPts)} is a convenience function which combines createPlot1Din3Dparametric with addChild!


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

comment:
\spad{addPlot2Din3D(n,{} f,{} uSeg,{} vSeg,{} numPts)} is a convenience function which combines createPlot2Din3D with addChild!


kind: o
name: addPlot2Din3Dparametric
exposed: n
type: (%,(DoubleFloat,DoubleFloat)->PT,Segment(DoubleFloat),Segment(DoubleFloat),NonNegativeInteger)->%
params: dScene(PT)
comment:
\spad{addPlot2Din3Dparametric(n,{} f,{} uSeg,{} vSeg,{} numPts)} is a convenience function which combines createPlot2Din3Dparametric with addChild!


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

comment:
\spad{addPlot2Din3Dparametric(n,{} f,{} uSeg,{} vSeg,{} numPts)} is a convenience function which combines createPlot2Din3Dparametric with addChild!


kind: o
name: addPoint2
exposed: n
type: (%,Point(R))->%
params: dSubSpace(n,R)
comment:
\spad{addPoint2(s,{} p)} adds the 4 dimensional point,{} \spad{p},{} to the 3 dimensional subspace,{} \spad{s}. The subspace \spad{s} is returned with the additional point.


kind: o
name: addPoint
exposed: n
type: (%,Point(R))->NonNegativeInteger
params: dSubSpace(n,R)
comment:
\spad{addPoint(s,{} p)} adds the point,{} \spad{p},{} to the 3 dimensional subspace,{} \spad{s},{} and returns the new total number of points in \spad{s}.


kind: o
name: addPoint
exposed: n
type: (%,List(NonNegativeInteger),NonNegativeInteger)->%
params: dSubSpace(n,R)
comment:
\spad{addPoint(s,{} \spad{li},{} i)} adds the 4 dimensional point indicated by the index location,{} \spad{i},{} to the 3 dimensional subspace,{} \spad{s}. The list of non negative integers,{} \spad{li},{} dictates the path to follow,{} or,{} to look at it another way,{} points to the component in which the point is to be added. It\spad{'s} length should range from 0 to \spad{n - 1} where \spad{n} is the dimension of the subspace. If the length is \spad{n - 1},{} then a specific lowest level component is being referenced. If it is less than \spad{n - 1},{} then some higher level component (0 indicates top level component) is being referenced and a component of that level with the desired point is created. The subspace \spad{s} is returned with the additional point.


kind: o
name: addPoint
exposed: n
type: (%,List(NonNegativeInteger),Point(R))->%
params: dSubSpace(n,R)
comment:
\spad{addPoint(s,{} \spad{li},{} p)} adds the 4 dimensional point,{} \spad{p},{} to the 3 dimensional subspace,{} \spad{s}. The list of non negative integers,{} \spad{li},{} dictates the path to follow,{} or,{} to look at it another way,{} points to the component in which the point is to be added. It\spad{'s} length should range from 0 to \spad{n - 1} where \spad{n} is the dimension of the subspace. If the length is \spad{n - 1},{} then a specific lowest level component is being referenced. If it is less than \spad{n - 1},{} then some higher level component (0 indicates top level component) is being referenced and a component of that level with the desired point is created. The subspace \spad{s} is returned with the additional point.


kind: o
name: addPointLast
exposed: n
type: (%,%,Point(R),NonNegativeInteger)->%
params: dSubSpace(n,R)
comment:
\spad{addPointLast(s,{} s2,{} \spad{li},{} p)} adds the 4 dimensional point,{} \spad{p},{} to the 3 dimensional subspace,{} \spad{s}. \spad{s2} point to the end of the subspace \spad{s}. \spad{n} is the path in the \spad{s2} component. The subspace \spad{s} is returned with the additional point.


kind: o
name: addRows!
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger,F)->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{addRows!(f,{} i,{} j,{} alpha)} adds alpha*row(\spad{i}) to row(\spad{j}) in the ALS of \spad{f}.


kind: o
name: addRows!
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger,R)->%
params: dLinearMultivariateMatrixPencil(R)
comment:
\spad{addRows!(p,{} i,{} j,{} alpha)} adds alpha*row(\spad{i}) to row(\spad{j}) in all matrices of the linear pencil \spad{p}.


kind: o
name: addRowsColumns!
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger,F)->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{addRowsColumns!(f,{} i,{} j,{} alpha)} adds alpha*row(\spad{i}) to row(\spad{j}) and subtracts alpha*column(\spad{j}) from column(\spad{i}) in the ALS of \spad{f}.


kind: o
name: addSceneArrow
exposed: n
type: (%,String,String,PT,Symbol,DoubleFloat)->%
params: dScene(PT)
comment:
\spad{addSceneArrow(n,{} st,{} en,{} offset,{} mode,{} size)} is a convenience function which combines createSceneArrow with addChild!


kind: o
name: addSceneArrow
exposed: n
type: (%,%,%,PT,Symbol,DoubleFloat,DoubleFloat)->%
params: dScene(PT)
comment:
\spad{addSceneArrow(n,{} st,{} en,{} offset,{} mode,{} size,{} fontScale)} is a convenience function which combines createSceneArrow with addChild!


kind: o
name: addSceneArrows
exposed: n
type: (%,List(List(PT)),Symbol,DoubleFloat)->%
params: dScene(PT)
comment:
\spad{addSceneArrows(n,{} line,{} mode,{} size)} is a convenience function which combines createSceneArrows with addChild!


kind: o
name: addSceneBox
exposed: n
type: (%,DoubleFloat)->%
params: dScene(PT)
comment:
\spad{addSceneBox(n,{} size)} is a convenience function which combines createSceneBox with addChild!


kind: o
name: addSceneClip
exposed: n
type: (%,SBoundary(PT))->%
params: dScene(PT)
comment:
\spad{addSceneClip(n,{} bb)} is a convenience function which combines createSceneClip with addChild!


kind: o
name: addSceneDef
exposed: n
type: (%,String,%)->%
params: dScene(PT)
comment:
\spad{addSceneDef(n,{} nam,{} nde)} is a convenience function which combines createSceneDef with addChild!


kind: o
name: addSceneGraph
exposed: n
type: (%,DirectedGraph(String),NonNegativeInteger,NonNegativeInteger,Boolean)->%
params: dScene(PT)
comment:
\spad{addSceneGraph(n,{} g,{} x,{} y,{} dispArrowName)} is a convenience function which combines createSceneGraph with addChild!


kind: o
name: addSceneGrid
exposed: n
type: (%,SBoundary(PT))->%
params: dScene(PT)
comment:
\spad{addSceneGrid(n,{} bb)} is a convenience function which combines createSceneGrid with addChild!


kind: o
name: addSceneGrid
exposed: n
type: (%,DoubleFloat,SBoundary(PT))->%
params: dScene(PT)
comment:
\spad{addSceneGrid(n,{} stepSize,{} bb)} is a convenience function which combines createSceneGrid with addChild!


kind: o
name: addSceneIFS
exposed: n
type: (%,List(List(NonNegativeInteger)),List(PT))->%
params: dScene(PT)
comment:
\spad{addSceneIFS(n,{} inx,{} pts)} is a convenience function which combines createSceneIFS with addChild!


kind: o
name: addSceneLine
exposed: n
type: (%,List(PT))->%
params: dScene(PT)
comment:
\spad{addSceneLine(n,{} line)} is a convenience function which combines createSceneLine with addChild!


kind: o
name: addSceneLine
exposed: n
type: (%,%,%,DoubleFloat)->%
params: dScene(PT)
comment:
\spad{addSceneLine(n,{} st,{} en,{} fontScale)} is a convenience function which combines createSceneLine with addChild!


kind: o
name: addSceneLines
exposed: n
type: (%,List(List(PT)))->%
params: dScene(PT)
comment:
\spad{addSceneLines(n,{} line)} is a convenience function which combines createSceneLines with addChild!


kind: o
name: addSceneMaterial
exposed: n
type: (%,Record(lineWidth:DoubleFloat,lineCol:String,fillCol:String,matOpacity:DoubleFloat))->%
params: dScene(PT)
comment:
\spad{addSceneMaterial(n,{} mat)} is a convenience function which combines createSceneMaterial with addChild!


kind: o
name: addSceneMaterial
exposed: n
type: (%,DoubleFloat,String,String)->%
params: dScene(PT)
comment:
\spad{addSceneMaterial(n,{} lineW,{} lineC,{} fillC)} is a convenience function which combines createSceneMaterial with addChild!


kind: o
name: addSceneNamedPoints
exposed: n
type: (%,SceneNamedPoints(PT))->%
params: dScene(PT)
comment:
\spad{addSceneNamedPoints(n,{} np)} is a convenience function which combines createSceneNamedPoints with addChild!


kind: o
name: addScenePattern
exposed: n
type: (%,Symbol,NonNegativeInteger,SBoundary(PT))->%
params: dScene(PT)
comment:
\spad{addScenePattern(n,{} ptype,{} step,{} bb)} is a convenience function which combines createScenePattern with addChild!


kind: o
name: addSceneRuler
exposed: n
type: (%,Symbol,PT,SBoundary(PT))->%
params: dScene(PT)
comment:
\spad{addSceneRuler(n,{} ptype,{} offset,{} bb)} is a convenience function which combines createSceneRuler with addChild!


kind: o
name: addSceneShape
exposed: n
type: (%,Record(shptype:Symbol,centre:PT,size:PT,fill:Boolean))->%
params: dScene(PT)
comment:
\spad{addSceneShape(n,{} shape)} is a convenience function which combines createSceneShape with addChild!


kind: o
name: addSceneText
exposed: n
type: (%,Record(txt:String,siz:NonNegativeInteger,pos:PT,np:List(String)))->%
params: dScene(PT)
comment:
\spad{addSceneText(n,{} text)} is a convenience function which combines createSceneText with addChild!


kind: o
name: addSceneText
exposed: n
type: (%,List(String),NonNegativeInteger,PT)->%
params: dScene(PT)
comment:
\spad{addSceneText(n,{} str,{} sz,{} pz)} is a convenience function which combines createSceneText with addChild!


kind: o
name: addSceneTransform
exposed: n
type: (%,STransform(PT))->%
params: dScene(PT)
comment:
\spad{addSceneTransform(n,{} tran)} is a convenience function which combines createSceneTransform with addChild!


kind: o
name: addSimplex
exposed: n
type: (%,OrientedFacet)->%
params: dFiniteSimplicialComplex(VS)
comment:
Add a facet to this simplex If the facet is also in the list then,{} do not append,{} instead change the multiplier. Used by boundary function


kind: o
name: addWarning
exposed: n
type: (OutputForm)->Void
params: pUnittestCount
comment:
\spad{addWarning s} is an internal function that adds \spad{s},{} together with an indication of the current testcase and the current testsuite to the list of warnings.


kind: o
name: addWArrow!
exposed: n
type: (%,String,NonNegativeInteger,NonNegativeInteger,W)->%
params: dWeightedGraph(S,W)
comment:
\spad{addWArrow!(s,{} name,{} n1,{} n2,{} w)} adds a weighted arrow to the graph \spad{s},{} where \spad{name} is \spad{name} of the arrow,{} \spad{w} is weight of the arrow,{} \spad{n1} is starting point of the arrow,{} \spad{n2} is endpoint of the arrow.


kind: o
name: adjacencyMatrix
exposed: n
type: (%)->Matrix(NonNegativeInteger)
params: cFiniteGraph(S)
comment:
\spad{adjacencyMatrix(s)} returns an \spad{n} by \spad{n} matrix A,{} where \spad{n} is the number of vertices in the graph. If there is an edge from a vertex \spad{x} to a vertex \spad{y},{} then the element ax,{} \spad{y} is 1 (or in general the number of xy edges),{} otherwise it is 0. In computing,{} this matrix makes it easy to find subgraphs,{} and to reverse a directed graph.


kind: o
name: adjoint
exposed: x
type: (M)->Record(adjMat:M,detMat:R)
params: pMatrixLinearAlgebraFunctions(R,Row,Col,M)
abbrev: has(R,IntegralDomain)
comment:
\spad{adjoint(m)} returns the ajoint matrix of \spad{m} (\spadignore{i.e.} the matrix \spad{n} such that \spad{m*n} = determinant(\spad{m})*id) and the detrminant of \spad{m}.


kind: o
name: adjoint
exposed: x
type: (%,%)->%
params: dModuleOperator(R,M)
abbrev: has(R,CommutativeRing)
comment:
\spad{adjoint(op1,{} op2)} sets the adjoint of \spad{op1} to be \spad{op2}. \spad{op1} must be a basic operator


kind: o
name: algDepHP
exposed: n
params: pGuessAlgebraicNumber
type:
(List(List(AlgebraicNumber)),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: algDepHP
exposed: x
params: pGuessFinite(F)
type:
(List(List(F)),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: algDepHP
exposed: x
params: pGuess(F,S,EXPRR,retract,coerce)
type:
(List(List(F)),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{algDepHP(list,{} options)} returns a specification for Hermite-Pade approximation looking for algebraic dependencies


kind: o
name: algDepHP
exposed: x
params: pGuessInteger
type:
(List(List(Fraction(Integer))),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: algDepHP
exposed: x
params: pGuessPolynomialInteger
type:
(List(List(Fraction(Polynomial(Integer)))),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: algDepHP
exposed: x
params: pGuessPolynomial(R)
type:
(List(List(Fraction(Polynomial(R)))),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: algDsolve
exposed: n
params: pPureAlgebraicLODE(F,UP,UPUP,R)
comment: \spad{algDsolve(op,{} lg)} is a parametric version of algDsolve(\spad{op},{} \spad{g})
type:
(LinearOrdinaryDifferentialOperator1(R),List(R))->Record(particular:List(Record(ratpart:R,coeffs:Vector(F))),basis:List(R))


kind: o
name: algDsolve
exposed: n
type: (LinearOrdinaryDifferentialOperator1(R),R)->Record(particular:Union(R,failed),basis:List(R))
params: pPureAlgebraicLODE(F,UP,UPUP,R)
comment:
\spad{algDsolve(op,{} g)} returns \spad{[failed,{} []]} if the equation \spad{op y = g} has no solution in \spad{R}. Otherwise,{} it returns \spad{[f,{} [y1,{} ...,{} ym]]} where \spad{f} is a particular rational solution and the \spad{y_i's} form a basis for the solutions in \spad{R} of the homogeneous equation.


kind: o
name: algebraic?
exposed: x
type: (%)->Boolean
params: cExtensionField(F)
comment:
\spad{algebraic?(a)} tests whether an element \spad{a} is algebraic with respect to the ground field \spad{F}.


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


kind: o
name: algebraicCoefficients?
exposed: x
type: (P,%)->Boolean
params: cRegularTriangularSetCategory(R,E,V,P)
comment:
\spad{algebraicCoefficients?(p,{} ts)} returns \spad{true} iff every variable of \spad{p} which is not the main one of \spad{p} is algebraic \spad{w}.\spad{r}.\spad{t}. \spad{ts}.


kind: o
name: algebraicGcd
exposed: n
params: pModularAlgebraicGcd(MPT,MD,MO)
type:
(Polynomial(Integer),Polynomial(Integer),List(Polynomial(Integer)),List(Symbol),Symbol,List(Symbol))->Polynomial(Integer)


kind: o
name: algebraicGcd
exposed: n
type: (PT,PT,List(PT),List(Symbol),Symbol,List(Symbol))->Polynomial(Integer)
params: pModularAlgebraicGcd2(PT,MP,MPT,MD,ME,MO)
comment:
\spad{algebraicGcd(x,{} y,{} lm,{} lp,{} v,{} la)} computes \spad{gcd} of \spad{x} and \spad{y} modulo polynomials in \spad{lm}. la is list of algebraic parameters,{} \spad{lp} is a list of transcendental parameters,{} \spad{v} is main variable.


kind: o
name: algebraicSort
exposed: x
type: (List(TS))->List(TS)
params: pQuasiComponentPackage(R,E,V,P,TS)
comment:
\spad{algebraicSort(lts)} sorts \spad{lts} \spad{w}.\spad{r}.\spad{t} \spadopFrom{supDimElseRittWu?}{QuasiComponentPackage}.


kind: o
name: algebraicSort
exposed: x
type: (List(TS))->List(TS)
params: pSquareFreeQuasiComponentPackage(R,E,V,P,TS)
comment:
\spad{algebraicSort(lts)} sorts \spad{lts} \spad{w}.\spad{r}.\spad{t} \spadopFrom{supDimElseRittWu}{QuasiComponentPackage}.


kind: o
name: algebraicVariables
exposed: x
type: (%)->List(V)
params: cTriangularSetCategory(R,E,V,P)
comment:
\spad{algebraicVariables(ts)} returns the decreasingly sorted list of the main variables of the polynomials of \spad{ts}.


kind: o
name: algextint
exposed: n
params: pAlgebraicIntegrate2(R0,F,UP,UPUP,R)
type:
((UP)->UP,(List(Fraction(UP)))->List(Record(ratpart:Fraction(UP),coeffs:Vector(F))),(Fraction(UP),List(Fraction(UP)))->List(Record(ratpart:Fraction(UP),coeffs:Vector(F))),(Matrix(F))->List(Vector(F)),List(R))->List(Record(ratpart:R,coeffs:Vector(F)))

comment:
\spad{algextint(der,{} ext,{} rde,{} csolve,{} [g1,{} ...,{} gn])} returns a basis of solutions of the homogeneous system \spad{h' + c1*g1 + ... + cn*gn = 0}. Argument \spad{ext} is an extended integration function on \spad{F},{} \spad{rde} is RDE solver,{} \spad{csolve} is linear solver over constants.


kind: o
name: algextint
exposed: n
params: pAlgebraicIntegration(R,F)
type:
(Kernel(F),Kernel(F),(SparseUnivariatePolynomial(F))->SparseUnivariatePolynomial(F),(List(Fraction(SparseUnivariatePolynomial(F))))->List(Record(ratpart:Fraction(SparseUnivariatePolynomial(F)),coeffs:Vector(F))),(Fraction(SparseUnivariatePolynomial(F)),List(Fraction(SparseUnivariatePolynomial(F))))->List(Record(ratpart:Fraction(SparseUnivariatePolynomial(F)),coeffs:Vector(F))),(Matrix(F))->List(Vector(F)),List(F))->List(Record(ratpart:F,coeffs:Vector(F)))

comment:
\spad{algextint(x,{} y,{} d,{} ext,{} rde,{} csolve,{} [g1,{} ...,{} gn])} returns \spad{[h,{} [c1,{} ...,{} cn]]} such that \spad{f = dh/dx + sum(\spad{ci} \spad{gi})} and dci/dx = 0,{} if such \spad{[h,{} [c1,{} ...,{} cn]]} exist,{} failed otherwise.


kind: o
name: algextint_base
exposed: n
type: ((UP)->UP,(Matrix(F))->List(Vector(F)),List(R))->List(Record(ratpart:R,coeffs:Vector(F)))
params: pAlgebraicIntegrate2(R0,F,UP,UPUP,R)
comment:
\spad{algextint_base(der,{} csolve,{} [g1,{} ...,{} gn])} is like algextint(\spad{der},{} ext,{} rde,{} \spad{csolve},{} [\spad{g1},{} ...,{} \spad{gn}]),{} but assumes that field is algebraic extension of rational functions and that \spad{gi}-\spad{s} have no poles at infinity.


kind: o
name: algextint_base
exposed: n
params: pAlgebraicIntegration(R,F)
type:
(Kernel(F),Kernel(F),(SparseUnivariatePolynomial(F))->SparseUnivariatePolynomial(F),(Matrix(F))->List(Vector(F)),List(F))->List(Record(ratpart:F,coeffs:Vector(F)))

comment:
\spad{algextint_base(x,{} y,{} d,{} csolve,{} [g1,{} ...,{} gn])} is like algextint but assumes that \spad{y} and \spad{gi}-\spad{s} are purely algebraic


kind: o
name: algint
exposed: n
params: pAlgebraicIntegration(R,F)
type:
(F,Kernel(F),Kernel(F),(SparseUnivariatePolynomial(F))->SparseUnivariatePolynomial(F),(F)->IntegrationResult(F))->IntegrationResult(F)

comment:
\spad{algint(f,{} x,{} y,{} d)} returns the integral of \spad{f(x,{} y)dx} where \spad{y} is an algebraic function of \spad{x}; \spad{d} is the derivation to use on \spad{k[x]}.


kind: o
name: alg_reduce0
exposed: n
params: pPrimGCD
comment: \spad{alg_reduce0(x,{} m,{} lv,{} z)} performs single reduction step.
type:
(SparseMultivariatePolynomial(Integer,Symbol),SparseMultivariatePolynomial(Integer,Symbol),List(Symbol),Symbol)->SparseMultivariatePolynomial(Integer,Symbol)


kind: o
name: alg_reduce
exposed: n
params: pPrimGCD
comment: \spad{alg_reduce(x,{} lm,{} lv,{} lz)} reduces \spad{x} modulo elements of \spad{lm}.
type:
(SparseMultivariatePolynomial(Integer,Symbol),List(SparseMultivariatePolynomial(Integer,Symbol)),List(Symbol),List(Symbol))->SparseMultivariatePolynomial(Integer,Symbol)


kind: o
name: alg_split_root0
exposed: n
type: (F,Kernel(F),Integer)->List(F)
params: pRootFSSplit(R,F)
comment:
\spad{alg_split_root0(f,{} r,{} n)} returns \spad{[a1,{} ...,{} an]} such that \spad{f = a1 + a2*r + ... an*r^(n - 1)}. \spad{r} must be a root and \spad{n} must be its degree.


kind: o
name: alg_split_roots
exposed: n
type: (List(F),Kernel(F),Kernel(F))->List(Record(funs:List(F),nroot:F,npow1:Integer,npow2:Integer))
params: pRootFSSplit(R,F)
comment:
\spad{alg_split_roots(lf,{} r1,{} r2)} splits each \spad{f} in \spad{lf} into linear combination of product of powers of \spad{r1} and \spad{r2} which must be independent roots.


kind: o
name: algSplitSimple
exposed: x
type: (%,(UP)->UP)->Record(num:%,den:UP,derivden:UP,gd:UP)
params: cFunctionFieldCategory(F,UP,UPUP)
comment:
\spad{algSplitSimple(f,{} D)} returns \spad{[h,{} d,{} d',{} g]} such that \spad{f=h/d},{} \spad{h} is integral at all the normal places \spad{w}.\spad{r}.\spad{t}. \spad{D},{} \spad{d' = Dd},{} \spad{g = gcd(d,{} discriminant())} and \spad{D} is the derivation to use. \spad{f} must have at most simple finite poles.


kind: o
name: algtower
exposed: x
type: (List(%))->List(K)
params: cFunctionSpace2(R,K)
abbrev: has(R,IntegralDomain)
comment:
\spad{algtower([f1,{} ...,{} fn])} returns list of kernels \spad{[ak1,{} ...,{} akl]} such that each toplevel algebraic kernel in one of \spad{f1},{} ...,{} \spad{fn} or in arguments of \spad{ak1},{} ...,{} akl is one of \spad{ak1},{} ...,{} akl.


kind: o
name: alg_trial_division
exposed: n
params: pPrimGCD
type:
(SparseMultivariatePolynomial(Integer,Symbol),SparseMultivariatePolynomial(Integer,Symbol),List(SparseMultivariatePolynomial(Integer,Symbol)),List(Symbol),List(Symbol))->Boolean

comment:
\spad{alg_trial_division(x,{} y,{} lm,{} lv,{} lz)} checks if \spad{x} is divisible by \spad{y} in algebraic extension defined by \spad{lm}. \spad{lz} is list of algebraic variables,{} \spad{lv} is list of independent (polynomial) variables. Other variables serve as parameters.


kind: o
name: allDegrees
exposed: n
type: (List(GuessOption))->Boolean
params: dGuessOptionFunctions0
comment:
\spad{allDegrees returns} whether all possibilities of the degree vector should be tried,{} the default being \spad{false}.


kind: o
name: allDegrees
exposed: x
type: (Boolean)->%
params: dGuessOption
comment:
\spad{allDegrees(d)} specifies whether all possibilities of the degree vector - taking into account maxDegree - should be tried. This is mainly interesting for rational interpolation. This option is expressed in the form \spad{allDegrees == d}.


kind: o
name: allRepeated
exposed: n
type: (List(NonNegativeInteger))->List(List(PositiveInteger))
params: cJetBundleCategory
comment:
\spad{allRepeated(ind)} returns a list of all possible realizations of a given multi-index as repeated index.


kind: o
name: allSimpleCells
exposed: n
type: (List(ThePols),Symbol)->List(%)
params: dSimpleCell(TheField,ThePols)
comment:
\spad{allSimpleCells(lp,{} sym)} returns decomposition into cells such that each \spad{p} in \spad{lp} has constant sign on each member of decomposition


kind: o
name: alpha
exposed: n
type: (NonNegativeInteger,List(NonNegativeInteger))->List(NonNegativeInteger)
params: pCartanKuranishi(JB,D)
comment:
\spad{alpha(q,{} beta)} computes the Cartan characters for a differential equation of order \spad{q} and with characters \spad{beta}.


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


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


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


kind: o
name: alphanumeric?
exposed: x
type: (%)->Boolean
params: dCharacter
comment:
\spad{alphanumeric?(c)} tests if \spad{c} is either a letter or number,{} \spadignore{i.e.} one of 0..9,{} a..\spad{z} or A..\spad{Z}.


kind: o
name: alternatingGroup
exposed: x
type: (List(Integer))->PermutationGroup(Integer)
params: pPermutationGroupExamples
comment:
\spad{alternatingGroup(\spad{li})} constructs the alternating group acting on the integers in the list {\em \spad{li}},{} generators are in general the {\em n-2}-cycle {\em (\spad{li}.3,{} ...,{} \spad{li}.n)} and the 3-cycle {\em (\spad{li}.1,{} \spad{li}.2,{} \spad{li}.3)},{} if \spad{n} is odd and product of the 2-cycle {\em (\spad{li}.1,{} \spad{li}.2)} with {\em n-2}-cycle {\em (\spad{li}.3,{} ...,{} \spad{li}.n)} and the 3-cycle {\em (\spad{li}.1,{} \spad{li}.2,{} \spad{li}.3)},{} if \spad{n} is even. Note: duplicates in the list will be removed.


kind: o
name: alternatingGroup
exposed: x
type: (PositiveInteger)->PermutationGroup(Integer)
params: pPermutationGroupExamples
comment:
\spad{alternatingGroup(n)} constructs the alternating group {\em An} acting on the integers 1,{} ...,{} \spad{n},{} generators are in general the {\em n-2}-cycle {\em (3,{} ...,{} n)} and the 3-cycle {\em (1,{} 2,{} 3)} if \spad{n} is odd and the product of the 2-cycle {\em (1,{} 2)} with {\em n-2}-cycle {\em (3,{} ...,{} n)} and the 3-cycle {\em (1,{} 2,{} 3)} if \spad{n} is even.


kind: o
name: alternative?
exposed: n
type: ()->Boolean
params: xFiniteRankNonAssociativeAlgebra&(S,R)
comment:
\spad{alternative?()} tests if \spad{2*associator(a,{} a,{} b) = 0 = 2*associator(a,{} b,{} b)} 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: altsupersub
exposed: n
type: (Integer)->(Integer,List(OutputForm))->OutputBox
params: cFormatterCategory
comment:
\spad{altsupersub(p)} returns a handler such that \spad{altsupersub(p)(prec,{} args)} formats the first argument with respect to the precedence \spad{p}. The remaining arguments are formatted without parentheses and interpreted as subscript,{} superscript,{} subscript,{} superscript,{} etc. where the subscripts and superscripts are pairwise aligned. Outer parentheses are added if \spad{p < prec}.


kind: o
name: analyseSymbol
exposed: n
params: dJetDifferentialEquation(JB,D)
comment: \spad{analyseSymbol(symb)} computes the multiplicative variables of the symbol \spad{symb}.
type:
(SparseEchelonMatrix(JB,D))->Record(Rank:NonNegativeInteger,NumMultVar:NonNegativeInteger,Betas:List(NonNegativeInteger))


kind: o
name: AND
exposed: n
params: dSwitch
comment: \spad{AND(x,{} y)} returns the \spadtype{Switch} expression representing \spad{x and y}.
type:
(Union(I:Expression(Integer),F:Expression(Float),CF:Expression(Complex(Float)),switch:%),Union(I:Expression(Integer),F:Expression(Float),CF:Expression(Complex(Float)),switch:%))->%


kind: o
name: And
exposed: x
type: (%,%)->%
params: dSingleInteger
comment:
\spad{And(n,{} m)} returns the bit-by-bit logical {\em and} of the single integers \spad{n} and \spad{m}.


kind: o
name: antiAssociative?
exposed: n
type: ()->Boolean
params: xFiniteRankNonAssociativeAlgebra&(S,R)
comment:
\spad{antiAssociative?()} tests if multiplication in algebra is anti-associative,{} \spadignore{i.e.} \spad{(a*b)*c + a*(b*c) = 0} for all \spad{a},{} \spad{b},{} \spad{c} in the algebra.


kind: o
name: antiCommutative?
exposed: n
type: ()->Boolean
params: xFiniteRankNonAssociativeAlgebra&(S,R)
comment:
\spad{antiCommutative?()} tests if \spad{a*a = 0} for all \spad{a} in the algebra. Note: this implies \spad{a*b + b*a = 0} for all \spad{a} and \spad{b}.


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


kind: o
name: antisymmetric?
exposed: x
type: (%)->Boolean
params: cMatrixCategory(R,Row,Col)
abbrev: has(R,AbelianGroup)
comment:
\spad{antisymmetric?(m)} returns \spad{true} if the matrix \spad{m} is square and antisymmetric (\spadignore{i.e.} \spad{m[i,{} j] = -m[j,{} i]} for all \spad{i} and \spad{j}) and \spad{false} otherwise.


kind: o
name: antisymmetricTensors
exposed: x
type: (List(Matrix(R)),PositiveInteger)->List(Matrix(R))
params: pRepresentationPackage1(R)
abbrev: has(R,CommutativeRing)
comment:
\spad{antisymmetricTensors(la,{} n)} applies to each \spad{m}-by-\spad{m} square matrix in the list {\em la} the irreducible,{} polynomial representation of the general linear group {\em GLm} which corresponds to the partition {\em (1,{} 1,{} ...,{} 1,{} 0,{} 0,{} ...,{} 0)} of \spad{n}. Error: if \spad{n} is greater than \spad{m}. Note: this corresponds to the symmetrization of the representation with the sign representation of the symmetric group {\em Sn}. The carrier spaces of the representation are the antisymmetric tensors of the \spad{n}-fold tensor product.


kind: o
name: antisymmetricTensors
exposed: x
type: (Matrix(R),PositiveInteger)->Matrix(R)
params: pRepresentationPackage1(R)
abbrev: has(R,CommutativeRing)
comment:
\spad{antisymmetricTensors(a,{} n)} applies to the square matrix {\em a} the irreducible,{} polynomial representation of the general linear group {\em GLm},{} where \spad{m} is the number of rows of {\em a},{} which corresponds to the partition {\em (1,{} 1,{} ...,{} 1,{} 0,{} 0,{} ...,{} 0)} of \spad{n}. Error: if \spad{n} is greater than \spad{m}. Note: this corresponds to the symmetrization of the representation with the sign representation of the symmetric group {\em Sn}. The carrier spaces of the representation are the antisymmetric tensors of the \spad{n}-fold tensor product.


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


kind: o
name: any
exposed: x
type: (SExpression,None)->%
params: dAny
comment:
\spad{any(type,{} object)} is a technical function for creating an object of \spadtype{Any}. Argument \spad{type} is a \spadgloss{LISP} form for the \spad{type} of \spad{object}.


kind: o
name: append
exposed: x
type: (%,%)->%
params: dList(S)
comment:
\spad{append(u1,{} u2)} appends the elements of list \spad{u1} onto the front of list \spad{u2}. This new list and \spad{u2} will share some structure.


kind: o
name: appendPoint
exposed: n
type: (%,Point(DoubleFloat))->Void
params: dGraphImage
comment:
\spad{appendPoint(\spad{gi},{} pt)} appends the point \spad{pt} to the end of the list of points component for the graph,{} \spad{\spad{gi}},{} which is of the domain \spadtype{GraphImage}.


kind: o
name: apply
exposed: n
type: (%,Partition)->R
params: cSequenceCategory(R)
comment:
\spad{elt(mm,{} \spad{pi})} returns the product of the entries indexed by the integer partition \spad{pi} (as in partitionend moments)


kind: o
name: apply
exposed: x
type: (Matrix(R),%)->%
params: cFramedNonAssociativeAlgebra(R)
comment:
\spad{apply(m,{} a)} defines a left operation of \spad{n} by \spad{n} matrices where \spad{n} is the rank of the algebra in terms of matrix-vector multiplication,{} this is a substitute for a left module structure. Error: if shape of matrix doesn\spad{'t} fit.


kind: o
name: apply
exposed: x
type: (UPS,Distribution(R))->Distribution(S)
params: pDistributionPolynomialPackage(R,S,UPS)
comment:
\spad{apply(p,{} d)} computes the distribution of the random variable \spad{p(X)}\$ where \spad{X} has distribution \spad{d}.


kind: o
name: apply
exposed: n
type: (P,(M)->M,M)->M
params: pApplyUnivariateSkewPolynomial(R,M,P)
comment:
\spad{apply(p,{} f,{} m)} returns \spad{p(m)} where the action is given by \spad{x m = f(m)}. \spad{f} must be an \spad{R}-pseudo linear map on \spad{M}.


kind: o
name: apply
exposed: n
type: (%,P,P)->Integer
params: dFiniteMoebiusFunction(P)
comment:
\spad{mf(\spad{pi},{} \spad{si})} evaluates the Moebius function \spad{mf} at \spad{pi} and \spad{si}


kind: o
name: apply
exposed: n
type: (%,S,S)->R
params: dIncidenceAlgebra(R,S)
comment:
\spad{A(s,{} t)} returns \$A_{\spad{i},{} \spad{j}}\$,{} where \$\spad{i}\$,{} \$\spad{j}\$ are the positions of \$\spad{s}\$ and \$\spad{t}\$ in the index list.


kind: o
name: apply
exposed: x
type: (%,R,R)->R
params: cUnivariateSkewPolynomialCategory(R)
comment:
\spad{apply(p,{} c,{} m)} returns \spad{p(m)} where the action is given by \spad{x m = c sigma(m) + delta(m)}.


kind: o
name: apply
exposed: n
type: (C,R,R,Automorphism(R),(R)->R)->R
params: pUnivariateSkewPolynomialCategoryOps(R,C)
comment:
\spad{apply(p,{} c,{} m,{} sigma,{} delta)} returns \spad{p(m)} where the action is given by \spad{x m = c sigma(m) + delta(m)}.


kind: o
name: applyRules
exposed: n
type: (List(RewriteRule(Base,R,F)),F)->F
params: pApplyRules(Base,R,F)
comment:
\spad{applyRules([r1,{} ...,{} rn],{} expr)} applies the rules \spad{r1},{} ...,{} \spad{rn} to \spad{f} an unlimited number of times,{} \spadignore{i.e.} until none of \spad{r1},{} ...,{} \spad{rn} is applicable to the expression.


kind: o
name: applyRules
exposed: n
type: (List(RewriteRule(Base,R,F)),F,PositiveInteger)->F
params: pApplyRules(Base,R,F)
comment:
\spad{applyRules([r1,{} ...,{} rn],{} expr,{} n)} applies the rules \spad{r1},{} ...,{} \spad{rn} to \spad{f} a most \spad{n} times.


kind: o
name: apply_taylor
exposed: n
type: (Stream(Coef),%)->%
params: dGeneralizedUnivariatePowerSeries(Coef,Expon,var,cen)
comment:
\spad{apply_taylor(ts,{} s)} applies Taylor series with coefficients \spad{ts} to \spad{s},{} that is computes infinite sum \spad{ts}(0) + \spad{ts}(1)\spad{*s} + \spad{ts}(2)\spad{*s^2} + ... Note: \spad{s} must be of positive order


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


kind: o
name: approximate
exposed: x
type: (%,Expon)->Coef
params: cUnivariatePowerSeriesCategory(Coef,Expon)
abbrev: AND(has(Coef,SIGNATURE(^,Coef(Coef,Expon))),has(Coef,SIGNATURE(coerce,Coef(Symbol))))
comment:
\spad{approximate(f)} returns a truncated power series with the series variable viewed as an element of the coefficient domain.


kind: o
name: approximate
exposed: x
type: (%,Integer)->Integer
params: cPAdicIntegerCategory(p)
comment:
\spad{approximate(x,{} n)} returns an integer \spad{y} such that \spad{y = x (mod p^n)} when \spad{n} is positive,{} and 0 otherwise.


kind: o
name: approximate
exposed: x
type: (ThePols,%,TheField)->TheField
params: cRealRootCharacterizationCategory(TheField,ThePols)
comment:
\spad{approximate(term,{} root,{} prec)} gives an approximation of \spad{term} over \spad{root} with precision \spad{prec}


kind: o
name: approxNthRoot
exposed: x
type: (I,NonNegativeInteger)->I
params: pIntegerRoots(I)
comment:
\spad{approxRoot(n,{} r)} returns an approximation \spad{x} to \spad{n^(1/r)} such that \spad{-1 < x - n^(1/r) < 1}


kind: o
name: approxSqrt
exposed: x
type: (I)->I
params: pIntegerRoots(I)
comment:
\spad{approxSqrt(n)} returns an approximation \spad{x} to \spad{sqrt(n)} such that \spad{-1 < x - sqrt(n) < 1}. Returns 0 if \spad{n} is negative. A variable precision Newton iteration is used. The running time is \spad{O( log(n)^2 )}.


kind: o
name: arbFunctions
exposed: n
type: (NonNegativeInteger,Integer,List(NonNegativeInteger))->List(Integer)
params: pCartanKuranishi(JB,D)
comment:
\spad{arbFunctions(q,{} j,{} cc)} uses the Cartan characters \spad{cc} to compute the number of arbitrary functions of differentiation order \spad{j} in the general solution of a differential equation of order \spad{q}.


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


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


kind: o
name: areEquivalent?
exposed: x
type: (List(Matrix(R)),List(Matrix(R)),Boolean,Integer)->Matrix(R)
params: pRepresentationPackage2(R)
abbrev: has(R,Field)
comment:
\spad{areEquivalent?(aG0,{} aG1,{} randomelements,{} numberOfTries)} tests whether the two lists of matrices,{} all assumed of same square shape,{} can be simultaneously conjugated by a non-singular matrix. If these matrices represent the same group generators,{} the representations are equivalent. The algorithm tries {\em numberOfTries} times to create elements in the generated algebras in the same fashion. If their ranks differ,{} they are not equivalent. If an isomorphism is assumed,{} then the kernel of an element of the first algebra is mapped to the kernel of the corresponding element in the second algebra. Now consider the one-dimensional ones. If they generate the whole space (\spadignore{e.g.} irreducibility !) we use {\em standardBasisOfCyclicSubmodule} to create the only possible transition matrix. The method checks whether the matrix conjugates all corresponding matrices from {\em aGi}. The way to choose the singular matrices is as in {\em meatAxe}. If the two representations are equivalent,{} this routine returns the transformation matrix {\em TM} with {\em aG0.i * TM = TM * aG1.i} for all \spad{i}. If the representations are not equivalent,{} a small 0-matrix is returned. Note: the case with different sets of group generators cannot be handled.


kind: o
name: argumentList!
exposed: n
type: (List(Symbol))->Void
params: dTheSymbolTable
comment:
\spad{argumentList!(l)} declares that the argument list for the current subprogram in the global symbol table is \spad{l}.


kind: o
name: argumentList!
exposed: n
type: (Symbol,List(Symbol))->Void
params: dTheSymbolTable
comment:
\spad{argumentList!(f,{} l)} declares that the argument list for subprogram \spad{f} in the global symbol table is \spad{l}.


kind: o
name: argumentList!
exposed: n
type: (Symbol,List(Symbol),%)->Void
params: dTheSymbolTable
comment:
\spad{argumentList!(f,{} l,{} tab)} declares that the argument list for subprogram \spad{f} in symbol table tab is \spad{l}.


kind: o
name: arguments
exposed: n
type: (OutputForm)->List(OutputForm)
params: pOutputFormTools
comment:
\spad{arguments(f)} gives arguments of form \spad{f}. Valid only when atom?(\spad{f}) is \spad{false}


kind: o
name: arity
exposed: x
type: (%)->Union(NonNegativeInteger,failed)
params: dBasicOperator
comment:
\spad{arity(op)} returns \spad{n} if \spad{op} is \spad{n}-ary,{} and failed if \spad{op} has arbitrary arity.


kind: o
name: aromberg
exposed: x
type: ((F)->F,F,F,F,F,Integer,Integer,Integer)->Record(value:F,error:F,totalpts:Integer,success:Boolean)
params: pNumericalQuadrature(F)
comment:
\spad{aromberg(fn,{} a,{} b,{} epsrel,{} epsabs,{} nmin,{} nmax,{} nint)} uses the adaptive romberg method to numerically integrate function \spad{fn} over the closed interval from \spad{a} to \spad{b},{} with relative accuracy \spad{epsrel} and absolute accuracy \spad{epsabs},{} with the refinement levels for convergence checking vary from \spad{nmin} to \spad{nmax},{} and where \spad{nint} is the number of independent intervals to apply the integrator. The value returned is a record containing the value of the integral,{} the estimate of the error in the computation,{} the total number of function evaluations,{} and either a boolean value which is \spad{true} if the integral was computed within the user specified error criterion. See \spadtype{NumericalQuadrature} for details.


kind: o
name: arrayStack
exposed: x
type: (List(S))->%
params: dArrayStack(S)
comment:
\spad{arrayStack([x,{} y,{} ...,{} z])} creates an array stack with first (top) element \spad{x},{} second element \spad{y},{} ...,{} and last element \spad{z}.


kind: o
name: arrowName
exposed: n
type: (%,NonNegativeInteger,NonNegativeInteger)->String
params: cFiniteGraph(S)
comment:
\spad{arrowName(s,{} a,{} b)} retrieves the name of arrow a-\spad{>b} if it does not exist then return \spad{?}


kind: o
name: asimpson
exposed: x
type: ((F)->F,F,F,F,F,Integer,Integer,Integer)->Record(value:F,error:F,totalpts:Integer,success:Boolean)
params: pNumericalQuadrature(F)
comment:
\spad{asimpson(fn,{} a,{} b,{} epsrel,{} epsabs,{} nmin,{} nmax,{} nint)} uses the adaptive simpson method to numerically integrate function \spad{fn} over the closed interval from \spad{a} to \spad{b},{} with relative accuracy \spad{epsrel} and absolute accuracy \spad{epsabs},{} with the refinement levels for convergence checking vary from \spad{nmin} to \spad{nmax},{} and where \spad{nint} is the number of independent intervals to apply the integrator. The value returned is a record containing the value of the integral,{} the estimate of the error in the computation,{} the total number of function evaluations,{} and either a boolean value which is \spad{true} if the integral was computed within the user specified error criterion. See \spadtype{NumericalQuadrature} for details.


kind: o
name: asin
exposed: x
type: (%)->%
params: cArcTrigonometricFunctionCategory
comment:
\spad{asin(x)} returns the arc-sine of \spad{x}. When evaluated into some subset of the complex numbers,{} one branch cut for asin lies along the negative real axis to the left of \spad{-1} (inclusive),{} continuous with the upper half plane,{} the other along the positive real axis to the right of 1 (inclusive),{} continuous with the lower half plane.


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


kind: o
name: assign
exposed: n
type: (Symbol,List(Polynomial(Integer)),Expression(Complex(Float)))->%
params: dFortranCode
comment:
\spad{assign(x,{} l,{} y)} creates a representation of the assignment of \spad{y} to the \spad{l}\spad{'}th element of array \spad{x} (\spad{l} is a list of indices).


kind: o
name: assoc
exposed: x
type: (Key,%)->Union(Record(key:Key,entry:Entry),failed)
params: cAssociationListAggregate(Key,Entry)
comment:
\spad{assoc(k,{} u)} returns the element \spad{x} in association list \spad{u} stored with key \spad{k},{} or failed if \spad{u} has no key \spad{k}.


kind: o
name: associatedEquations
exposed: n
params: pAssociatedEquations(R,L)
abbrev: has(R,Field)
type:
(L,PositiveInteger)->Record(minor:List(PositiveInteger),eq:L,minors:List(List(PositiveInteger)),ops:List(L))

comment:
\spad{associatedEquations(op,{} m)} returns \spad{[w,{} eq,{} lw,{} lop]} such that \spad{eq(w) = 0} where \spad{w} is the given minor,{} and \spad{lw_i = lop_i(w)} for all the other minors.


kind: o
name: associatedSystem
exposed: n
type: (L,PositiveInteger)->Record(mat:Matrix(R),vec:Vector(List(PositiveInteger)))
params: pAssociatedEquations(R,L)
comment:
\spad{associatedSystem(op,{} m)} returns \spad{[M,{} w]} such that the \spad{m}-th associated equation system to \spad{L} is \spad{w' = M w}.


kind: o
name: associates?
exposed: x
type: (%,%)->Boolean
params: cEntireRing
comment:
\spad{associates?(x,{} y)} tests whether \spad{x} and \spad{y} are associates,{} \spadignore{i.e.} differ by a unit factor.


kind: o
name: associatorDependence
exposed: n
type: ()->List(Vector(R))
params: xFiniteRankNonAssociativeAlgebra&(S,R)
comment:
\spad{associatorDependence()} looks for the associator identities,{} \spadignore{i.e.} finds a basis of the solutions of the linear combinations of the six permutations of \spad{associator(a,{} b,{} c)} which yield 0,{} for all \spad{a},{} \spad{b},{} \spad{c} in the algebra. The order of the permutations is \spad{123 231 312 132 321 213}.


kind: o
name: atan
exposed: x
type: (%)->%
params: cArcTrigonometricFunctionCategory
comment:
\spad{atan(x)} returns the arc-tangent of \spad{x}. When evaluated into some subset of the complex numbers,{} one branch cut for atan lies along the positive imaginary axis above \%\spad{i} (exclusive),{} continuous with the left half plane,{} the other along the negative imaginary axis below -\%\spad{i} (exclusive) continuous with the right half plane. The domain does not contain \%\spad{i} and -\%\spad{i}.


kind: o
name: atom?
exposed: n
type: (%)->Boolean
params: dILogic
comment:
returns \spad{true} if this is an atom,{} that is a leaf node otherwise return \spad{false} if this is a compound term


kind: o
name: atom?
exposed: n
type: (%)->Boolean
params: dLambda(UT)
comment:
returns \spad{true} if this is an atom,{} that is free or bound variable otherwise return \spad{false} if this is a compound or lambda definition


kind: o
name: atrapezoidal
exposed: x
type: ((F)->F,F,F,F,F,Integer,Integer,Integer)->Record(value:F,error:F,totalpts:Integer,success:Boolean)
params: pNumericalQuadrature(F)
comment:
\spad{atrapezoidal(fn,{} a,{} b,{} epsrel,{} epsabs,{} nmin,{} nmax,{} nint)} uses the adaptive trapezoidal method to numerically integrate function \spad{fn} over the closed interval from \spad{a} to \spad{b},{} with relative accuracy \spad{epsrel} and absolute accuracy \spad{epsabs},{} with the refinement levels for convergence checking vary from \spad{nmin} to \spad{nmax},{} and where \spad{nint} is the number of independent intervals to apply the integrator. The value returned is a record containing the value of the integral,{} the estimate of the error in the computation,{} the total number of function evaluations,{} and either a boolean value which is \spad{true} if the integral was computed within the user specified error criterion. See \spadtype{NumericalQuadrature} for details.


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


kind: o
name: augment
exposed: x
type: (P,%)->List(%)
params: cRegularTriangularSetCategory(R,E,V,P)
comment:
\spad{augment(p,{} ts)} assumes that \spad{p} is a non-constant polynomial whose main variable is greater than any variable of \spad{ts}. This operation assumes also that if \spad{p} is added to \spad{ts} the resulting set,{} say \spad{ts+p},{} is a regular triangular set. 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 required to be square-free.


kind: o
name: autoReduce
exposed: n
type: (List(%))->List(%)
params: cJetBundleFunctionCategory(JB)
comment:
\spad{autoReduce(sys)} tries to simplify a system by solving each equation for its leading term and substituting it into the other equations.


kind: o
name: autoReduced?
exposed: x
type: (%,(P,List(P))->Boolean)->Boolean
params: cTriangularSetCategory(R,E,V,P)
comment:
\spad{autoReduced?(ts,{} redOp?)} returns \spad{true} iff every element of \spad{ts} is reduced \spad{w}.\spad{r}.\spad{t} to every other in the sense of \spad{redOp?}


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


kind: o
name: axes
exposed: n
type: (%,PositiveInteger,Palette)->Void
params: dTwoDimensionalViewport
comment:
\spad{axes(v,{} n,{} c)} displays the axes of the graph in field \spad{n} of the given two-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{TwoDimensionalViewport},{} with the axes color set to the given palette color \spad{c}.


kind: o
name: axes
exposed: n
type: (%,PositiveInteger,String)->Void
params: dTwoDimensionalViewport
comment:
\spad{axes(v,{} n,{} s)} displays the axes of the graph in field \spad{n} of the given two-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{TwoDimensionalViewport},{} if \spad{s} is on,{} or does not display the axes if \spad{s} is off.


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


kind: o
name: B1solve
exposed: n
params: pParametricLinearEquations(R,Var,Expon,GR)
type:
(Record(mat:Matrix(Fraction(Polynomial(R))),vec:List(Fraction(Polynomial(R))),rank:NonNegativeInteger,rows:List(Integer),cols:List(Integer)))->Record(partsol:Vector(Fraction(Polynomial(R))),basis:List(Vector(Fraction(Polynomial(R)))))

comment:
\spad{B1solve(s)} solves the system (\spad{s}.mat) \spad{z} = \spad{s}.vec for the variables given by the column indices of \spad{s}.cols in terms of the other variables and the right hand side \spad{s}.vec by assuming that the rank is \spad{s}.rank,{} that the system is consistent,{} with the linearly independent equations indexed by the given row indices \spad{s}.rows; the coefficients in \spad{s}.mat involving parameters are treated as polynomials. B1solve(\spad{s}) returns a particular solution to the system and a basis of the homogeneous system (\spad{s}.mat) \spad{z} = 0.


kind: o
name: back
exposed: x
type: (%)->S
params: cQueueAggregate(S)
comment:
\spad{back(q)} returns the element at the back of the queue. The queue \spad{q} is unchanged by this operation. Error: if \spad{q} is empty.


kind: o
name: backOldPos
exposed: x
type: (Record(mval:Matrix(F),invmval:Matrix(F),genIdeal:%))->%
params: dPolynomialIdeal(F,Expon,VarSet,DPoly)
comment:
\spad{backOldPos(genPos)} takes the result produced by \spadfunFrom{generalPosition}{PolynomialIdeal} and performs the inverse transformation,{} returning the original ideal \spad{backOldPos(generalPosition(I,{} listvar))} = \spad{I}.


kind: o
name: badValues
exposed: n
type: (Pattern(R))->List(D)
params: pPatternFunctions1(R,D)
comment:
\spad{badValues(p)} returns the list of bad values for \spad{p}; \spad{p} is not allowed to match any of its bad values.


kind: o
name: balancedBinaryTree
exposed: x
type: (NonNegativeInteger,S)->%
params: dBalancedBinaryTree(S)
comment:
\spad{balancedBinaryTree(n,{} s)} creates a balanced binary tree with \spad{n} nodes each with value \spad{s}.


kind: o
name: balancedFactorisation
exposed: n
type: (UP,List(UP))->Factored(UP)
params: pBalancedFactorisation(R,UP)
comment:
\spad{balancedFactorisation(a,{} [b1,{} ...,{} bn])} returns a factorisation \spad{a = p1^e1 ... pm^em} such that each \spad{pi} is balanced with respect to \spad{[b1,{} ...,{} bm]}.


kind: o
name: balancedFactorisation
exposed: n
type: (UP,UP)->Factored(UP)
params: pBalancedFactorisation(R,UP)
comment:
\spad{balancedFactorisation(a,{} b)} returns a factorisation \spad{a = p1^e1 ... pm^em} such that each \spad{\spad{pi}} is balanced with respect to \spad{b}.


kind: o
name: bandedHessian
exposed: n
type: (F,FLAS,NonNegativeInteger)->Matrix(F)
params: pMultiVariableCalculusFunctions(S,F,FLAF,FLAS)
comment:
\spad{bandedHessian(v,{} xlist,{} k)} computes the hessian,{} the matrix of second partial derivatives,{} of the scalar field \spad{v},{} \spad{v} a function of the variables listed in \spad{xlist},{} \spad{k} is the semi-bandwidth,{} the number of nonzero subdiagonals,{} 2*k+1 being actual bandwidth. Stores the nonzero band in lower triangle in a matrix,{} dimensions \spad{k+1} by \#xlist,{} whose rows are the vectors formed by diagonal,{} subdiagonal,{} etc. of the real,{} full-matrix,{} hessian. (The notation conforms to LAPACK/NAG-\spad{F07} conventions.)


kind: o
name: bandedJacobian
exposed: n
type: (FLAF,FLAS,NonNegativeInteger,NonNegativeInteger)->Matrix(F)
params: pMultiVariableCalculusFunctions(S,F,FLAF,FLAS)
comment:
\spad{bandedJacobian(vf,{} xlist,{} kl,{} ku)} computes the jacobian,{} the matrix of first partial derivatives,{} of the vector field \spad{vf},{} \spad{vf} a vector function of the variables listed in \spad{xlist},{} \spad{kl} is the number of nonzero subdiagonals,{} ku is the number of nonzero superdiagonals,{} \spad{kl+ku+1} being actual bandwidth. Stores the nonzero band in a matrix,{} dimensions \spad{kl+ku+1} by \#xlist. The upper triangle is in the top ku rows,{} the diagonal is in row \spad{ku+1},{} the lower triangle in the last \spad{kl} rows. Entries in a column in the band store correspond to entries in same column of full store. (The notation conforms to LAPACK/NAG-\spad{F07} conventions.)


kind: o
name: bandMatrix
exposed: n
type: (M,List(Integer))->M
params: pMatrixManipulation(R,Row,Col,M)
abbrev: has(R,AbelianMonoid)
comment:
\spad{bandMatrix} returns multiple diagonals out of a matrix. The diagonals are 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: basicSet
exposed: x
type: (List(P),(P,P)->Boolean)->Union(Record(bas:%,top:List(P)),failed)
params: cTriangularSetCategory(R,E,V,P)
comment:
\spad{basicSet(ps,{} redOp?)} returns \spad{[bs,{} ts]} where \spad{concat(bs,{} ts)} is \spad{ps} and \spad{bs} is a basic set in Wu Wen Tsun sense of \spad{ps} \spad{w}.\spad{r}.\spad{t} the reduction-test \spad{redOp?},{} if no non-zero constant polynomial lie in \spad{ps},{} otherwise \spad{failed} is returned.


kind: o
name: basicSet
exposed: x
type: (List(P),(P)->Boolean,(P,P)->Boolean)->Union(Record(bas:%,top:List(P)),failed)
params: cTriangularSetCategory(R,E,V,P)
comment:
\spad{basicSet(ps,{} pred?,{} redOp?)} returns the same as \spad{basicSet(qs,{} redOp?)} where \spad{qs} consists of the polynomials of \spad{ps} satisfying property \spad{pred?}.


kind: o
name: basis
exposed: x
type: (NonNegativeInteger,NonNegativeInteger)->Vector(List(Integer))
params: pHallBasis
comment:
\spad{basis(numberOfGens,{} maximalWeight)} generates a vector of elements of the form [left,{} weight,{} right] which represents a \spad{P}. Hall basis element for the free lie algebra on \spad{numberOfGens} generators. We only generate those basis elements of weight less than or equal to maximalWeight


kind: o
name: basisOfCenter
exposed: x
type: ()->List(A)
params: pAlgebraPackage(R,A)
comment:
\spad{basisOfCenter()} returns a basis of the space of all \spad{x} of \spad{A} satisfying \spad{commutator(x,{} a) = 0} and \spad{associator(x,{} a,{} b) = associator(a,{} x,{} b) = associator(a,{} b,{} x) = 0} for all \spad{a},{} \spad{b} in \spad{A}.


kind: o
name: basisOfCentroid
exposed: x
type: ()->List(Matrix(R))
params: pAlgebraPackage(R,A)
comment:
\spad{basisOfCentroid()} returns a basis of the centroid,{} \spadignore{i.e.} the endomorphism ring of \spad{A} considered as \spad{(A,{} A)}-bimodule.


kind: o
name: basisOfCommutingElements
exposed: x
type: ()->List(A)
params: pAlgebraPackage(R,A)
comment:
\spad{basisOfCommutingElements()} returns a basis of the space of all \spad{x} of \spad{A} satisfying \spad{0 = commutator(x,{} a)} for all \spad{a} in \spad{A}.


kind: o
name: basisOfLeftAnnihilator
exposed: x
type: (A)->List(A)
params: pAlgebraPackage(R,A)
comment:
\spad{basisOfLeftAnnihilator(a)} returns a basis of the space of all \spad{x} of \spad{A} satisfying \spad{0 = x*a}.


kind: o
name: basisOfLeftNucleus
exposed: x
type: ()->List(A)
params: pAlgebraPackage(R,A)
comment:
\spad{basisOfLeftNucleus()} returns a basis of the space of all \spad{x} of \spad{A} satisfying \spad{0 = associator(x,{} a,{} b)} for all \spad{a},{} \spad{b} in \spad{A}.


kind: o
name: basisOfLeftNucloid
exposed: x
type: ()->List(Matrix(R))
params: pAlgebraPackage(R,A)
comment:
\spad{basisOfLeftNucloid()} returns a basis of the space of endomorphisms of \spad{A} as right module. Note: left nucloid coincides with left nucleus if \spad{A} has a unit.


kind: o
name: basisOfMiddleNucleus
exposed: x
type: ()->List(A)
params: pAlgebraPackage(R,A)
comment:
\spad{basisOfMiddleNucleus()} returns a basis of the space of all \spad{x} of \spad{A} satisfying \spad{0 = associator(a,{} x,{} b)} for all \spad{a},{} \spad{b} in \spad{A}.


kind: o
name: basisOfNucleus
exposed: x
type: ()->List(A)
params: pAlgebraPackage(R,A)
comment:
\spad{basisOfNucleus()} returns a basis of the space of all \spad{x} of \spad{A} satisfying \spad{associator(x,{} a,{} b) = associator(a,{} x,{} b) = associator(a,{} b,{} x) = 0} for all \spad{a},{} \spad{b} in \spad{A}.


kind: o
name: basisOfRightAnnihilator
exposed: x
type: (A)->List(A)
params: pAlgebraPackage(R,A)
comment:
\spad{basisOfRightAnnihilator(a)} returns a basis of the space of all \spad{x} of \spad{A} satisfying \spad{0 = a*x}.


kind: o
name: basisOfRightNucleus
exposed: x
type: ()->List(A)
params: pAlgebraPackage(R,A)
comment:
\spad{basisOfRightNucleus()} returns a basis of the space of all \spad{x} of \spad{A} satisfying \spad{0 = associator(a,{} b,{} x)} for all \spad{a},{} \spad{b} in \spad{A}.


kind: o
name: basisOfRightNucloid
exposed: x
type: ()->List(Matrix(R))
params: pAlgebraPackage(R,A)
comment:
\spad{basisOfRightNucloid()} returns a basis of the space of endomorphisms of \spad{A} as left module. Note: right nucloid coincides with right nucleus if \spad{A} has a unit.


kind: o
name: belong?
exposed: n
type: (BasicOperator)->Boolean
params: pAlgebraicFunction(R,F)
comment:
\spad{belong?(op)} is \spad{true} if \spad{op} is an algebraic operator,{} that is,{} an \spad{n}th root or implicit algebraic operator.


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


kind: o
name: bernoulli
exposed: x
type: (Integer)->Fraction(Integer)
params: pIntegerNumberTheoryFunctions
comment:
\spad{bernoulli(n)} returns the \spad{n}th Bernoulli number. this is \spad{B(n,{} 0)},{} where \spad{B(n,{} x)} is the \spad{n}th Bernoulli polynomial.


kind: o
name: besselI
exposed: x
type: (Complex(DoubleFloat),Complex(DoubleFloat))->Complex(DoubleFloat)
params: pDoubleFloatSpecialFunctions
comment:
\spad{besselI(v,{} x)} is the modified Bessel function of the first kind,{} \spad{I(v,{} x)}. This function satisfies the differential equation: \indented{2}{\spad{x^2 w''(x) + x w'(x) - (x^2+v^2)w(x) = 0}.}


kind: o
name: besselJ
exposed: x
type: (Complex(DoubleFloat),Complex(DoubleFloat))->Complex(DoubleFloat)
params: pDoubleFloatSpecialFunctions
comment:
\spad{besselJ(v,{} x)} is the Bessel function of the first kind,{} \spad{J(v,{} x)}. This function satisfies the differential equation: \indented{2}{\spad{x^2 w''(x) + x w'(x) + (x^2-v^2)w(x) = 0}.}


kind: o
name: besselK
exposed: x
type: (Complex(DoubleFloat),Complex(DoubleFloat))->Complex(DoubleFloat)
params: pDoubleFloatSpecialFunctions
comment:
\spad{besselK(v,{} x)} is the modified Bessel function of the second kind,{} \spad{K(v,{} x)}. This function satisfies the differential equation: \indented{2}{\spad{x^2 w''(x) + x w'(x) - (x^2+v^2)w(x) = 0}.} Note: The default implementation uses the relation \indented{2}{\spad{K(v,{} x) = \%pi/2*(I(-v,{} x) - I(v,{} x))/sin(v*\%\spad{pi})}} so is not valid for integer values of \spad{v}.


kind: o
name: besselK
exposed: x
type: (DoubleFloat,DoubleFloat)->DoubleFloat
params: pDoubleFloatSpecialFunctions
comment:
\spad{besselK(v,{} x)} is the modified Bessel function of the second kind,{} \spad{K(v,{} x)}. This function satisfies the differential equation: \indented{2}{\spad{x^2 w''(x) + x w'(x) - (x^2+v^2)w(x) = 0}.} Note: The default implementation uses the relation \indented{2}{\spad{K(v,{} x) = \%pi/2*(I(-v,{} x) - I(v,{} x))/sin(v*\%\spad{pi})}.} so is not valid for integer values of \spad{v}.


kind: o
name: besselY
exposed: x
type: (Complex(DoubleFloat),Complex(DoubleFloat))->Complex(DoubleFloat)
params: pDoubleFloatSpecialFunctions
comment:
\spad{besselY(v,{} x)} is the Bessel function of the second kind,{} \spad{Y(v,{} x)}. This function satisfies the differential equation: \indented{2}{\spad{x^2 w''(x) + x w'(x) + (x^2-v^2)w(x) = 0}.} Note: The default implementation uses the relation \indented{2}{\spad{Y(v,{} x) = (J(v,{} x) cos(v*\%\spad{pi}) - J(-v,{} x))/sin(v*\%\spad{pi})}} so is not valid for integer values of \spad{v}.


kind: o
name: bezoutDiscriminant
exposed: n
type: (UP)->R
params: pBezoutMatrix(R,UP,M,Row,Col)
abbrev: has(R,CommutativeRing)
comment:
\spad{bezoutDiscriminant(p)} computes the discriminant of a polynomial \spad{p} by computing the determinant of a Bezout matrix.


kind: o
name: bezoutMatrix
exposed: n
type: (UP,UP)->M
params: pBezoutMatrix(R,UP,M,Row,Col)
comment:
\spad{bezoutMatrix(p,{} q)} returns the Bezout matrix for the two polynomials \spad{p} and \spad{q}.


kind: o
name: bezoutResultant
exposed: n
type: (UP,UP)->R
params: pBezoutMatrix(R,UP,M,Row,Col)
abbrev: has(R,CommutativeRing)
comment:
\spad{bezoutResultant(p,{} q)} computes the resultant of the two polynomials \spad{p} and \spad{q} by computing the determinant of a Bezout matrix.


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

comment:
\spad{binary(h1,{} h2)} returns a handler \spad{h} such that \spad{h(prec,{} args)} formats the first argument according to \spad{h1} and the second argument by \spad{h2}. Both boxes will be horizontally concatenated. binary(\spad{h1},{} \spad{h2}) is equal to infix(\spad{"},{} maxPrecedence(),{} \spad{h1},{} \spad{h2})


kind: o
name: binary
exposed: n
type: (%,List(%))->%
params: dInputForm
comment:
\spad{binary(op,{} [a1,{} ...,{} an])} returns the input form corresponding to \spad{a1 op a2 op ... op an}.


kind: o
name: binarySearch
exposed: n
type: (S,(S,S)->Integer)->Union(S,failed)
params: pSortedCache(S)
comment:
\spad{binarySearch(x,{} f)} searches \spad{x} in the cache,{} calling \spad{f(x,{} y)} to determine order. It returns \spad{y} from cache if \spad{f}(\spad{x},{} \spad{y}) is 0 or failed if no such \spad{y} exists.


kind: o
name: binaryTournament
exposed: x
type: (List(S))->%
params: dBinaryTournament(S)
comment:
\spad{binaryTournament(ls)} creates a binary tournament with the elements of \spad{ls} as values of the nodes.


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


kind: o
name: binomial
exposed: n
type: (F,F)->F
params: pCombinatorialFunction(R,F)
comment:
\spad{binomial(n,{} r)} returns the number of subsets of \spad{r} objects taken among \spad{n} objects,{} \spadignore{i.e.} \spad{n!/}(\spad{r!} * (\spad{n}-\spad{r})!).


kind: o
name: binomial
exposed: n
type: (Integer,List(OutputForm))->OutputBox
params: cFormatterCategory
comment:
\spad{binomial} is a handler such that \spad{binomial(prec,{}args)} formats a binomial expression of the first two arguments.


kind: o
name: binomial
exposed: x
type: (%,%)->%
params: cCombinatorialFunctionCategory
comment:
\spad{binomial(n,{} r)} returns the \spad{(n,{} r)} binomial coefficient (often denoted in the literature by \spad{C(n,{} r)}). Note: \spad{C(n,{} r) = n!/(r!(n-r)!)} where \spad{n >= r >= 0}.


kind: o
name: binomial
exposed: x
type: (I,I)->I
params: pIntegerCombinatoricFunctions(I)
comment:
\spad{binomial(n,{} r)} returns the binomial coefficient \spad{C(n,{} r) = n!/(r! (n-r)!)},{} where \spad{n >= r >= 0}. This is the number of combinations of \spad{n} objects taken \spad{r} at a time.


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


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


kind: o
name: biRank
exposed: x
type: (A)->NonNegativeInteger
params: pAlgebraPackage(R,A)
comment:
\spad{biRank(x)} determines the number of linearly independent elements in \spad{x},{} \spad{x*bi},{} \spad{bi*x},{} \spad{bi*x*bj},{} \spad{i,{} j=1,{} ...,{} n},{} where \spad{b=[b1,{} ...,{} bn]} is a basis. Note: if \spad{A} has a unit,{} then \spadfunFrom{doubleRank}{AlgebraPackage},{} \spadfunFrom{weakBiRank}{AlgebraPackage} and \spadfunFrom{biRank}{AlgebraPackage} coincide.


kind: o
name: bitTruth
exposed: n
type: (Integer,NonNegativeInteger)->Boolean
params: pIntegerBits
comment:
\spad{bitTruth(n,{} m)} returns \spad{true} if coefficient of 2^m in two complement representation of \spad{n} is 1.


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


kind: o
name: bivariateSLPEBR
exposed: n
params: pPolynomialFactorizationByRecursion(R,E,VarSet,S)
type:
(List(SparseUnivariatePolynomial(S)),SparseUnivariatePolynomial(S),VarSet)->Union(List(SparseUnivariatePolynomial(S)),failed)

comment:
\spad{bivariateSLPEBR(lp,{} p,{} v)} implements the bivariate case of \spadfun{solveLinearPolynomialEquationByRecursion}; its implementation depends on \spad{R}


kind: o
name: blockConcat
exposed: x
type: (List(List(%)))->%
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{blockConcat(ll)} concatenates arrays row and column wise,{} building a array from blocks. The order is row major as in \spad{matrix}.


kind: o
name: blockElimination
exposed: n
params: dFreeDivisionAlgebra(VAR,F)
type:
(%,List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger),List(NonNegativeInteger))->List(Matrix(F))

comment:
\spad{blockElimination(f,{} rsrc,{} rdst,{} csrc,{} cdst)} flg_u = \spad{true},{} flg_v = \spad{true}


kind: o
name: blockElimination
exposed: n
params: dFreeDivisionAlgebra(VAR,F)
type:
(%,List(NonNegativeInteger),List(NonNegativeInteger),Boolean,List(NonNegativeInteger),List(NonNegativeInteger),Boolean)->List(Matrix(F))

comment:
\spad{blockElimination(f,{} rsrc,{} rdst,{} flg_u,{} csrc,{} cdst,{} flg_v)} returns transformation matrices if it is possible to eliminate all entries in \spad{rdst} \spad{x} \spad{cdst} (including columns in \spad{u} if \spad{flg_u} = \spad{true},{} including rows in \spad{v} if flg_v = \spad{true}) by using rows in \spad{rsrc} and columns in \spad{csrc}. Otherwise an empty list.


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

comment:
\spad{blockElimination(p,{} rsrc,{} rdst,{} rext,{} csrc,{} cdst,{} cext)} r___ rows,{} c___ columns _src source,{} _dst destination,{} _ext extra (zeros) Uses a linear system of equations to determine row and column transformation matrices to eliminate the entries in rdst+rext \times cdst+cext and returns an empty list if there is no solution.


kind: o
name: blockSplit
exposed: n
type: (M,List(NonNegativeInteger),PositiveInteger)->List(List(M))
params: pMatrixManipulation(R,Row,Col,M)
comment:
\spad{blockSplit} splits a matrix into multiple submatrices row and column wise,{} dividing a matrix into blocks.


kind: o
name: blockSplit
exposed: x
type: (%,List(NonNegativeInteger),List(NonNegativeInteger))->List(List(%))
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{blockSplit(a,{} [n1,{}...,{}\spad{ni}],{} [m1,{}...,{}\spad{mi}])} splits a into multiple subarraus row and column wise,{} such that element at position \spad{k},{} \spad{l} has \spad{nk} rows and \spad{ml} columns. Error: if number of rows of a is different than \spad{n1} + ... + \spad{ni} or number of columns of a is different than \spad{m1} + ... + \spad{mj}


kind: o
name: blockSplit
exposed: x
type: (%,PositiveInteger,PositiveInteger)->List(List(%))
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{blockSplit(a,{} n,{} m)} splits a into \spad{n*m} subarrays of equal size row and column wise,{} dividing a into blocks. Error: if number of rows of a is not divisible by \spad{n} or number of columns of a is not divisible by \spad{m}.


kind: o
name: blockStructure
exposed: n
type: (%)->Matrix(NonNegativeInteger)
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{blockStructure(f)} analyzes the structure of the ALS of \spad{f} and detects blocks with respect to an upper triangular structure. Entry (\spad{i},{}1) contains the first row,{} (\spad{i},{}2) the last row,{} (\spad{i},{}3) the size and (\spad{i},{}4) if block \spad{i} is refined.


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


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


kind: o
name: booleanCumulant
exposed: n
type: (%,PositiveInteger)->R
params: cDistributionCategory(R)
comment:
\spad{booleanCumulant(x,{} n)} returns the \spad{n}-th boolean cumulant of the distribution \spad{x}


kind: o
name: booleanCumulantFromJacobi
exposed: x
type: (Integer,Sequence(R),Sequence(R))->R
params: dDistribution(R)
comment:
\spad{booleanCumulantFromJacobi(n,{} aa,{} bb)} computes the \spad{n}th Boolean cumulant from the given Jacobiparameters \spad{aa} and \spad{bb}.


kind: o
name: boolWordPermute
exposed: n
type: (NonNegativeInteger,NonNegativeInteger)->List(List(Boolean))
params: dOrientedFacet
comment:
boolean word permutation find all permutations of numZeros and numOnes used by product to calculate all paths through lattice


kind: o
name: bound
exposed: n
type: (NonNegativeInteger,NonNegativeInteger,NonNegativeInteger)->NonNegativeInteger
params: pCartanKuranishi(JB,D)
comment:
\spad{bound(n,{} m,{} q)} computes an upper bound for the number of prolongations needed to make the symbol of an equation of order \spad{q} with \spad{n} independent and \spad{m} dependent variables involutive.


kind: o
name: boundary
exposed: n
type: (%)->%
params: dFiniteCubicalComplex(VS)
comment:
Boundary operator. Step down to the next lower dimension,{} this is like hollowing out the complex. It takes the highest dimension entries and replaces them with their boundaries,{} cancelling out where it can.


kind: o
name: boundary
exposed: n
type: (%)->%
params: dFiniteSimplicialComplex(VS)
comment:
Step down to the next lower dimension,{} this is like hollowing out the complex. It takes the highest dimension entries and replaces them with their boundaries,{} cancelling out where it can.


kind: o
name: boundary
exposed: n
type: (%,DoubleFloat)->SBoundary(PT)
params: dScene(PT)
comment:
\spad{boundary(n,{} fontScale)} returns the boundary of a given node,{} so if this is called on the root node,{} it will return the boundary of the whole scene. There is a difficulty involving text nodes,{} that is they have a fixed font size. But we want to calculate the boundary in local coordinates,{} to do this conversion we need to know the total boundary size but that is what we are trying to calculate! To get round this contradiction the parameter fontScale is required since fonts are rendered at a fixed size we need a scaling factor so that we can give the boundary in our coordinate system. 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 this node,{} or its subnodes,{} do not contain a text node then its value is not significant.


kind: o
name: box
exposed: n
type: ((Integer,List(OutputForm))->OutputBox)->(Integer,List(OutputForm))->OutputBox
params: cFormatterCategory
comment:
\spad{box(hh)} returns a handler \spad{h} such that \spad{h(prec,{} args)} formats the arguments via \spad{hh(prec,{} args)} and then draws a box frame around the resulting box.


kind: o
name: box
exposed: x
type: (%)->%
params: cExpressionSpace2(K)
comment:
\spad{box(f)} returns \spad{f} with a 'box' around it that prevents \spad{f} from being evaluated when operators are applied to it. For example,{} \spad{log(1)} returns 0,{} but \spad{log(box 1)} returns the formal kernel log(1).


kind: o
name: boxBoundary
exposed: n
type: (PT,PT)->%
params: dSBoundary(PT)
comment:
\spad{boxBoundary(c1,{} c2)} constructs a box boundary (\spad{n}-dimensional axis-aligned rectangle) with given parameters \spad{c1:} \spad{PT} holds minimum coordinates \spad{c2:} \spad{PT} holds maximum coordinates


kind: o
name: brace
exposed: n
type: (List(%))->%
params: dOutputForm
comment:
\spad{brace(lf)} creates the form separating the elements of \spad{lf} by commas and encloses the result in curly brackets.


kind: o
name: bracket
exposed: n
type: (List(%))->%
params: dOutputForm
comment:
\spad{bracket(lf)} creates the form separating the elements of \spad{lf} by commas and encloses the result in square brackets.


kind: o
name: bracket
exposed: n
type: (String,String,(Integer,List(OutputForm))->OutputBox)->(Integer,List(OutputForm))->OutputBox
params: cFormatterCategory
comment:
\spad{bracket(lb,{} rb,{} hh)} returns a handler \spad{h} such that \spad{h(prec,{} args)} formats its first argument according to \spad{hh} and then put left and right brackets given by \spad{lb} and \spad{rb} around the resulting box.


kind: o
name: branchIfCan
exposed: x
params: pQuasiComponentPackage(R,E,V,P,TS)
type:
(List(P),TS,List(P),Boolean,Boolean,Boolean,Boolean,Boolean)->Union(Record(eq:List(P),tower:TS,ineq:List(P)),failed)

comment:
\spad{branchIfCan(leq,{} ts,{} lineq,{} b1,{} b2,{} b3,{} b4,{} b5)} is an internal subroutine,{} exported only for development.


kind: o
name: brillhartIrreducible?
exposed: n
type: (UP)->Boolean
params: pBrillhartTests(UP)
comment:
\spad{brillhartIrreducible?(p)} returns \spad{true} if \spad{p} can be shown to be irreducible by a remark of Brillhart,{} \spad{false} is inconclusive.


kind: o
name: brillhartIrreducible?
exposed: n
type: (UP,Boolean)->Boolean
params: pBrillhartTests(UP)
comment:
\spad{brillhartIrreducible?(p,{} noLinears)} returns \spad{true} if \spad{p} can be shown to be irreducible by a remark of Brillhart,{} \spad{false} else. If noLinears is \spad{true},{} we are being told \spad{p} has no linear factors \spad{false} does not mean that \spad{p} is reducible.


kind: o
name: brillhartTrials
exposed: n
type: (NonNegativeInteger)->NonNegativeInteger
params: pBrillhartTests(UP)
comment:
\spad{brillhartTrials(n)} sets to \spad{n} the number of tests in \spadfun{brillhartIrreducible?} and returns the previous value.


kind: o
name: bringDown
exposed: n
type: (F)->Fraction(Integer)
params: pFunctionSpaceReduce(R,F)
comment:
\spad{bringDown(f)} replaces transcendental kernels in \spad{f} by random integers. Error if \spad{f} contains algebraic kernel.


kind: o
name: bringDown
exposed: n
type: (F,Kernel(F))->SparseUnivariatePolynomial(Fraction(Integer))
params: pFunctionSpaceReduce(R,F)
comment:
\spad{bringDown(f,{} k)} is like bringDown(\spad{f}) but \spad{k} is algebraic kernel and the result is reduced modulo minimal polynomial of \spad{k}.


kind: o
name: bsolve
exposed: n
params: pParametricLinearEquations(R,Var,Expon,GR)
type:
(Matrix(GR),List(Fraction(Polynomial(R))),NonNegativeInteger,String,Integer)->Record(rgl:List(Record(eqzro:List(GR),neqzro:List(GR),wcond:List(Polynomial(R)),bsoln:Record(partsol:Vector(Fraction(Polynomial(R))),basis:List(Vector(Fraction(Polynomial(R))))))),rgsz:Integer)

comment:
\spad{bsolve(c,{} w,{} r,{} s,{} m)} returns a list of regimes and solutions of the system \spad{c} \spad{z} = \spad{w} for ranks at least \spad{r}; depending on the mode \spad{m} chosen,{} it writes the output to a file given by the string \spad{s}.


kind: o
name: btwFact
exposed: n
params: pGaloisGroupFactorizer(UP)
type:
(UP,Boolean,Set(NonNegativeInteger),NonNegativeInteger)->Record(contp:Integer,factors:List(Record(irr:UP,pow:NonNegativeInteger)))

comment:
\spad{btwFact(p,{} sqf,{} pd,{} r)} 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). \spad{pd} is the \spadtype{Set} of possible degrees. \spad{r} is a lower bound for the number of factors of \spad{p}. Please do not use this function in your code because its design may change.


kind: o
name: BumInSepFFE
exposed: n
params: pUnivariatePolynomialSquareFree(RC,P)
type:
(Record(flag:Union(nil,sqfr,irred,prime),factor:P,exponent:NonNegativeInteger))->Record(flag:Union(nil,sqfr,irred,prime),factor:P,exponent:NonNegativeInteger)

comment:
\spad{BumInSepFFE(f)} is a local function,{} exported only because it has multiple conditional definitions.


kind: o
name: bumprow
exposed: n
type: ((S,S)->Boolean,List(S),List(List(S)))->Record(fs:Boolean,sd:List(S),td:List(List(S)))
params: pTableauxBumpers(S)
comment:
\spad{bumprow(cf,{} pr,{} r)} is an auxiliary function which bumps a row \spad{r} with a pair \spad{pr} using comparison function \spad{cf},{} and returns a record


kind: o
name: bumptab1
exposed: n
type: (List(S),List(List(List(S))))->List(List(List(S)))
params: pTableauxBumpers(S)
comment:
\spad{bumptab1(pr,{} t)} bumps a tableau \spad{t} with a pair \spad{pr} using comparison function \spadfun{<},{} returning a new tableau


kind: o
name: bumptab
exposed: n
type: ((S,S)->Boolean,List(S),List(List(List(S))))->List(List(List(S)))
params: pTableauxBumpers(S)
comment:
\spad{bumptab(cf,{} pr,{} t)} bumps a tableau \spad{t} with a pair \spad{pr} using comparison function \spad{cf},{} returning a new tableau


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


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


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


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


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


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


kind: o
name: cap
exposed: x
type: (SymmetricPolynomial(Fraction(Integer)),SymmetricPolynomial(Fraction(Integer)))->Fraction(Integer)
params: pCycleIndicators
comment:
\spad{cap(s1,{} s2)},{} introduced by Redfield,{} \indented{1}{is the scalar product of two cycle indices.}


kind: o
name: cardinality
exposed: x
type: (%)->NonNegativeInteger
params: cFiniteSetAggregate(S)
comment:
\spad{cardinality(u)} returns the number of elements of \spad{u}. Note: \spad{cardinality(u) = \#u}.


kind: o
name: carmichaelLambda
exposed: x
type: (Integer)->Integer
params: pIntegerNumberTheoryFunctions
comment:
\spad{carmichaelLambda(n)} returns exponent of the multiplicative group of integers modulo \spad{n},{} that is smallest positive integer \spad{k} such that \spad{i^k rem n = 1} for all \spad{i} relatively prime to \spad{n}.


kind: o
name: cartesian
exposed: n
type: (List(List(T)))->List(List(T))
params: pListPackage(T)
comment:
\spad{cartesian([S1,{} S2,{} ...])} returns the set of lists [\spad{s1},{} \spad{s2},{} ...] with \spad{si} in \spad{Si}


kind: o
name: cartesian
exposed: n
type: (%,%)->DirectedGraph(Product(S,S))
params: dDirectedGraph(S)
comment:
\spad{cartesian(a,{} b)} returns a Cartesian product: the vertex set of \spad{G} \spad{o} \spad{H} is the Cartesian product \spad{V}(\spad{G}) \times \spad{V}(\spad{H}) and any two vertices (\spad{u},{} u') and (\spad{v},{} \spad{v'}) \indented{1}{are adjacent in \spad{G} \spad{o} \spad{H} if and only if either} \spad{u} = \spad{v} and u' is adjacent with \spad{v'} in \spad{H},{} or u' = \spad{v'} and \spad{u} is adjacent with \spad{v} in \spad{G}.


kind: o
name: cartesian
exposed: n
type: (%,%)->MultifunctionGraph(Product(S,S))
params: dMultifunctionGraph(S)
comment:
Cartesian product doubles the size of next list in each object,{} that is it produces two arrows out of every node


kind: o
name: cartesian
exposed: n
type: (%,%)->UndirectedGraph(Product(S,S))
params: dUndirectedGraph(S)
comment:
Cartesian product: the vertex set of \spad{G} \spad{o} \spad{H} is the Cartesian product \spad{V}(\spad{G}) \times \spad{V}(\spad{H}) and any two vertices (\spad{u},{} u') and (\spad{v},{} \spad{v'}) \indented{1}{are adjacent in \spad{G} \spad{o} \spad{H} if and only if either} \spad{u} = \spad{v} and u' is adjacent with \spad{v'} in \spad{H},{} or u' = \spad{v'} and \spad{u} is adjacent with \spad{v} in \spad{G}.


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


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


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


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


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


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


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


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


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


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


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


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


kind: o
name: center
exposed: x
type: (List(String),Integer,String)->List(String)
params: pDisplayPackage
comment:
\spad{center(l,{} i,{} s)} takes a list of strings \spad{l},{} and centers them within a list of strings which is \spad{i} characters long,{} in which the remaining spaces are filled with strings composed of as many repetitions as possible of the last string parameter \spad{s}.


kind: o
name: center
exposed: x
type: (String,Integer,String)->String
params: pDisplayPackage
comment:
\spad{center(s,{} i,{} s)} takes the first string \spad{s},{} and centers it within a string of length \spad{i},{} in which the other elements of the string are composed of as many replications as possible of the second indicated string,{} \spad{s} which must have a length greater than that of an empty string.


kind: o
name: certainlySubVariety?
exposed: n
type: (List(P),List(P))->Boolean
params: pPolynomialSetUtilitiesPackage(R,E,V,P)
comment:
\spad{certainlySubVariety?(newlp,{} lp)} returns \spad{true} iff for every \spad{p} in \spad{lp} the remainder of \spad{p} by \spad{newlp} using the division algorithm of Groebner techniques is zero.


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


kind: o
name: chain
exposed: n
type: (%)->ChainComplex
params: dFiniteSimplicialComplex(VS)
comment:
returns a matrix sequence representing the face maps in linear algebra form For more information: \url{http://www.euclideanspace.com/prog/scratchpad/mycode/topology/chain/index.\spad{htm}}


kind: o
name: chainSubResultants
exposed: n
type: (polR,polR)->List(polR)
params: pPseudoRemainderSequence(R,polR)
comment:
\spad{chainSubResultants(P,{} Q)} computes the list of non zero subresultants of \spad{P} and \spad{Q}.


kind: o
name: changeBase
exposed: n
type: (Matrix(K),Matrix(K),Automorphism(K),(K)->K)->Matrix(K)
params: pPseudoLinearNormalForm(K)
comment:
\spad{changeBase(M,{} A,{} sig,{} der)}: computes the new matrix of a pseudo-linear transform given by the matrix \spad{M} under the change of base A


kind: o
name: changeWeightLevel
exposed: n
type: (NonNegativeInteger)->Void
params: dWeightedPolynomials(R,VarSet,E,P,vl,wl,wtlevel)
comment:
\spad{changeWeightLevel(n)} changes the weight level to the new value given: \spad{NB:} previously calculated terms are not affected


kind: o
name: char
exposed: x
type: (Integer)->%
params: dCharacter
comment:
\spad{char(i)} provides a character corresponding to the integer code \spad{i}. It is always \spad{true} that \spad{ord char i = i}.


kind: o
name: characteristicPolynomial
exposed: n
type: (E)->PolR
params: pCharacteristicPolynomialInMonogenicalAlgebra(R,PolR,E)
comment:
\spad{characteristicPolynomial(e)} returns the characteristic polynomial of \spad{e} using resultants


kind: o
name: characteristicPolynomial
exposed: x
type: (Matrix(Complex(Fraction(Integer))))->Polynomial(Complex(Fraction(Integer)))
params: pNumericComplexEigenPackage(Par)
comment:
\spad{characteristicPolynomial(m)} returns the characteristic polynomial of the matrix \spad{m} expressed as polynomial over complex rationals with a new symbol as variable.


kind: o
name: characteristicPolynomial
exposed: x
type: (Matrix(Fraction(Integer)))->Polynomial(Fraction(Integer))
params: pNumericRealEigenPackage(Par)
comment:
\spad{characteristicPolynomial(m)} returns the characteristic polynomial of the matrix \spad{m} expressed as polynomial over \spad{RN} with a new symbol as variable.


kind: o
name: characteristicPolynomial
exposed: x
type: (Matrix(Fraction(Polynomial(R))))->Polynomial(R)
params: pEigenPackage(R)
comment:
\spad{characteristicPolynomial(m)} returns the characteristicPolynomial of the matrix \spad{m} using a new generated symbol symbol as the main variable.


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


kind: o
name: characteristicPolynomial
exposed: n
type: (Matrix(R),R)->R
params: pCharacteristicPolynomial(R)
comment:
\spad{characteristicPolynomial(m,{} r)} computes the characteristic polynomial of the matrix \spad{m} evaluated at the point \spad{r}. In particular,{} if \spad{r} is the polynomial \spad{'x},{} then it returns the characteristic polynomial expressed as a polynomial in \spad{'x}.


kind: o
name: characteristicPolynomial
exposed: x
type: (Matrix(Complex(Fraction(Integer))),Symbol)->Polynomial(Complex(Fraction(Integer)))
params: pNumericComplexEigenPackage(Par)
comment:
\spad{characteristicPolynomial(m,{} x)} returns the characteristic polynomial of the matrix \spad{m} expressed as polynomial over Complex Rationals with variable \spad{x}.


kind: o
name: characteristicPolynomial
exposed: x
type: (Matrix(Fraction(Integer)),Symbol)->Polynomial(Fraction(Integer))
params: pNumericRealEigenPackage(Par)
comment:
\spad{characteristicPolynomial(m,{} x)} returns the characteristic polynomial of the matrix \spad{m} expressed as polynomial over \spad{RN} with variable \spad{x}.


kind: o
name: characteristicPolynomial
exposed: x
type: (Matrix(Fraction(Polynomial(R))),Symbol)->Polynomial(R)
params: pEigenPackage(R)
comment:
\spad{characteristicPolynomial(m,{} var)} returns the characteristicPolynomial of the matrix \spad{m} using the symbol var as the main variable.


kind: o
name: characteristicSerie
exposed: x
type: (List(P))->List(%)
params: dWuWenTsunTriangularSet(R,E,V,P)
comment:
\spad{characteristicSerie(ps)} returns the same as \spad{characteristicSerie(ps,{} initiallyReduced?,{} initiallyReduce)}.


kind: o
name: characteristicSerie
exposed: x
type: (List(P),(P,P)->Boolean,(P,P)->P)->List(%)
params: dWuWenTsunTriangularSet(R,E,V,P)
comment:
\spad{characteristicSerie(ps,{} redOp?,{} redOp)} returns a list \spad{lts} of triangular sets such that the zero set of \spad{ps} is the union of the regular zero sets of the members of \spad{lts}. This is made by the Ritt and Wu Wen Tsun process applying the operation \spad{characteristicSet(ps,{} redOp?,{} redOp)} to compute characteristic sets in Wu Wen Tsun sense.


kind: o
name: characteristicSet
exposed: x
type: (List(P))->Union(%,failed)
params: dWuWenTsunTriangularSet(R,E,V,P)
comment:
\spad{characteristicSet(ps)} returns the same as \spad{characteristicSet(ps,{} initiallyReduced?,{} initiallyReduce)}.


kind: o
name: characteristicSet
exposed: x
type: (List(P),(P,P)->Boolean,(P,P)->P)->Union(%,failed)
params: dWuWenTsunTriangularSet(R,E,V,P)
comment:
\spad{characteristicSet(ps,{} redOp?,{} redOp)} returns a non-contradictory characteristic set of \spad{ps} in Wu Wen Tsun sense \spad{w}.\spad{r}.\spad{t} the reduction-test \spad{redOp?} (using \spad{redOp} to reduce polynomials \spad{w}.\spad{r}.\spad{t} a \spad{redOp?} basic set),{} if no non-zero constant polynomial appear during those reductions,{} else \spad{failed} is returned. The operations \spad{redOp} and \spad{redOp?} must satisfy the following conditions: \spad{redOp?(redOp(p,{} q),{} q)} holds for every polynomials \spad{p,{} q} and there exists an integer \spad{e} and a polynomial \spad{f} such that we have \spad{init(q)^e*p = f*q + redOp(p,{} q)}.


kind: o
name: charClass
exposed: x
type: (List(Character))->%
params: dCharacterClass
comment:
\spad{charClass(l)} creates a character class which contains exactly the characters given in the list \spad{l}.


kind: o
name: charClass
exposed: x
type: (String)->%
params: dCharacterClass
comment:
\spad{charClass(s)} creates a character class which contains exactly the characters given in the string \spad{s}.


kind: o
name: charpol
exposed: n
type: (Matrix(K))->SparseUnivariatePolynomial(K)
params: pInnerNumericEigenPackage(K,F,Par)
comment:
\spad{charpol(m)} computes the characteristic polynomial of a matrix \spad{m} with entries in \spad{K}.


kind: o
name: charthRoot
exposed: x
type: (%)->%
params: cFiniteFieldCategory
comment:
\spad{charthRoot(a)} takes the characteristic'th root of {\em a}. Note: such a root is always defined in finite fields.


kind: o
name: charthRoot
exposed: x
type: (%)->Union(%,failed)
params: cCharacteristicNonZero
comment:
\spad{charthRoot(x)} returns the \spad{p}th root of \spad{x} where \spad{p} is the characteristic of the ring.


kind: o
name: charthRoot
exposed: x
type: (%)->Union(%,failed)
params: cPolynomialFactorizationExplicit
abbrev: has(%,CharacteristicNonZero)
comment:
\spad{charthRoot(r)} returns the \spad{p}\spad{-}th root of \spad{r},{} or failed if none exists in the domain.


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


kind: o
name: chebyshevT
exposed: x
type: (NonNegativeInteger,R)->R
params: pOrthogonalPolynomialFunctions(R)
comment:
\spad{chebyshevT(n,{} x)} is the \spad{n}-th Chebyshev polynomial of the first kind,{} \spad{T[n](x)}. These are defined by \spad{(1-t*x)/(1-2*t*x+t^2) = sum(T[n](x) *t^n,{} n = 0..)}.


kind: o
name: chebyshevU
exposed: n
type: (Integer)->SparseUnivariatePolynomial(Integer)
params: pPolynomialNumberTheoryFunctions
comment:
\spad{chebyshevU(n)} returns the \spad{n}th Chebyshev polynomial \spad{U[n](x)}. Note: Chebyshev polynomials of the second kind,{} denoted \spad{U[n](x)},{} computed from the two term recurrence. The generating function \spad{1/(1-2*t*x+t^2) = sum(T[n](x)*t^n,{} n=0..infinity)}.


kind: o
name: chebyshevU
exposed: x
type: (NonNegativeInteger,R)->R
params: pOrthogonalPolynomialFunctions(R)
comment:
\spad{chebyshevU(n,{} x)} is the \spad{n}-th Chebyshev polynomial of the second kind,{} \spad{U[n](x)}. These are defined by \spad{1/(1-2*t*x+t^2) = sum(T[n](x) *t^n,{} n = 0..)}.


kind: o
name: check
exposed: n
type: (List(GuessOption))->Union(skip,MonteCarlo,deterministic)
params: dGuessOptionFunctions0
comment:
\spad{check(d)} specifies how we want to check the solution. If the value is skip,{} we return the solutions found by the interpolation routine without checking. If the value is MonteCarlo,{} we use a probabilistic check. The default is deterministic.


kind: o
name: check
exposed: x
type: (%)->%
params: cThreeSpaceCategory(R)
comment:
\spad{check(s)} returns lllpt,{} list of lists of lists of point information about the \spadtype{ThreeSpace} \spad{s}.


kind: o
name: check
exposed: x
type: (Union(skip,MonteCarlo,deterministic))->%
params: dGuessOption
comment:
\spad{check(d)} specifies how we want to check the solution. If the value is skip,{} we return the solutions found by the interpolation routine without checking. If the value is MonteCarlo,{} we use a probabilistic check. This option is expressed in the form \spad{check == d}


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


kind: o
name: checkExtraValues
exposed: n
type: (List(GuessOption))->Boolean
params: dGuessOptionFunctions0
comment:
\spad{checkExtraValues(d)} specifies whether we want to check the solution beyond the order given by the degree bounds. The default is \spad{true}.


kind: o
name: checkExtraValues
exposed: x
type: (Boolean)->%
params: dGuessOption
comment:
\spad{checkExtraValues(d)} specifies whether we want to check the solution beyond the order given by the degree bounds. This option is expressed in the form \spad{checkExtraValues == d}


kind: o
name: checkForZero
exposed: n
params: pDefiniteIntegrationTools(R,F)
type:
(SparseUnivariatePolynomial(F),OrderedCompletion(F),OrderedCompletion(F),Boolean)->Union(Boolean,failed)

comment:
\spad{checkForZero(p,{} a,{} b,{} incl?)} is \spad{true} if \spad{p} has a zero between a and \spad{b},{} \spad{false} otherwise,{} failed if this cannot be determined. Check for a and \spad{b} inclusive if incl? is \spad{true},{} exclusive otherwise.


kind: o
name: checkForZero
exposed: n
type: (Polynomial(R),Symbol,OrderedCompletion(F),OrderedCompletion(F),Boolean)->Union(Boolean,failed)
params: pDefiniteIntegrationTools(R,F)
comment:
\spad{checkForZero(p,{} x,{} a,{} b,{} incl?)} is \spad{true} if \spad{p} has a zero for \spad{x} between a and \spad{b},{} \spad{false} otherwise,{} failed if this cannot be determined. Check for a and \spad{b} inclusive if incl? is \spad{true},{} exclusive otherwise.


kind: o
name: checkOptions
exposed: n
type: (List(GuessOption))->Void
params: dGuessOptionFunctions0
comment:
\spad{checkOptions checks} whether the given options are consistent,{} and yields an error otherwise


kind: o
name: checkRur
exposed: n
type: (TS,List(TS))->Boolean
params: pInternalRationalUnivariateRepresentationPackage(R,E,V,P,TS)
comment:
\spad{checkRur(ts,{} lus)} returns \spad{true} if \spad{lus} is a rational univariate representation of \spad{ts}.


kind: o
name: check_sol1a
exposed: n
params: pModularHermitePade
comment: \spad{check_sol1a performs} one round of modular Monte Carlo check for solutions.
type:
(Vector(U32Vector),List(U32Vector),(List(U32Vector),Integer,Integer)->Vector(U32Vector),Integer,Integer,Integer)->U32Vector


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


kind: o
name: children
exposed: x
type: (%)->List(%)
params: cRecursiveAggregate(S)
comment:
\spad{children(u)} returns a list of the children of aggregate \spad{u}. Error: if \spad{u} is empty.


kind: o
name: chineseRemainder
exposed: x
type: (List(List(R)),List(R))->List(R)
params: pCRApackage(R)
comment:
\spad{chineseRemainder(llv,{} lm)} returns a list of values,{} each of which corresponds to the Chinese remainder of the associated element of \spad{llv} and \spad{lm}. This is more efficient than applying chineseRemainder several times.


kind: o
name: chineseRemainder
exposed: x
type: (List(R),List(R))->R
params: pCRApackage(R)
comment:
\spad{chineseRemainder(lv,{} lm)} returns a value \spad{v} such that,{} if \spad{x} is \spad{lv.i} modulo \spad{lm.i} for all \spad{i},{} then \spad{x} is \spad{v} modulo \spad{lm(1)*lm(2)*...*lm(n)}.


kind: o
name: chineseRemainder
exposed: n
params: pChineseRemainderToolsForIntegralBases(K,R,UP)
comment: \spad{chineseRemainder(lu,{} lr,{} n)} \undocumented
type:
(List(UP),List(Record(basis:Matrix(R),basisDen:R,basisInv:Matrix(R))),NonNegativeInteger)->Record(basis:Matrix(R),basisDen:R,basisInv:Matrix(R))


kind: o
name: chineseRemainder
exposed: x
type: (Integer,Integer,Integer,Integer)->Integer
params: pIntegerNumberTheoryFunctions
comment:
\spad{chineseRemainder(x1,{} m1,{} x2,{} m2)} returns \spad{w},{} where \spad{w} is such that \spad{w = x1 mod m1} and \spad{w = x2 mod m2}. Note: \spad{m1} and \spad{m2} must be relatively prime.


kind: o
name: chinese_update
exposed: n
type: (U32Vector,Integer,%)->Void
params: dVectorModularReconstructor
comment:
\spad{chinese_update(v,{} pt,{} r)} informs \spad{r} that evaluation at \spad{pt} gave vector of values \spad{v}


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


kind: o
name: chvar
exposed: n
params: pChangeOfVariable(F,UP,UPUP)
comment: \spad{chvar(lf,{} p)} is like chvar(\spad{f},{} \spad{p}) but handles list of functions
type:
(List(UPUP),UPUP)->Record(func:List(UPUP),poly:UPUP,c1:Fraction(UP),c2:Fraction(UP),deg:NonNegativeInteger)


kind: o
name: chvar
exposed: n
type: (UPUP,UPUP)->Record(func:UPUP,poly:UPUP,c1:Fraction(UP),c2:Fraction(UP),deg:NonNegativeInteger)
params: pChangeOfVariable(F,UP,UPUP)
comment:
\spad{chvar(f(x,{} y),{} p(x,{} y))} returns \spad{[g(z,{} t),{} q(z,{} t),{} c1(x),{} c2(x),{} n]} such that under the change of variable \spad{z = c1(x)},{} \spad{t = y * c2(x)},{} one gets \spad{f(x,{} y) = c1'(x)g(c1(x),{} c2(x)y)} The algebraic relation between \spad{x} and \spad{y} is \spad{p(x,{} y) = 0}. The algebraic relation between \spad{z} and \spad{t} is \spad{q(z,{} t) = 0}.


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


kind: o
name: class
exposed: n
type: (List(NonNegativeInteger))->NonNegativeInteger
params: cJetBundleCategory
comment:
\spad{class(ind)} yields the class of the multi-index \spad{ind} (Position for first non-vanishing entry).


kind: o
name: class
exposed: n
type: (%)->NonNegativeInteger
params: cJetBundleCategory
comment:
\spad{class(jv)} yields the class of the jet variable \spad{jv} (Class of multi-index for derivative,{} 0 else).


kind: o
name: class
exposed: n
type: (%)->NonNegativeInteger
params: cJetBundleFunctionCategory(JB)
comment:
\spad{class(f)} is defined as the highest class of the jet variables effectively occurring in \spad{f}.


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


kind: o
name: classicalCumulant
exposed: n
type: (%,PositiveInteger)->R
params: cDistributionCategory(R)
comment:
\spad{classicalCumulant(x,{} n)} returns the \spad{n}-th classical cumulant of the distribution \spad{x}


kind: o
name: clearDenominator
exposed: n
type: (B)->A
params: pInnerCommonDenominator(R,Q,A,B)
comment:
\spad{clearDenominator([q1,{} ...,{} qn])} returns \spad{[p1,{} ...,{} pn]} such that \spad{\spad{qi} = pi/d} where \spad{d} is a common denominator for the \spad{qi}\spad{'s}.


kind: o
name: clearDenominator
exposed: n
type: (P)->P
params: pPolynomialCommonDenominator(R,Q,E,VarSet,P)
comment:
\spad{clearDenominator(q)} returns \spad{p} such that \spad{q = p/d} where \spad{d} is a common denominator for the coefficients of \spad{q}.


kind: o
name: clearDenominator
exposed: x
type: (Matrix(Q))->Matrix(R)
params: pMatrixCommonDenominator(R,Q)
comment:
\spad{clearDenominator(q)} returns \spad{p} such that \spad{q = p/d} where \spad{d} is a common denominator for the elements of \spad{q}.


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


kind: o
name: clip
exposed: n
params: pTwoDimensionalPlotClipping
type:
(List(List(Point(DoubleFloat))))->Record(brans:List(List(Point(DoubleFloat))),xValues:Segment(DoubleFloat),yValues:Segment(DoubleFloat))

comment:
\spad{clip(ll)} performs two-dimensional clipping on a list of lists of points,{} \spad{ll}; the default parameters \spad{1/2} for the fraction and \spad{5/1} for the scale are used in the \pspadfun{iClipParametric} subroutine,{} which is called by this function.


kind: o
name: clip
exposed: n
params: pTwoDimensionalPlotClipping
type:
(List(Point(DoubleFloat)))->Record(brans:List(List(Point(DoubleFloat))),xValues:Segment(DoubleFloat),yValues:Segment(DoubleFloat))

comment:
\spad{clip(l)} performs two-dimensional clipping on a curve \spad{l},{} which is a list of points; the default parameters \spad{1/2} for the fraction and \spad{5/1} for the scale are used in the \pspadfun{iClipParametric} subroutine,{} which is called by this function.


kind: o
name: clip
exposed: n
params: pTwoDimensionalPlotClipping
type:
(Plot)->Record(brans:List(List(Point(DoubleFloat))),xValues:Segment(DoubleFloat),yValues:Segment(DoubleFloat))

comment:
\spad{clip(p)} performs two-dimensional clipping on a plot,{} \spad{p},{} from the domain \spadtype{Plot} for the graph of one variable,{} \spad{y = f(x)}; the default parameters \spad{1/4} for the fraction and \spad{5/1} for the scale are used in the \spadfun{clip} function.


kind: o
name: clip
exposed: x
type: (Boolean)->%
params: dDrawOption
comment:
\spad{clip(b)} turns 2D clipping on if \spad{b} is \spad{true},{} or off if \spad{b} is \spad{false}. This option is expressed in the form \spad{clip == b}.


kind: o
name: clip
exposed: x
type: (List(Segment(Float)))->%
params: dDrawOption
comment:
\spad{clip([l])} provides ranges for user-defined clipping as specified in the list \spad{l}. This option is expressed in the form \spad{clip == [l]}.


kind: o
name: clip
exposed: n
params: pTwoDimensionalPlotClipping
type:
(Plot,Fraction(Integer),Fraction(Integer))->Record(brans:List(List(Point(DoubleFloat))),xValues:Segment(DoubleFloat),yValues:Segment(DoubleFloat))

comment:
\spad{clip(p,{} frac,{} sc)} performs two-dimensional clipping on a plot,{} \spad{p},{} from the domain \spadtype{Plot} for the graph of one variable \spad{y = f(x)}; the fraction parameter is specified by \spad{frac} and the scale parameter is specified by \spad{sc} for use in the \spadfun{clip} function.


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


kind: o
name: clipParametric
exposed: n
params: pTwoDimensionalPlotClipping
type:
(Plot)->Record(brans:List(List(Point(DoubleFloat))),xValues:Segment(DoubleFloat),yValues:Segment(DoubleFloat))

comment:
\spad{clipParametric(p)} performs two-dimensional clipping on a plot,{} \spad{p},{} from the domain \spadtype{Plot} for the parametric curve \spad{x = f(t)},{} \spad{y = g(t)}; the default parameters \spad{1/2} for the fraction and \spad{5/1} for the scale are used in the \pspadfun{iClipParametric} subroutine,{} which is called by this function.


kind: o
name: clipParametric
exposed: n
params: pTwoDimensionalPlotClipping
type:
(Plot,Fraction(Integer),Fraction(Integer))->Record(brans:List(List(Point(DoubleFloat))),xValues:Segment(DoubleFloat),yValues:Segment(DoubleFloat))

comment:
\spad{clipParametric(p,{} frac,{} sc)} performs two-dimensional clipping on a plot,{} \spad{p},{} from the domain \spadtype{Plot} for the parametric curve \spad{x = f(t)},{} \spad{y = g(t)}; the fraction parameter is specified by \spad{frac} and the scale parameter is specified by \spad{sc} for use in the \pspadfun{iClipParametric} subroutine,{} which is called by this function.


kind: o
name: clipPointsDefault
exposed: x
type: (Boolean)->Boolean
params: pGraphicsDefaults
comment:
\spad{clipPointsDefault(true)} turns on automatic clipping; \spad{clipPointsDefault(false)} turns off automatic clipping. The default setting is \spad{true}.


kind: o
name: clipSurface
exposed: x
type: (%,String)->Void
params: dThreeDimensionalViewport
comment:
\spad{clipSurface(v,{} s)} displays the graph with the specified clipping region removed if \spad{s} is on,{} or displays the graph without clipping implemented if \spad{s} is off,{} for the given three-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{ThreeDimensionalViewport}.


kind: o
name: clipWithRanges
exposed: n
params: pTwoDimensionalPlotClipping
type:
(List(List(Point(DoubleFloat))),DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat)->Record(brans:List(List(Point(DoubleFloat))),xValues:Segment(DoubleFloat),yValues:Segment(DoubleFloat))

comment:
\spad{clipWithRanges(pointLists,{} xMin,{} xMax,{} yMin,{} yMax)} performs clipping on a list of lists of points,{} \spad{pointLists}. Clipping is done within the specified ranges of \spad{xMin},{} \spad{xMax} and \spad{yMin},{} \spad{yMax}. This function is used internally by the \pspadfun{iClipParametric} subroutine in this package.


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


kind: o
name: close
exposed: n
type: (%)->Void
params: dTwoDimensionalViewport
comment:
\spad{close(v)} closes the viewport window of the given two-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{TwoDimensionalViewport},{} and terminates the corresponding process ID.


kind: o
name: close
exposed: x
type: (%)->Void
params: dThreeDimensionalViewport
comment:
\spad{close(v)} closes the viewport window of the given three-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{ThreeDimensionalViewport},{} and terminates the corresponding process ID.


kind: o
name: closeComponent
exposed: n
type: (%,List(NonNegativeInteger),Boolean)->%
params: dSubSpace(n,R)
comment:
\spad{closeComponent(s,{} \spad{li},{} b)} sets the property of the component in the 3 dimensional subspace,{} \spad{s},{} to be closed if \spad{b} is \spad{true},{} or open if \spad{b} is \spad{false}. 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 closed property is to be set. The subspace,{} \spad{s},{} is returned with the component property modification.


kind: o
name: closedCartesian
exposed: n
type: (%,%,(S,S)->S)->%
params: dDirectedGraph(S)
comment:
\spad{closedCartesian(a,{} b,{} f)} builds Cartesian product of a and \spad{b} and then maps it back to \% using \spad{f}.


kind: o
name: closedCurve?
exposed: x
type: (%)->Boolean
params: cThreeSpaceCategory(R)
comment:
\spad{closedCurve?(s)} returns \spad{true} if the \spadtype{ThreeSpace} \spad{s} contains a single closed curve component,{} \spadignore{i.e.} the first element of the curve is also the last element,{} or \spad{false} otherwise.


kind: o
name: closedCurve
exposed: x
type: (List(Point(R)))->%
params: cThreeSpaceCategory(R)
comment:
\spad{closedCurve(lp)} sets a list of points defined by the first element of \spad{lp} through the last element of \spad{lp} and back to the first element again and returns a \spadtype{ThreeSpace} whose component is the closed curve defined by \spad{lp}.


kind: o
name: closedCurve
exposed: x
type: (%)->List(Point(R))
params: cThreeSpaceCategory(R)
comment:
\spad{closedCurve(s)} checks to see if the \spadtype{ThreeSpace},{} \spad{s},{} is composed of a single closed curve component defined by a list of points in which the first point is also the last point,{} all of which are from the domain \spad{PointDomain(m,{} R)} and if so,{} returns the list of points. An error is signaled otherwise.


kind: o
name: closedCurve
exposed: x
type: (%,List(List(R)))->%
params: cThreeSpaceCategory(R)
comment:
\spad{closedCurve(s,{} [[lr0],{} [lr1],{} ...,{} [lrn],{} [lr0]])} adds a closed curve component defined by a list of points \spad{lr0} through \spad{lrn},{} which are 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,{} in which the last element of the list of points contains a copy of the first element list,{} \spad{lr0}. The closed curve is added to the \spadtype{ThreeSpace},{} \spad{s}.


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


kind: o
name: closedTensor
exposed: n
type: (%,%,(S,S)->S)->%
params: dDirectedGraph(S)
comment:
\spad{closedTensor(a,{} b,{} f)} builds tensor product of a and \spad{b} and then maps it back to \% using \spad{f}.


kind: o
name: closedTensor
exposed: n
type: (%,%,(S,S)->S)->%
params: dFunctionGraph(S)
comment:
as tensor product but returns \%. Cartesian product does apply to function graph produces two arrows out of every node


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


kind: o
name: coAdjoint
exposed: n
type: (%,List(NonNegativeInteger))->Union(List(NonNegativeInteger),failed)
params: dFunctionGraph(S)
comment:
given a mapping from this graph this function tries to calculate a unique reverse mapping back to this graph


kind: o
name: coChain
exposed: n
type: (%)->CoChainComplex(VS)
params: dFiniteSimplicialComplex(VS)
comment:
returns a matrix sequence representing the face maps in linear algebra form For more information: \url{http://www.euclideanspace.com/prog/scratchpad/mycode/topology/chain/cochain/index.\spad{htm}}


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


kind: o
name: code
exposed: n
params: dFortranCode
comment: \spad{code(f)} returns the internal representation of the object represented by \spad{f}.
type:
(%)->Union(nullBranch:null,assignmentBranch:Record(var:Symbol,arrayIndex:List(Polynomial(Integer)),rand:Record(ints2Floats?:Boolean,expr:OutputForm)),arrayAssignmentBranch:Record(var:Symbol,rand:OutputForm,ints2Floats?:Boolean),conditionalBranch:Record(switch:Switch,thenClause:%,elseClause:%),returnBranch:Record(empty?:Boolean,value:Record(ints2Floats?:Boolean,expr:OutputForm)),blockBranch:List(%),commentBranch:List(String),callBranch:String,forBranch:Record(range:SegmentBinding(Polynomial(Integer)),span:Polynomial(Integer),body:%),labelBranch:SingleInteger,loopBranch:Record(switch:Switch,body:%),commonBranch:Record(name:Symbol,contents:List(Symbol)),printBranch:List(OutputForm))


kind: o
name: coef
exposed: n
type: (%,E)->R
params: dXPolynomialRing(R,E)
comment:
\spad{coef(p,{} e)} extracts the coefficient of the monomial \spad{e}. Returns zero if \spad{e} is not present.


kind: o
name: coef
exposed: x
type: (%,%)->R
params: cXFreeAlgebra(vl,R)
comment:
\spad{coef(x,{} y)} returns scalar product of \spad{x} by \spad{y},{} the set of words being regarded as an orthogonal basis.


kind: o
name: coef
exposed: x
type: (XRecursivePolynomial(VarSet,R),%)->R
params: cFreeLieAlgebra(VarSet,R)
comment:
\spad{coef(x,{} y)} returns the scalar product of \spad{x} by \spad{y},{} the set of words being regarded as an orthogonal basis.


kind: o
name: coefficient
exposed: n
type: (%,%)->Expression(CoefRing)
params: dDeRhamComplex(CoefRing,listIndVar)
comment:
\spad{coefficient(df,{} u)},{} where \spad{df} is a differential form,{} returns the coefficient of \spad{df} containing the basis term \spad{u} if such a term exists,{} and 0 otherwise.


kind: o
name: coefficient
exposed: n
type: (%,JB)->D
params: dJetDifferential(JB,D)
comment:
\spad{coefficient(om,{} jb)} returns the coefficient of \spad{om} for the differential of \spad{jb}.


kind: o
name: coefficient
exposed: n
type: (%,%)->R
params: dAntiSymm(R,lVar)
comment:
\spad{coefficient(p,{} u)} returns the coefficient of the term in \spad{p} containing the basis term \spad{u} if such a term exists,{} and 0 otherwise. Error: if the second argument \spad{u} is not a basis element.


kind: o
name: coefficient
exposed: x
type: (%,E)->R
params: cAbelianMonoidRing(R,E)
comment:
\spad{coefficient(p,{} e)} extracts the coefficient of the monomial with exponent \spad{e} from polynomial \spad{p},{} or returns zero if exponent is not present.


kind: o
name: coefficient
exposed: x
type: (%,List(PositiveInteger))->K
params: dCliffordAlgebra(n,K,bLin)
comment:
\spad{coefficient(x,{} [i1,{} i2,{} ...,{} iN])} extracts the coefficient of \spad{e(i1)*e(i2)*...*e(iN)} in \spad{x}.


kind: o
name: coefficient
exposed: n
type: (%,List(VarSet),List(NonNegativeInteger))->%
params: cMaybeSkewPolynomialCategory(R,E,VarSet)
comment:
\spad{coefficient(p,{} lv,{} ln)} views the polynomial \spad{p} as a polynomial in the variables of \spad{lv} and returns the coefficient of the term \spad{lv^ln},{} \spadignore{i.e.} \spad{prod(lv_i ^ ln_i)}.


kind: o
name: coefficient
exposed: n
type: (%,VarSet,NonNegativeInteger)->%
params: cMaybeSkewPolynomialCategory(R,E,VarSet)
comment:
\spad{coefficient(p,{} v,{} n)} views the polynomial \spad{p} as a univariate polynomial in \spad{v} and returns the coefficient of the \spad{v^n} term.


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


kind: o
name: coefficients
exposed: n
type: (%)->Stream(Coef)
params: dInnerTaylorSeries(Coef)
comment:
\spad{coefficients(x)} returns a stream of ring elements. \indented{1}{When \spad{x} is a univariate series,{} this is a stream of Taylor} \indented{1}{coefficients. When \spad{x} is a multivariate series,{} the} \indented{1}{\spad{n}th element of the stream is a form of} \indented{1}{degree \spad{n} in the power series variables.}


kind: o
name: coefficients
exposed: n
type: (%)->Stream(SMP)
params: dSparseMultivariateTaylorSeries(Coef,Var,SMP)
comment:
\spad{coefficients(s)} gives stream of coefficients of \spad{s},{} \spadignore{i.e.} [coefficient(\spad{s},{}0),{} coefficient(\spad{s},{}1),{} ...]


kind: o
name: coefficients
exposed: x
type: (%)->Stream(Coef)
params: cUnivariateTaylorSeriesCategory(Coef)
comment:
\spad{coefficients(a0 + a1 x + a2 x^2 + ...)} returns a stream of coefficients: \spad{[a0,{} a1,{} a2,{} ...]}. The entries of the stream may be zero.


kind: o
name: coeffs0
exposed: n
params: pPrimGCD
comment: \spad{coeffs0(x,{} lv,{} lp)} is used by \spad{coeffs1}
type:
(SparseMultivariatePolynomial(Integer,Symbol),List(Symbol),List(SparseMultivariatePolynomial(Integer,Symbol)))->List(SparseMultivariatePolynomial(Integer,Symbol))


kind: o
name: coeffs1
exposed: n
params: pPrimGCD
type:
(SparseMultivariatePolynomial(Integer,Symbol),List(Symbol))->List(SparseMultivariatePolynomial(Integer,Symbol))

comment:
\spad{coeffs1(x,{} lv)} computes list of coefficients of \spad{x} with respect to variables in \spad{lv}. Variables in \spad{lv} must be decreasing and bigger than all other variables of \spad{x}.


kind: o
name: coerce
exposed: n
type: (D)->%
params: dJetLazyFunction(JB,D)
comment:
\spad{coerce(d)} coerces an element of \spad{D} into the new domain. This includes the calculation of its leading derivative and its jet variables.


kind: o
name: coerce
exposed: n
type: (%)->D
params: dJetLazyFunction(JB,D)
comment:
\spad{coerce(exp)} retracts an element to the base domain \spad{D}. This looses all information about its leading derivative and its jet variables and requires complete evaluation of the expression.


kind: o
name: coerce
exposed: n
type: (F)->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{coerce(c)} converts the constant \spad{c} into an element of the free field represented by an ALS in minimal refined form.


kind: o
name: coerce
exposed: n
type: (FortranCode)->%
params: cFortranFunctionCategory
comment:
\spad{coerce(e)} takes an object from \spadtype{FortranCode} and \indented{1}{uses it as the body of an ASP.}


kind: o
name: coerce
exposed: n
type: (FreeMonoid(VAR))->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{coerce(m)} converts the monoid \spad{m} into an element of the free field represented by an ALS in minimal refined form.


kind: o
name: coerce
exposed: n
type: (%)->FreeMonoid(VarSet)
params: dFreeMagma(VarSet)
comment:
\spad{coerce(x)} returns the element of \spadtype{FreeMonoid}(VarSet) corresponding to \spad{x} by removing parentheses.


kind: o
name: coerce
exposed: n
type: (%)->FreeMonoid(VarSet)
params: dPoincareBirkhoffWittLyndonBasis(VarSet)
comment:
\spad{coerce([l1]*[l2]*...[ln])} returns the word \spad{l1*l2*...*ln},{} where \spad{[l_i]} is the backeted form of the Lyndon word \spad{l_i}.


kind: o
name: coerce
exposed: n
type: (GraphImage)->TwoDimensionalViewport
params: pViewportPackage
comment:
\spad{coerce(\spad{gi})} converts the indicated \spadtype{GraphImage},{} \spad{gi},{} into the \spadtype{TwoDimensionalViewport} form.


kind: o
name: coerce
exposed: n
type: (Lambda(UT))->SKICombinators(UT)
params: pcompUtil(UT)
comment:
\spad{coerce Lambda} term to SKI combinators. this process is known as abstraction elimination. it is done by applying the following rules until all lambda terms have been eliminated. rule LS1: Lam[\spad{x}] \spad{=>} \spad{x} rule LS2: Lam[(\spad{E1} \spad{E2})] \spad{=>} (Lam[\spad{E1}] Lam[\spad{E2}]) rule LS3: Lam[\spad{x}.\spad{E}] \spad{=>} (\spad{K} Lam[\spad{E}]) (if \spad{x} does not occur free in \spad{E}) rule LS4: Lam[\spad{x}.\spad{x}] \spad{=>} \spad{I} rule LS5: Lam[\spad{x}.\spad{y}.\spad{E}] \spad{=>} Lam[\spad{x}.Lam[\spad{y}.\spad{E}]] (if \spad{x} occurs free in \spad{E}) rule LS6: Lam[\spad{x}.(\spad{E1} \spad{E2})] \spad{=>} (\spad{S} Lam[\spad{x}.\spad{E1}] Lam[\spad{x}.\spad{E2}])


kind: o
name: coerce
exposed: n
type: (List(FortranCode))->%
params: cFortranFunctionCategory
comment:
\spad{coerce(e)} takes an object from \spadtype{List FortranCode} and \indented{1}{uses it as the body of an ASP.}


kind: o
name: coerce
exposed: n
type: (List(Integer))->%
params: dExtAlgBasis
comment:
\spad{coerce(l)} converts a list of 0\spad{'s} and 1\spad{'s} into a basis element,{} where 1 (respectively 0) designates that the variable of the corresponding index of \spad{l} is (respectively,{} is not) present. Error: if an element of \spad{l} is not 0 or 1.


kind: o
name: coerce
exposed: n
type: (List(List(Point(DoubleFloat))))->%
params: dGraphImage
comment:
\spad{coerce(llp)} creates and returns a graph of the domain \spadtype{GraphImage} which is composed of the list of list of points given by \spad{llp},{} and whose point colors,{} line colors and point sizes are determined by the default functions \spadfun{pointColorDefault},{} \spadfun{lineColorDefault},{} and \spadfun{pointSizeDefault}. The graph data is then sent to the viewport manager where it waits to be included in a two-dimensional viewport window.


kind: o
name: coerce
exposed: n
type: (%)->List(String)
params: dXmlElement
comment:
\spad{coerce(x)} outputs \spad{x} as a list of strings. Each element in the list represents a new line. This is an alternative to creating a long single string with 'newline' embedded in it.


kind: o
name: coerce
exposed: n
type: (%)->Matrix(R)
params: dRectangularMatrix(m,n,R)
comment:
\spad{coerce(m)} converts a matrix of type \spadtype{RectangularMatrix} to a matrix of type \spad{Matrix}.


kind: o
name: coerce
exposed: n
type: (%)->Matrix(R)
params: dSquareMatrix(ndim,R)
comment:
\spad{coerce(m)} converts a matrix of type \spadtype{SquareMatrix} to a matrix of type \spadtype{Matrix}.


kind: o
name: coerce
exposed: n
type: (%)->OutputForm
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{coerce(f)} prints the ALS of \spad{f} if the debug flag is set and a rational expression if the alternative output flag is set.


kind: o
name: coerce
exposed: n
type: (%)->OutputForm
params: dGraphImage
comment:
\spad{coerce(\spad{gi})} returns the indicated graph,{} \spad{\spad{gi}},{} of domain \spadtype{GraphImage} as output of the domain \spadtype{OutputForm}.


kind: o
name: coerce
exposed: n
type: (%)->OutputForm
params: dScene(PT)
comment:
output a full scenegraph could contain a lot of data and so we have to be careful to restrict the output to what is reasonable on the command line. Therefore we do not display all subnodes or the full information from nodes such as IFS.


kind: o
name: coerce
exposed: n
type: (%)->OutputForm
params: dTwoDimensionalViewport
comment:
\spad{coerce(v)} returns the given two-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{TwoDimensionalViewport} as output of the domain \spadtype{OutputForm}.


kind: o
name: coerce
exposed: n
type: (PrimitiveArray(PrimitiveArray(PrimitiveArray(R))))->%
params: dThreeDimensionalMatrix(R)
comment:
\spad{coerce(p)} moves from the representation type (PrimitiveArray PrimitiveArray PrimitiveArray \spad{R}) to the domain


kind: o
name: coerce
exposed: n
type: (Record(localSymbols:SymbolTable,code:List(FortranCode)))->%
params: cFortranFunctionCategory
comment:
\spad{coerce(e)} takes the component of \spad{e} from \spadtype{List FortranCode} and uses it as the body of the ASP,{} making the declarations in the \spadtype{SymbolTable} component.


kind: o
name: coerce
exposed: n
type: (SKICombinators(UT))->ILogic
params: pcompUtil(UT)
comment:
\spad{coerce combinators} to intuitionistic logic this is known as the Curry-Howard isomorphism it uses the following rules: rule SI1: Ski[Kab] \spad{=>} a \spad{->} (\spad{b} \spad{->} a),{} rule SI2: Ski[Sabc] \spad{=>} (a \spad{->} (\spad{b} \spad{->} \spad{c})) \spad{->} ((a \spad{->} \spad{b}) \spad{->} (a \spad{->} \spad{c})),{} rule SI3: Ski[a a-\spad{>b}] \spad{=>} \spad{b} the last rule is function application (modus ponens)


kind: o
name: coerce
exposed: n
type: (SKICombinators(UT))->Lambda(UT)
params: pcompUtil(UT)
comment:
\spad{coerce SKI} combinators to Lambda term. this conversion is done by applying the following rules rule SL1: Ski[\spad{I}] = \spad{x}.0 rule SL2: Ski[\spad{K}] = \spad{x}.\spad{y}.1 rule SL3: Ski[\spad{S}] = \spad{x}.\spad{y}.\spad{z}.(2 0 (1 0)) rule SL4: Ski[(\spad{E1} \spad{E2})] = (Ski[\spad{E1}] Ski[\spad{E2}])


kind: o
name: coerce
exposed: n
type: (String)->%
params: dFortranScalarType
comment:
\spad{coerce(s)} transforms the string \spad{s} into an element of FortranScalarType provided \spad{s} is one of real,{} double precision,{} complex,{} logical,{} integer,{} character,{} REAL,{} COMPLEX,{} LOGICAL,{} INTEGER,{} CHARACTER,{} DOUBLE PRECISION


kind: o
name: coerce
exposed: n
type: (Symbol)->%
params: dFortranScalarType
comment:
\spad{coerce(s)} transforms the symbol \spad{s} into an element of FortranScalarType provided \spad{s} is one of real,{} complex,{} double precision,{} logical,{} integer,{} character,{} REAL,{} COMPLEX,{} LOGICAL,{} INTEGER,{} CHARACTER,{} DOUBLE PRECISION


kind: o
name: coerce
exposed: n
type: (Symbol)->%
params: dJetBundle(IVar,DVar)
comment:
\spad{coerce(sy)} allows for the input of jet variables as symbols. Yields an error,{} if the symbol is not contained in \spad{IVar} or \spad{DVar}.


kind: o
name: coerce
exposed: n
type: (UnivariatePolynomial(var,Coef))->%
params: dSparseUnivariateTaylorSeries(Coef,var,cen)
comment:
\spad{coerce(p)} converts a univariate polynomial \spad{p} in the variable \spad{var} to a univariate Taylor series in \spad{var}.


kind: o
name: coerce
exposed: n
type: (UnivariatePuiseuxSeries(FE,var,cen))->%
params: dExponentialExpansion(R,FE,var,cen)
comment:
\spad{coerce(f)} converts a \spadtype{UnivariatePuiseuxSeries} to an \spadtype{ExponentialExpansion}.


kind: o
name: coerce
exposed: n
type: (Vector(Fraction(Polynomial(R))))->%
params: dGenericNonAssociativeAlgebra(R,n,ls,gamma)
comment:
\spad{coerce(v)} assumes that it is called with a vector of length equal to the dimension of the algebra,{} then a linear combination with the basis element is formed


kind: o
name: coerce
exposed: n
type: (Vector(Matrix(R)))->Vector(Matrix(Fraction(Polynomial(R))))
params: pCoerceVectorMatrixPackage(R)
comment:
\spad{coerce(v)} coerces a vector \spad{v} with entries in \spadtype{Matrix R} as vector over \spadtype{Matrix Fraction Polynomial R}


kind: o
name: coerce
exposed: n
type: (XDistributedPolynomial(VAR,F))->%
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{coerce(p)} converts the polynomial \spad{p} to an element in the free field represented by an minimal admissible linear system.


kind: o
name: coerce
exposed: x
type: (A)->%
params: dAssociatedJordanAlgebra(R,A)
comment:
\spad{coerce(a)} coerces the element \spad{a} of the algebra \spad{A} to an element of the Jordan algebra \spadtype{AssociatedJordanAlgebra}(\spad{R},{} A).


kind: o
name: coerce
exposed: x
type: (A)->%
params: dAssociatedLieAlgebra(R,A)
comment:
\spad{coerce(a)} coerces the element \spad{a} of the algebra \spad{A} to an element of the Lie algebra \spadtype{AssociatedLieAlgebra}(\spad{R},{} A).


kind: o
name: coerce
exposed: x
type: (Exit)->S
params: pResolveLatticeCompletion(S)
comment:
\spad{coerce(e)} is never really evaluated. This coercion is used for formal type correctness when a function will not return directly to its caller.


kind: o
name: coerce
exposed: x
type: (F1)->F2
params: pFiniteFieldHomomorphisms(F1,GF,F2)
comment:
\spad{coerce(x)} is the homomorphic image of \spad{x} from {\em F1} in {\em F2}. Thus {\em coerce} is a field homomorphism between the fields extensions {\em F1} and {\em F2} both over ground field {\em GF} (the second argument to the package). Error: if the extension degree of {\em F1} doesn\spad{'t} divide the extension degree of {\em F2}. Note that the other coercion function in the \spadtype{FiniteFieldHomomorphisms} is a left inverse.


kind: o
name: coerce
exposed: x
type: (F2)->F1
params: pFiniteFieldHomomorphisms(F1,GF,F2)
comment:
\spad{coerce(x)} is the homomorphic image of \spad{x} from {\em F2} in {\em F1},{} where {\em coerce} is a field homomorphism between the fields extensions {\em F2} and {\em F1} both over ground field {\em GF} (the second argument to the package). Error: if the extension degree of {\em F2} doesn\spad{'t} divide the extension degree of {\em F1}. Note that the other coercion function in the \spadtype{FiniteFieldHomomorphisms} is a left inverse.


kind: o
name: coerce
exposed: x
type: (Fraction(Factored(R)))->%
params: dPartialFraction(R)
comment:
\spad{coerce(f)} takes a fraction with numerator and denominator in factored form and creates a partial fraction. It is necessary for the parts to be factored because it is not known in general how to factor elements of \spad{R} and this is needed to decompose into partial fractions.


kind: o
name: coerce
exposed: x
type: (Fraction(Polynomial(AlgebraicNumber)))->Expression(Integer)
params: pPolynomialAN2Expression
comment:
\spad{coerce(rf)} converts \spad{rf},{} a fraction of polynomial \spad{p} with algebraic number coefficients to \spadtype{Expression Integer}.


kind: o
name: coerce
exposed: x
type: (List(List(S)))->%
params: dPermutation(S)
comment:
\spad{coerce(lls)} coerces a list of cycles {\em lls} to a permutation,{} each cycle being a list with no 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: coerce
exposed: x
type: (List(S))->%
params: dPermutation(S)
comment:
\spad{coerce(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: coerce
exposed: x
type: (Polynomial(AlgebraicNumber))->Expression(Integer)
params: pPolynomialAN2Expression
comment:
\spad{coerce(p)} converts the polynomial \spad{p} with algebraic number coefficients to \spadtype{Expression Integer}.


kind: o
name: coerce
exposed: x
type: (SegmentBinding(Expression(R)))->SegmentBinding(Float)
params: pDrawNumericHack(R)
comment:
\spad{coerce(x = a..b)} returns \spad{x = c..d} where \spad{c} and \spad{d} are the numerical values of \spad{a} and \spad{b}.


kind: o
name: coerce
exposed: x
type: (S)->TexFormat
params: pTexFormat1(S)
comment:
\spad{coerce(s)} provides a direct coercion from a domain \spad{S} to TeX format. This allows the user to skip the step of first manually coercing the object to standard output format before it is coerced to TeX format.


kind: o
name: coerce
exposed: x
type: (%)->String
params: cFileNameCategory
comment:
\spad{coerce(fn)} produces a string for a file name according to operating system-dependent conventions.


kind: o
name: coerce
exposed: x
type: (String)->%
params: cFileNameCategory
comment:
\spad{coerce(s)} converts a string to a file name according to operating system-dependent conventions.


kind: o
name: coerce
exposed: x
type: (String)->%
params: dIndexCard
comment:
\spad{coerce(s)} converts \spad{s} into an \spad{IndexCard}. Warning: if \spad{s} is not of the right format then an error will occur when using it.


kind: o
name: coerce
exposed: x
type: (S)->Void
params: pResolveLatticeCompletion(S)
comment:
\spad{coerce(s)} throws all information about \spad{s} away. This coercion allows values of any type to appear in contexts where they will not be used. For example,{} it allows the resolution of different types in the \spad{then} and \spad{else} branches when an \spad{if} is in a context where the resulting value is not used.


kind: o
name: coerce
exposed: x
type: (Symbol)->%
params: dOpenMathErrorKind
comment:
\spad{coerce(u)} creates an OpenMath error object of an appropriate type if \spad{u} is one of \spad{OMParseError},{} \spad{OMReadError},{} \spad{OMUnknownCD} or \spad{OMUnknownSymbol},{} otherwise it raises a runtime error.


kind: o
name: coerce
exposed: x
type: (Vector(R))->%
params: dAlgebraGivenByStructuralConstants(R,n,ls,gamma)
comment:
\spad{coerce(v)} converts a vector to a member of the algebra by forming a linear combination with the basis element. Note: the vector is assumed to have length equal to the dimension of the algebra.


kind: o
name: coerceImages
exposed: x
type: (List(S))->%
params: dPermutation(S)
abbrev: AND(has(S,Finite),not(has(S,IntegerNumberSystem)))
comment:
\spad{coerceImages(ls)} coerces the list {\em ls} to a permutation whose image is given by {\em ls} and the preimage is fixed to be {\em [1,{} ...,{} n]}. Note: {coerceImages(\spad{ls})=coercePreimagesImages([1,{} ...,{} \spad{n}],{} \spad{ls})}. We assume that both preimage and image do not contain repetitions.


kind: o
name: coerceL
exposed: n
type: (OutputForm)->String
params: dHTMLFormat
comment:
\spad{coerceL(o)} changes \spad{o} in the standard output format to html format and displays result as one long string.


kind: o
name: coerceL
exposed: n
type: (OutputForm)->String
params: dMathMLFormat
comment:
\spad{coerceL(o)} changes \spad{o} in the standard output format to MathML format and displays result as one long string.


kind: o
name: coerceL
exposed: n
type: (OutputForm)->String
params: dTexmacsFormat
comment:
\spad{coerceL(o)} changes \spad{o} in the standard output format to Texmacs format and displays result as one long string.


kind: o
name: coerceListOfPairs
exposed: x
type: (List(List(S)))->%
params: dPermutation(S)
comment:
\spad{coerceListOfPairs(lls)} coerces a list of pairs {\em lls} to a permutation. Error: if not consistent,{} \spadignore{i.e.} the set of the first elements coincides with the set of second elements. coerce(\spad{p}) generates output of the permutation \spad{p} with domain OutputForm.


kind: o
name: coerceP
exposed: n
type: (Vector(Matrix(R)))->Vector(Matrix(Polynomial(R)))
params: pCoerceVectorMatrixPackage(R)
comment:
\spad{coerceP(v)} coerces a vector \spad{v} with entries in \spadtype{Matrix R} as vector over \spadtype{Matrix Polynomial R}


kind: o
name: coercePreimagesImages
exposed: x
type: (List(List(S)))->%
params: dPermutation(S)
comment:
\spad{coercePreimagesImages(lls)} coerces the representation {\em lls} of a permutation as a list of preimages and images to a permutation. We assume that both preimage and image do not contain repetitions.


kind: o
name: coerceS
exposed: n
type: (OutputForm)->String
params: dHTMLFormat
comment:
\spad{coerceS(o)} changes \spad{o} in the standard output format to html format and displays formatted result.


kind: o
name: coerceS
exposed: n
type: (OutputForm)->String
params: dMathMLFormat
comment:
\spad{coerceS(o)} changes \spad{o} in the standard output format to MathML format and displays formatted result.


kind: o
name: coHomology
exposed: n
type: (%)->List(Homology)
params: dFiniteSimplicialComplex(VS)
comment:
calculate cohomology using SmithNormalForm \url{http://www.euclideanspace.com/prog/scratchpad/mycode/topology/homology/cohomol/index.\spad{htm}}


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


kind: o
name: colinearity
exposed: n
type: (%,%)->DoubleFloat
params: cSPointCategory
comment:
\spad{colinearity(x,{} y)} returns a measure of how parallel two vectors are independent of the length of the vectors: 1.0 is completely parallel 0.0 is completely perpendicular returned value will be between these


kind: o
name: collect
exposed: x
type: (%,VarSet)->%
params: cPolynomialSetCategory(R,E,VarSet,P)
comment:
\spad{collect(ps,{} v)} returns the set consisting of the polynomials of \spad{ps} with \spad{v} as main variable.


kind: o
name: collectQuasiMonic
exposed: x
type: (%)->%
params: cTriangularSetCategory(R,E,V,P)
comment:
\spad{collectQuasiMonic(ts)} returns the subset of \spad{ts} consisting of the polynomials with initial in \spad{R}.


kind: o
name: collectUnder
exposed: x
type: (%,VarSet)->%
params: cPolynomialSetCategory(R,E,VarSet,P)
comment:
\spad{collectUnder(ps,{} v)} returns the set consisting of the polynomials of \spad{ps} with main variable less than \spad{v}.


kind: o
name: collectUpper
exposed: x
type: (%,VarSet)->%
params: cPolynomialSetCategory(R,E,VarSet,P)
comment:
\spad{collectUpper(ps,{} v)} returns the set consisting of the polynomials of \spad{ps} with main variable greater than \spad{v}.


kind: o
name: color
exposed: n
type: (Point(R))->R
params: pPointPackage(R)
comment:
\spad{color(pt)} returns the fourth element of the 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,{} color to express a fourth dimension.


kind: o
name: colorDef
exposed: x
type: (%,Color,Color)->Void
params: dThreeDimensionalViewport
comment:
\spad{colorDef(v,{} c1,{} c2)} sets the range of colors along the colormap so that the lower end of the colormap is defined by \spad{c1} and the top end of the colormap is defined by \spad{c2},{} for the given three-dimensional viewport,{} \spad{v},{} which is of domain \spadtype{ThreeDimensionalViewport}.


kind: o
name: colorFunction
exposed: x
type: ((DoubleFloat)->DoubleFloat)->%
params: dDrawOption
comment:
\spad{colorFunction(f(z))} specifies the color based upon the \spad{z}-component of three dimensional plots. This option is expressed in the form \spad{colorFunction == f(z)}.


kind: o
name: colorFunction
exposed: x
type: ((DoubleFloat,DoubleFloat)->DoubleFloat)->%
params: dDrawOption
comment:
\spad{colorFunction(f(u,{} v))} specifies the color for three dimensional plots as a function based upon the two parametric variables. This option is expressed in the form \spad{colorFunction == f(u,{} v)}.


kind: o
name: colorFunction
exposed: x
type: ((DoubleFloat,DoubleFloat,DoubleFloat)->DoubleFloat)->%
params: dDrawOption
comment:
\spad{colorFunction(f(x,{} y,{} z))} specifies the color for three dimensional plots as a function of \spad{x},{} \spad{y},{} and \spad{z} coordinates. This option is expressed in the form \spad{colorFunction == f(x,{} y,{} z)}.


kind: o
name: colSlice
exposed: x
type: (%)->Segment(Integer)
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{colSlice(m)} returns a segment \spad{s} such that for \spad{m} the access \spad{m}(\spad{i},{} \spad{s}) gives the \spad{i}-th row.


kind: o
name: column
exposed: x
type: (%,Integer)->Col
params: cRectangularMatrixCategory(m,n,R,Row,Col)
comment:
\spad{column(m,{} j)} returns the \spad{j}th column of the matrix \spad{m}. Error: if the index outside the proper range.


kind: o
name: column
exposed: x
type: (%,Integer)->Col
params: cTwoDimensionalArrayCategory(R,Row,Col)
comment:
\spad{column(m,{} j)} returns the \spad{j}th column of \spad{m} error check to determine if index is in proper ranges


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


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


kind: o
name: columnSpace
exposed: x
type: (%)->List(Col)
params: cMatrixCategory(R,Row,Col)
abbrev: has(R,EuclideanDomain)
comment:
\spad{columnSpace(m)} returns a sublist of columns of the matrix \spad{m} forming a basis of its column space


kind: o
name: columnSpace
exposed: x
type: (%)->List(Col)
params: cRectangularMatrixCategory(m,n,R,Row,Col)
abbrev: has(R,EuclideanDomain)
comment:
\spad{columnSpace(m)} returns a sublist of columns of the matrix \spad{m} forming a basis of its column space.


kind: o
name: columnSpan
exposed: n
type: (%)->Stream(Matrix(XDistributedPolynomial(VAR,F)))
params: dFreeDivisionAlgebra(VAR,F)
comment:
\spad{columnSpan(f)} computes the column span for a regular element,{} that is (\spad{v'},{} \spad{Mv'},{} M^2v',{} ...) where PAs=Pv=v' with PA = \spad{I}-\spad{M}.


kind: o
name: commonDenominator
exposed: n
type: (B)->R
params: pInnerCommonDenominator(R,Q,A,B)
comment:
\spad{commonDenominator([q1,{} ...,{} qn])} returns a common denominator \spad{d} for \spad{q1},{} ...,{} \spad{qn}.


kind: o
name: compactFraction
exposed: x
type: (%)->%
params: dPartialFraction(R)
comment:
\spad{compactFraction(p)} normalizes the partial fraction \spad{p} to the compact representation. In this form,{} the partial fraction has only one fractional term per prime in the denominator.


kind: o
name: companionBlocks
exposed: n
type: (Matrix(K),List(Vector(K)))->List(Record(C:Matrix(K),lg:List(Vector(K))))
params: pPseudoLinearNormalForm(K)
comment:
\spad{companionBlocks(m,{} lv)} returns \spad{[[C_1,{} lg_1],{} ...,{} [C_k,{} lg_k]]} such that each \spad{C_i} is a companion block and \spad{m = diagonal(C_1,{} ...,{} C_k)}.


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


kind: o
name: compBound
exposed: n
type: (BP,List(BP))->NonNegativeInteger
params: pGenExEuclid(R,BP)
comment:
\spad{compBound(p,{} lp)} computes a bound for the coefficients of the solution polynomials. Given a polynomial right hand side \spad{p},{} and a list \spad{lp} of left hand side polynomials. Exported because it depends on the valuation.


kind: o
name: compile
exposed: n
type: (Symbol,List(%))->Symbol
params: dInputForm
comment:
\spad{compile(f,{} [t1,{} ...,{} tn])} forces the interpreter to compile the function \spad{f} with signature \spad{(t1,{} ...,{} tn) -> ?}. returns the symbol \spad{f} if successful. Error: if \spad{f} was not defined beforehand in the interpreter,{} or if the \spad{ti}\spad{'s} are not valid types,{} or if the compiler fails.


kind: o
name: compiledFunction
exposed: n
type: (S,Symbol)->(D)->I
params: pMakeUnaryCompiledFunction(S,D,I)
comment:
\spad{compiledFunction(expr,{} x)} returns a function \spad{f: D -> I} defined by \spad{f(x) == expr}. Function \spad{f} is compiled and directly applicable to objects of type \spad{D}.


kind: o
name: compiledFunction
exposed: n
type: (S,Symbol,Symbol)->(D1,D2)->I
params: pMakeBinaryCompiledFunction(S,D1,D2,I)
comment:
\spad{compiledFunction(expr,{} x,{} y)} returns a function \spad{f: (D1,{} D2) -> I} defined by \spad{f(x,{} y) == expr}. Function \spad{f} is compiled and directly applicable to objects of type \spad{(D1,{} D2)}


kind: o
name: complement
exposed: x
type: (%)->%
params: cFiniteSetAggregate(S)
abbrev: has(S,Finite)
comment:
\spad{complement(u)} returns the complement of the set \spad{u},{} \spadignore{i.e.} the set of all values not in \spad{u}.


kind: o
name: complementaryBasis
exposed: x
type: (Vector(%))->Vector(%)
params: cFunctionFieldCategory(F,UP,UPUP)
comment:
\spad{complementaryBasis(b1,{} ...,{} bn)} returns the complementary basis \spad{(b1',{} ...,{} bn')} of \spad{(b1,{} ...,{} bn)}.


kind: o
name: complementSpace
exposed: n
type: (%)->%
params: dVectorSpaceBasis(R)
comment:
\spad{complementSpace B} builds a complement space of the basis \spad{B} from some vectors of the canonical basis. This function fails with the empty basis.


kind: o
name: complementSpace
exposed: n
type: (List(Vector(R)))->%
params: dVectorSpaceBasis(R)
comment:
\spad{complementSpace Lv} builds a complement space of the subspace spanned by the list of vectors \spad{LV}. This function fails with the empty basis.


kind: o
name: complementSpace
exposed: n
type: (List(Vector(R)),NonNegativeInteger)->%
params: dVectorSpaceBasis(R)
comment:
\spad{complementSpace(Lv,{} n)} builds a complement space of the subspace spanned by the list of vectors \spad{LV}. The integer \spad{n} provides the length of the vectors in the case of the empty basis.


kind: o
name: complementSpace
exposed: n
type: (%,NonNegativeInteger)->%
params: dVectorSpaceBasis(R)
comment:
\spad{complementSpace(B,{} n)} builds a complement space of the basis \spad{B} from some vectors of the canonical basis \spad{B}. The integer \spad{n} provides the length of the vectors in the case of the empty basis.


kind: o
name: complete
exposed: n
type: (JetDifferentialEquation(JB,D))->Void
params: pCartanKuranishi(JB,D)
comment:
\spad{complete(de)} completes \spad{de} to an involutive equation. No result is returned; the display depends of the setting of the output flags with \spadfun{setOutput}.


kind: o
name: complete
exposed: x
type: (%)->%
params: cLazyStreamAggregate(S)
comment:
\spad{complete(st)} causes all entries of 'st' to be computed. this function should only be called on streams which are known to be finite.


kind: o
name: complete
exposed: x
type: (%)->%
params: cPowerSeriesCategory(Coef,Expon,Var)
comment:
\spad{complete(f)} causes all terms of \spad{f} to be computed. Note: this results in an infinite loop if \spad{f} has infinitely many terms.


kind: o
name: complete
exposed: x
type: (%)->%
params: dContinuedFraction(R)
comment:
\spad{complete(x)} causes all entries in \spadvar{\spad{x}} to be computed. Normally entries are only computed as needed. If \spadvar{\spad{x}} is an infinite continued fraction,{} a user-initiated interrupt is necessary to stop the computation.


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


kind: o
name: complete2
exposed: n
params: pCartanKuranishi(JB,D)
type:
(JetDifferentialEquation(JB,D))->Record(IDe:JetDifferentialEquation(JB,D),ISys:List(D),Order:NonNegativeInteger,NumProj:NonNegativeInteger,Dim:NonNegativeInteger,CarChar:List(NonNegativeInteger))

comment:
\spad{complete2(de)} is like \spadfun{complete} but returns the involutive equation \spad{IDe},{} a basis \spad{ISys} for the involutive system without prolongations,{} its order \spad{Order},{} the number \spad{NumProj} of needed projections and the Cartan characters \spad{CarChar}.


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


kind: o
name: completeEchelonBasis
exposed: x
type: (Vector(Vector(R)))->Matrix(R)
params: pRepresentationPackage2(R)
comment:
\spad{completeEchelonBasis(lv)} completes the basis {\em lv} assumed to be in echelon form of a subspace of {\em R^n} (\spad{n} the length of all the vectors in {\em lv}) with unit vectors to a basis of {\em R^n}. It is assumed that the argument is not an empty vector and that it is not the basis of the 0-subspace. Note: the rows of the result correspond to the vectors of the basis.


kind: o
name: completeEval
exposed: n
type: (SparseUnivariatePolynomial(P),List(OV),List(R))->SparseUnivariatePolynomial(R)
params: pFactoringUtilities(E,OV,R,P)
comment:
\spad{completeEval(upoly,{} lvar,{} lval)} evaluates the polynomial \spad{upoly} with each variable in \spad{lvar} replaced by the corresponding value in lval. Substitutions are done for all variables in \spad{upoly} producing a univariate polynomial over \spad{R}.


kind: o
name: completeHensel
exposed: n
type: (TP,List(TP),RP,PositiveInteger)->List(TP)
params: pGeneralHenselPackage(RP,TP)
comment:
\spad{completeHensel(pol,{} lfact,{} prime,{} bound)} lifts \spad{lfact},{} the factorization mod \spad{prime} of \spad{pol},{} to the factorization mod prime^k>bound. Factors are recombined on the way.


kind: o
name: completeHermite
exposed: x
type: (M)->Record(Hermite:M,eqMat:M)
params: pSmithNormalForm(R,Row,Col,M)
comment:
\spad{completeHermite} returns a record that contains the Hermite normal form \spad{H} of the matrix and the equivalence matrix \spad{U} such that U*m = \spad{H}


kind: o
name: completeSmith
exposed: x
type: (M)->Record(Smith:M,leftEqMat:M,rightEqMat:M)
params: pSmithNormalForm(R,Row,Col,M)
comment:
\spad{completeSmith} returns a record that contains the Smith normal form \spad{H} of the matrix and the left and right equivalence matrices \spad{U} and \spad{V} such that U*m*v = \spad{H}


kind: o
name: completeSmith
exposed: n
params: pIntegerSmithNormalForm
type:
(Matrix(Integer),(Matrix(Integer))->Record(Smith:Matrix(Integer),leftEqMat:Matrix(Integer),rightEqMat:Matrix(Integer)))->Record(Smith:Matrix(Integer),leftEqMat:Matrix(Integer),rightEqMat:Matrix(Integer))

comment:
\spad{completeSmith(m,{} full)} computes record containing Smith normal form of \spad{m} and the left and right equivalence matrices. It first reduces \spad{m} to smaller matrix and then uses full to finish.


kind: o
name: complexEigenvalues
exposed: x
type: (Matrix(Complex(Fraction(Integer))),Par)->List(Complex(Par))
params: pNumericComplexEigenPackage(Par)
comment:
\spad{complexEigenvalues(m,{} eps)} computes the eigenvalues of the matrix \spad{m} to precision eps. The eigenvalues are expressed as complex floats or complex rational numbers depending on the type of eps (float or rational).


