diff --git a/books/bookvol10.2.pamphlet b/books/bookvol10.2.pamphlet index 4b02a16..083d50f 100644 --- a/books/bookvol10.2.pamphlet +++ b/books/bookvol10.2.pamphlet @@ -410,6 +410,7 @@ These are directly exported but not implemented: ++ Date Last Updated: 14 May 1991 ++ Description: ++ Category for the inverse hyperbolic trigonometric functions; + ArcHyperbolicFunctionCategory(): Category == with acosh: $ -> $ ++ acosh(x) returns the hyperbolic arc-cosine of x. acoth: $ -> $ ++ acoth(x) returns the hyperbolic arc-cotangent of x. @@ -485,7 +486,9 @@ These are implemented by this category: ++ Author: ??? ++ Date Created: ??? ++ Date Last Updated: 14 May 1991 -++ Description: Category for the inverse trigonometric functions; +++ Description: +++ Category for the inverse trigonometric functions; + ArcTrigonometricFunctionCategory(): Category == with acos: $ -> $ ++ acos(x) returns the arc-cosine of x. acot: $ -> $ ++ acot(x) returns the arc-cotangent of x. @@ -546,7 +549,7 @@ is true if it has an operation $"*": (D,D) -> D$ which is commutative. \item {\bf \cross{ATTREG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf \cross{ATTREG}{unitsKnown}} is true if a monoid (a multiplicative semigroup with a 1) has @@ -599,8 +602,9 @@ the real numbers''. <>= )abbrev category ATTREG AttributeRegistry - +++ Description: ++ This category exports the attributes in the AXIOM Library + AttributeRegistry(): Category == with finiteAggregate ++ \spad{finiteAggregate} is true if it is an aggregate with a @@ -611,7 +615,7 @@ AttributeRegistry(): Category == with shallowlyMutable ++ \spad{shallowlyMutable} is true if its values ++ have immediate components that are updateable (mutable). - ++ Note: the properties of any component domain are irrevelant to the + ++ Note that the properties of any component domain are irrevelant to the ++ \spad{shallowlyMutable} proper. unitsKnown ++ \spad{unitsKnown} is true if a monoid (a multiplicative semigroup @@ -735,6 +739,7 @@ These are implemented by this category: ++ Description: ++ \spadtype{BasicType} is the basic category for describing a collection ++ of elements with \spadop{=} (equality). + BasicType(): Category == with "=": (%,%) -> Boolean ++ x=y tests if x and y are equal. "~=": (%,%) -> Boolean ++ x~=y tests if x and y are not equal. @@ -797,6 +802,7 @@ This is directly exported but not implemented: ++ Description: ++ A is coercible to B means any element of A can automatically be ++ converted into an element of B by the interpreter. + CoercibleTo(S:Type): Category == with coerce: % -> S ++ coerce(a) transforms a into an element of S. @@ -866,22 +872,24 @@ These are directly exported but not implemented: ++ Author: Manuel Bronstein ++ Date Created: ??? ++ Date Last Updated: 14 May 1991 -++ Description: Category for the usual combinatorial functions; +++ Description: +++ Category for the usual combinatorial functions; + CombinatorialFunctionCategory(): Category == with binomial : ($, $) -> $ ++ 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}. + ++ Note that \spad{C(n,r) = n!/(r!(n-r)!)} where \spad{n >= r >= 0}. ++ ++X [binomial(5,i) for i in 0..5] factorial : $ -> $ ++ factorial(n) computes the factorial of n ++ (denoted in the literature by \spad{n!}) - ++ Note: \spad{n! = n (n-1)! when n > 0}; also, \spad{0! = 1}. + ++ Note that \spad{n! = n (n-1)! when n > 0}; also, \spad{0! = 1}. permutation: ($, $) -> $ ++ permutation(n, m) returns the number of ++ permutations of n objects taken m at a time. - ++ Note: \spad{permutation(n,m) = n!/(n-m)!}. + ++ Note that \spad{permutation(n,m) = n!/(n-m)!}. @ <>= @@ -941,6 +949,7 @@ This is directly exported but not implemented: ++ A is convertible to B means any element of A ++ can be converted into an element of B, ++ but not automatically by the interpreter. + ConvertibleTo(S:Type): Category == with convert: % -> S ++ convert(a) transforms a into an element of S. @@ -1064,7 +1073,9 @@ These are implemented by this category: ++ Author: Manuel Bronstein ++ Date Created: ??? ++ Date Last Updated: 14 May 1991 -++ Description: Category for the elementary functions; +++ Description: +++ Category for the elementary functions; + ElementaryFunctionCategory(): Category == with log : $ -> $ ++ log(x) returns the natural logarithm of x. exp : $ -> $ ++ exp(x) returns %e to the power x. @@ -1136,6 +1147,7 @@ This is directly exported but not implemented: ++ Examples of eltable structures range from data structures, e.g. those ++ of type \spadtype{List}, to algebraic structures like ++ \spadtype{Polynomial}. + Eltable(S:SetCategory, Index:Type): Category == with elt : (%, S) -> Index ++ elt(u,i) (also written: u . i) returns the element of u indexed by i. @@ -1218,7 +1230,9 @@ These are implemented by this category: ++ Author: ??? ++ Date Created: ??? ++ Date Last Updated: 14 May 1991 -++ Description: Category for the hyperbolic trigonometric functions; +++ Description: +++ Category for the hyperbolic trigonometric functions; + HyperbolicFunctionCategory(): Category == with cosh: $ -> $ ++ cosh(x) returns the hyperbolic cosine of x. coth: $ -> $ ++ coth(x) returns the hyperbolic cotangent of x. @@ -1310,12 +1324,13 @@ These are implemented by this category: ++ Examples: ++ References: ++ Description: -++ This category provides \spadfun{eval} operations. -++ A domain may belong to this category if it is possible to make -++ ``evaluation'' substitutions. The difference between this -++ and \spadtype{Evalable} is that the operations in this category -++ specify the substitution as a pair of arguments rather than as -++ an equation. +++ This category provides \spadfun{eval} operations. +++ A domain may belong to this category if it is possible to make +++ ``evaluation'' substitutions. The difference between this +++ and \spadtype{Evalable} is that the operations in this category +++ specify the substitution as a pair of arguments rather than as +++ an equation. + InnerEvalable(A:SetCategory, B:Type): Category == with eval: ($, A, B) -> $ ++ eval(f, x, v) replaces x by v in f. @@ -1672,11 +1687,12 @@ These exports come from \refto{ConvertibleTo}(Pattern(Float)): ++ Author: Manuel Bronstein ++ Date Created: 29 Nov 1989 ++ Date Last Updated: 29 Nov 1989 -++ Description: -++ An object S is Patternable over an object R if S can -++ lift the conversions from R into \spadtype{Pattern(Integer)} and -++ \spadtype{Pattern(Float)} to itself; ++ Keywords: pattern, matching. +++ Description: +++ An object S is Patternable over an object R if S can +++ lift the conversions from R into \spadtype{Pattern(Integer)} and +++ \spadtype{Pattern(Float)} to itself; + Patternable(R:Type): Category == with if R has ConvertibleTo Pattern Integer then ConvertibleTo Pattern Integer @@ -1746,7 +1762,9 @@ These are directly exported but not implemented: ++ Author: Manuel Bronstein ++ Date Created: ??? ++ Date Last Updated: 14 May 1991 -++ Description: Category for the functions defined by integrals; +++ Description: +++ Category for the functions defined by integrals; + PrimitiveFunctionCategory(): Category == with integral: ($, Symbol) -> $ ++ integral(f, x) returns the formal integral of f dx. @@ -1820,8 +1838,9 @@ These are implemented by this category: ++ Basic Operations: nthRoot, sqrt, ** ++ Related Constructors: ++ Keywords: rational numbers -++ Description: The \spad{RadicalCategory} is a model for the -++ rational numbers. +++ Description: +++ The \spad{RadicalCategory} is a model for the rational numbers. + RadicalCategory(): Category == with sqrt : % -> % ++ sqrt(x) returns the square root of x. @@ -1913,6 +1932,7 @@ These are implemented by this category: ++ A is retractable to B means that some elementsif A can be converted ++ into elements of B and any element of B can be converted into an ++ element of A. + RetractableTo(S: Type): Category == with coerce: S -> % ++ coerce(a) transforms a into an element of %. @@ -2050,7 +2070,9 @@ These are directly exported but not implemented: ++ Author: Manuel Bronstein ++ Date Created: ??? ++ Date Last Updated: 11 May 1993 -++ Description: Category for the other special functions; +++ Description: +++ Category for the other special functions; + SpecialFunctionCategory(): Category == with abs : $ -> $ ++ abs(x) returns the absolute value of x. @@ -2146,7 +2168,9 @@ These are implemented by this category: ++ Author: ??? ++ Date Created: ??? ++ Date Last Updated: 14 May 1991 -++ Description: Category for the trigonometric functions; +++ Description: +++ Category for the trigonometric functions; + TrigonometricFunctionCategory(): Category == with cos: $ -> $ ++ cos(x) returns the cosine of x. cot: $ -> $ ++ cot(x) returns the cotangent of x. @@ -2213,7 +2237,9 @@ digraph pic { ++ Author: Richard Jenks ++ Date Created: 14 May 1992 ++ Date Last Updated: 14 May 1992 -++ Description: The fundamental Type; +++ Description: +++ The fundamental Type; + Type(): Category == with nil @ @@ -2293,24 +2319,23 @@ These are implemented by this category: ++ References: ++ Description: ++ The notion of aggregate serves to model any data structure aggregate, -++ designating any collection of objects, -++ with heterogenous 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 x satisfying relation {\em r(x)}" +++ designating any collection of objects, with heterogenous 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 x satisfying relation r(x)" ++ An attribute \spadatt{finiteAggregate} is used to assert that a domain ++ has a finite number of elements. + Aggregate: Category == Type with eq?: (%,%) -> Boolean ++ eq?(u,v) tests if u and v are same objects. copy: % -> % ++ copy(u) returns a top-level (non-recursive) copy of u. - ++ Note: for collections, \axiom{copy(u) == [x for x in u]}. + ++ Note that for collections, \axiom{copy(u) == [x for x in u]}. empty: () -> % ++ empty()$D creates an aggregate of type D with 0 elements. - ++ Note: The {\em $D} can be dropped if understood by context, + ++ Note that The $D can be dropped if understood by context, ++ e.g. \axiom{u: D := empty()}. empty?: % -> Boolean ++ empty?(u) tests if u has 0 elements. @@ -2403,8 +2428,9 @@ These exports come from \refto{CombinatorialFunctionCategory}(): ++ Date Created: ??? ++ Date Last Updated: 22 February 1993 (JHD/BMT) ++ Description: -++ CombinatorialOpsCategory is the category obtaining by adjoining -++ summations and products to the usual combinatorial operations; +++ CombinatorialOpsCategory is the category obtaining by adjoining +++ summations and products to the usual combinatorial operations; + CombinatorialOpsCategory(): Category == CombinatorialFunctionCategory with factorials : $ -> $ @@ -2476,7 +2502,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{ELTAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \end{itemize} @@ -2513,7 +2539,8 @@ These exports come from \refto{Eltable}(): ++ For example, the list \axiom{[1,7,4]} can applied to 0,1, and 2 ++ respectively will return the integers 1,7, and 4; thus this list may ++ be viewed as mapping 0 to 1, 1 to 7 and 2 to 4. In general, an aggregate -++ can map members of a domain {\em Dom} to an image domain {\em Im}. +++ can map members of a domain Dom to an image domain Im. + EltableAggregate(Dom:SetCategory, Im:Type): Category == -- This is separated from Eltable -- and series won't have to support qelt's and setelt's. @@ -2532,12 +2559,12 @@ EltableAggregate(Dom:SetCategory, Im:Type): Category == ++ is required, use the function \axiom{elt}. if % has shallowlyMutable then setelt : (%, Dom, Im) -> Im - ++ setelt(u,x,y) sets the image of x to be y under u, - ++ assuming x is in the domain of u. - ++ Error: if x is not in the domain of u. - -- this function will soon be renamed as setelt!. + ++ setelt(u,x,y) sets the image of x to be y under u, + ++ assuming x is in the domain of u. + ++ Error: if x is not in the domain of u. + -- this function will soon be renamed as setelt!. qsetelt_!: (%, Dom, Im) -> Im - ++ qsetelt!(u,x,y) sets the image of \axiom{x} to be \axiom{y} + ++ qsetelt!(u,x,y) sets the image of \axiom{x} to be \axiom{y} ++ under \axiom{u}, without checking that \axiom{x} is in ++ the domain of \axiom{u}. ++ If such a check is required use the function \axiom{setelt}. @@ -2619,9 +2646,10 @@ These exports come from \refto{InnerEvalable}(R:SetCategory,R:SetCategory): ++ Examples: ++ References: ++ Description: -++ This category provides \spadfun{eval} operations. -++ A domain may belong to this category if it is possible to make -++ ``evaluation'' substitutions. +++ This category provides \spadfun{eval} operations. +++ A domain may belong to this category if it is possible to make +++ ``evaluation'' substitutions. + Evalable(R:SetCategory): Category == InnerEvalable(R,R) with eval: ($, Equation R) -> $ ++ eval(f,x = v) replaces x by v in f. @@ -2725,8 +2753,8 @@ These exports come from \refto{CoercibleTo}(OutputForm): ++ References: ++ Description: ++ \axiomType{FortranProgramCategory} provides various models of -++ FORTRAN subprograms. These can be transformed into actual FORTRAN -++ code. +++ FORTRAN subprograms. These can be transformed into actual FORTRAN code. + FortranProgramCategory():Category == Join(Type,CoercibleTo OutputForm) with outputAsFortran : $ -> Void ++ \axiom{outputAsFortran(u)} translates \axiom{u} into a legal FORTRAN @@ -2820,14 +2848,14 @@ These exports come from \refto{RetractableTo}(S:Type): <>= )abbrev category FRETRCT FullyRetractableTo ++ Author: Manuel Bronstein -++ Description: -++ A is fully retractable to B means that A is retractable to B, and, -++ in addition, if B is retractable to the integers or rational -++ numbers then so is A. -++ In particular, what we are asserting is that there are no integers -++ (rationals) in A which don't retract into B. ++ Date Created: March 1990 ++ Date Last Updated: 9 April 1991 +++ Description: +++ A is fully retractable to B means that A is retractable to B and +++ if B is retractable to the integers or rational numbers then so is A. +++ In particular, what we are asserting is that there are no integers +++ (rationals) in A which don't retract into B. + FullyRetractableTo(S: Type): Category == RetractableTo(S) with if (S has RetractableTo Integer) then RetractableTo Integer if (S has RetractableTo Fraction Integer) then @@ -2960,11 +2988,12 @@ These exports come from \refto{Type}(): ++ Author: Manuel Bronstein ++ Date Created: 28 Nov 1989 ++ Date Last Updated: 29 Nov 1989 -++ Description: -++ A set S is PatternMatchable over R if S can lift the -++ pattern-matching functions of S over the integers and float -++ to itself (necessary for matching in towers). ++ Keywords: pattern, matching. +++ Description: +++ A set S is PatternMatchable over R if S can lift the +++ pattern-matching functions of S over the integers and float +++ to itself (necessary for matching in towers). + FullyPatternMatchable(R:Type): Category == Type with if R has PatternMatchable Integer then PatternMatchable Integer if R has PatternMatchable Float then PatternMatchable Float @@ -3056,15 +3085,15 @@ These exports come from \refto{BasicType}(): ++ Related Constructors: ++ Keywords: boolean ++ Description: -++ `Logic' provides the basic operations for lattices, -++ e.g., boolean algebra. +++ `Logic' provides the basic operations for lattices, e.g., boolean algebra. + Logic: Category == BasicType with _~: % -> % - ++ ~(x) returns the logical complement of x. + ++ ~(x) returns the logical complement of x. _/_\: (%, %) -> % - ++ \spadignore { /\ }returns the logical `meet', e.g. `and'. + ++ \spadignore { /\ }returns the logical `meet', e.g. `and'. _\_/: (%, %) -> % - ++ \spadignore{ \/ } returns the logical `join', e.g. `or'. + ++ \spadignore{ \/ } returns the logical `join', e.g. `or'. add _\_/(x: %,y: %) == _~( _/_\(_~(x), _~(y))) @@ -3135,7 +3164,8 @@ These exports come from \refto{CoercibleTo}(OutputForm): ++ AMS Classifications: ++ Keywords: plot, graphics ++ References: -++ Description: PlottablePlaneCurveCategory is the category of curves in the +++ Description: +++ 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 @@ -3231,7 +3261,8 @@ These exports come from \refto{CoercibleTo}(OutputForm): ++ AMS Classifications: ++ Keywords: plot, graphics ++ References: -++ Description: PlottableSpaceCurveCategory is the category of curves in +++ Description: +++ 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 @@ -3328,6 +3359,7 @@ These exports come from \refto{ConvertibleTo}(Float): ++ References: ++ Description: ++ The category of real numeric domains, i.e. convertible to floats. + RealConstant(): Category == Join(ConvertibleTo DoubleFloat, ConvertibleTo Float) @@ -3420,8 +3452,8 @@ These are directly exported but not implemented: ++ Examples: ++ References: ++ Description: -++ This category provides operations on ranges, or {\em segments} -++ as they are called. +++ This category provides operations on ranges, or segments +++ as they are called. SegmentCategory(S:Type): Category == Type with SEGMENT: (S, S) -> % @@ -3431,20 +3463,20 @@ SegmentCategory(S:Type): Category == Type with ++ \spad{n}-th element is used. lo: % -> S ++ lo(s) returns the first endpoint of s. - ++ Note: \spad{lo(l..h) = l}. + ++ Note that \spad{lo(l..h) = l}. hi: % -> S ++ hi(s) returns the second endpoint of s. - ++ Note: \spad{hi(l..h) = h}. + ++ Note that \spad{hi(l..h) = h}. low: % -> S ++ low(s) returns the first endpoint of s. - ++ Note: \spad{low(l..h) = l}. + ++ Note that \spad{low(l..h) = l}. high: % -> S ++ high(s) returns the second endpoint of s. - ++ Note: \spad{high(l..h) = h}. + ++ Note that \spad{high(l..h) = h}. incr: % -> Integer ++ incr(s) returns \spad{n}, where s is a segment in which every ++ \spad{n}-th element is used. - ++ Note: \spad{incr(l..h by n) = n}. + ++ Note that \spad{incr(l..h by n) = n}. segment: (S, S) -> % ++ segment(i,j) is an alternate way to create the segment ++ \spad{i..j}. @@ -3543,8 +3575,7 @@ These exports come from \refto{CoercibleTo}(OutputForm): )abbrev category SETCAT SetCategory ++ Author: ++ Date Created: -++ Date Last Updated: -++ November 10, 2009 tpd happy birthday +++ Date Last Updated: November 10, 2009 tpd happy birthday ++ Basic Functions: ++ Related Constructors: ++ Also See: @@ -3556,8 +3587,9 @@ These exports come from \refto{CoercibleTo}(OutputForm): ++ of elements with \spadop{=} (equality) and \spadfun{coerce} to ++ output form. ++ -++ Conditional Attributes: -++ canonical\tab{15}data structure equality is the same as \spadop{=} +++ Conditional Attributes\br +++ \tab{5}canonical\tab{5}data structure equality is the same as \spadop{=} + SetCategory(): Category == Join(BasicType,CoercibleTo OutputForm) with hash: % -> SingleInteger ++ hash(s) calculates a hash code for s. @@ -3717,7 +3749,9 @@ These exports come from \refto{ElementaryFunctionCategory}(): ++ Author: Manuel Bronstein ++ Date Created: ??? ++ Date Last Updated: 14 May 1991 -++ Description: Category for the transcendental elementary functions; +++ Description: +++ Category for the transcendental elementary functions; + TranscendentalFunctionCategory(): Category == Join(TrigonometricFunctionCategory,ArcTrigonometricFunctionCategory, HyperbolicFunctionCategory,ArcHyperbolicFunctionCategory, @@ -3858,12 +3892,13 @@ These exports come from \refto{SetCategory}(): ++ Keywords: ++ References: ++ Description: -++ the class of all additive (commutative) semigroups, i.e. +++ The class of all additive (commutative) semigroups, i.e. ++ a set with a commutative and associative operation \spadop{+}. ++ -++ Axioms: -++ \spad{associative("+":(%,%)->%)}\tab{30}\spad{ (x+y)+z = x+(y+z) } -++ \spad{commutative("+":(%,%)->%)}\tab{30}\spad{ x+y = y+x } +++ Axioms\br +++ \tab{5}\spad{associative("+":(%,%)->%)}\tab{5}\spad{ (x+y)+z = x+(y+z) }\br +++ \tab{6}\spad{commutative("+":(%,%)->%)}\tab{5}\spad{ x+y = y+x } + AbelianSemiGroup(): Category == SetCategory with "+": (%,%) -> % ++ x+y computes the sum of x and y. "*": (PositiveInteger,%) -> % @@ -3978,6 +4013,7 @@ These exports come from \refto{FortranProgramCategory}(): ++ Description: ++ \axiomType{FortranFunctionCategory} is the category of arguments to ++ NAG Library routines which return (sets of) function values. + FortranFunctionCategory():Category == FortranProgramCategory with coerce : List FortranCode -> $ ++ coerce(e) takes an object from \spadtype{List FortranCode} and @@ -4111,6 +4147,7 @@ These exports come from \refto{FortranProgramCategory}(): ++ producing Functions and Subroutines when the input to these ++ is an AXIOM object of type \axiomType{Matrix} or in domains ++ involving \axiomType{FortranCode}. + FortranMatrixCategory():Category == FortranProgramCategory with coerce : Matrix MachineFloat -> $ ++ coerce(v) produces an ASP which returns the value of \spad{v}. @@ -4351,6 +4388,7 @@ These exports come from \refto{FortranProgramCategory}(): ++ producing Functions and Subroutines when the input to these ++ is an AXIOM object of type \axiomType{Vector} or in domains ++ involving \axiomType{FortranCode}. + FortranVectorCategory():Category == FortranProgramCategory with coerce : Vector MachineFloat -> $ ++ coerce(v) produces an ASP which returns the value of \spad{v}. @@ -4458,6 +4496,7 @@ These exports come from \refto{FortranProgramCategory}(): ++ Description: ++ \axiomType{FortranVectorFunctionCategory} is the catagory of arguments ++ to NAG Library routines which return the values of vectors of functions. + FortranVectorFunctionCategory():Category == FortranProgramCategory with coerce : List FortranCode -> $ ++ coerce(e) takes an object from \spadtype{List FortranCode} and @@ -4603,8 +4642,9 @@ These exports come from \refto{InnerEvalable}(a:Symbol,b:SetCategory): ++ Examples: ++ References: ++ Description: -++ This category provides a selection of evaluation operations -++ depending on what the argument type R provides. +++ This category provides a selection of evaluation operations +++ depending on what the argument type R provides. + FullyEvalableOver(R:SetCategory): Category == with map: (R -> R, $) -> $ ++ map(f, ex) evaluates ex, applying f to values of type R in ex. @@ -4740,10 +4780,10 @@ These exports come from SetCategory(): ++ Examples: ++ References: ++ Description: -++ This category provides an interface to operate on files in the -++ computer'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 S. +++ This category provides an interface to operate on files in the +++ computer'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 S. FileCategory(Name, S): Category == FCdefinition where Name: SetCategory @@ -4880,9 +4920,9 @@ These exports come from \refto{SetCategory}(): ++ to give a bijection between the finite set and an initial ++ segment of positive integers. ++ -++ Axioms: -++ \spad{lookup(index(n)) = n} -++ \spad{index(lookup(s)) = s} +++ Axioms:\br +++ \tab{5}\spad{lookup(index(n)) = n}\br +++ \tab{5}\spad{index(lookup(s)) = s} Finite(): Category == SetCategory with size: () -> NonNegativeInteger @@ -4999,7 +5039,8 @@ These exports come from \refto{SetCategory}(): ++ Examples: ++ References: ++ Description: -++ This category provides an interface to names in the file system. +++ This category provides an interface to names in the file system. + FileNameCategory(): Category == SetCategory with coerce: String -> % ++ coerce(s) converts a string to a file name @@ -5135,15 +5176,15 @@ These exports come from \refto{SetCategory}(): ++ Examples: ++ References: Algebra 2d Edition, MacLane and Birkhoff, MacMillan 1979 ++ Description: -++ GradedModule(R,E) denotes ``E-graded R-module'', i.e. collection of -++ R-modules indexed by an abelian monoid E. -++ An element \spad{g} of \spad{G[s]} for some specific \spad{s} in \spad{E} -++ is said to be an element of \spad{G} with {\em degree} \spad{s}. -++ Sums are defined in each module \spad{G[s]} so two elements of \spad{G} -++ have a sum if they have the same degree. +++ GradedModule(R,E) denotes ``E-graded R-module'', i.e. collection of +++ R-modules indexed by an abelian monoid E. +++ An element \spad{g} of \spad{G[s]} for some specific \spad{s} in \spad{E} +++ is said to be an element of \spad{G} with degree \spad{s}. +++ Sums are defined in each module \spad{G[s]} so two elements of \spad{G} +++ have a sum if they have the same degree. ++ -++ Morphisms can be defined and composed by degree to give the -++ mathematical category of graded modules. +++ Morphisms can be defined and composed by degree to give the +++ mathematical category of graded modules. GradedModule(R: CommutativeRing, E: AbelianMonoid): Category == SetCategory with @@ -5264,7 +5305,7 @@ digraph pic { is true if it is an aggregate with a finite number of elements. \item {\bf \cross{HOAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \end{itemize} @@ -5343,61 +5384,62 @@ These exports come from \refto{SetCategory}(): ++ have a finite number of members. ++ Those with attribute \spadatt{shallowlyMutable} allow an element ++ to be modified or updated without changing its overall value. + HomogeneousAggregate(S:Type): Category == Aggregate with if S has SetCategory then SetCategory if S has SetCategory then if S has Evalable S then Evalable S - map : (S->S,%) -> % + map : (S->S,%) -> % ++ map(f,u) returns a copy of u with each element x replaced by f(x). ++ For collections, \axiom{map(f,u) = [f(x) for x in u]}. if % has shallowlyMutable then map_!: (S->S,%) -> % - ++ map!(f,u) destructively replaces each element x of u + ++ map!(f,u) destructively replaces each element x of u ++ by \axiom{f(x)}. if % has finiteAggregate then any?: (S->Boolean,%) -> Boolean - ++ any?(p,u) tests if \axiom{p(x)} is true for any element x of u. - ++ Note: for collections, - ++ \axiom{any?(p,u) = reduce(or,map(f,u),false,true)}. + ++ any?(p,u) tests if \axiom{p(x)} is true for any element x of u. + ++ Note that for collections, + ++ \axiom{any?(p,u) = reduce(or,map(f,u),false,true)}. every?: (S->Boolean,%) -> Boolean - ++ every?(f,u) tests if p(x) is true for all elements x of u. - ++ Note: for collections, - ++ \axiom{every?(p,u) = reduce(and,map(f,u),true,false)}. + ++ every?(f,u) tests if p(x) is true for all elements x of u. + ++ Note that for collections, + ++ \axiom{every?(p,u) = reduce(and,map(f,u),true,false)}. count: (S->Boolean,%) -> NonNegativeInteger - ++ count(p,u) returns the number of elements x in u - ++ such that \axiom{p(x)} is true. For collections, - ++ \axiom{count(p,u) = reduce(+,[1 for x in u | p(x)],0)}. + ++ count(p,u) returns the number of elements x in u + ++ such that \axiom{p(x)} is true. For collections, + ++ \axiom{count(p,u) = reduce(+,[1 for x in u | p(x)],0)}. parts: % -> List S - ++ parts(u) returns a list of the consecutive elements of u. - ++ For collections, \axiom{parts([x,y,...,z]) = (x,y,...,z)}. + ++ parts(u) returns a list of the consecutive elements of u. + ++ For collections, \axiom{parts([x,y,...,z]) = (x,y,...,z)}. members: % -> List S - ++ members(u) returns a list of the consecutive elements of u. - ++ For collections, \axiom{parts([x,y,...,z]) = (x,y,...,z)}. + ++ members(u) returns a list of the consecutive elements of u. + ++ For collections, \axiom{parts([x,y,...,z]) = (x,y,...,z)}. if S has SetCategory then - count: (S,%) -> NonNegativeInteger - ++ count(x,u) returns the number of occurrences of x in u. For - ++ collections, \axiom{count(x,u) = reduce(+,[x=y for y in u],0)}. - member?: (S,%) -> Boolean - ++ member?(x,u) tests if x is a member of u. - ++ For collections, - ++ \axiom{member?(x,u) = reduce(or,[x=y for y in u],false)}. + count: (S,%) -> NonNegativeInteger + ++ count(x,u) returns the number of occurrences of x in u. For + ++ collections, \axiom{count(x,u) = reduce(+,[x=y for y in u],0)}. + member?: (S,%) -> Boolean + ++ member?(x,u) tests if x is a member of u. + ++ For collections, + ++ \axiom{member?(x,u) = reduce(or,[x=y for y in u],false)}. add if S has Evalable S then eval(u:%,l:List Equation S):% == map(x +-> eval(x,l),u) if % has finiteAggregate then - #c == # parts c - any?(f, c) == _or/[f x for x in parts c] - every?(f, c) == _and/[f x for x in parts c] + #c == # parts c + any?(f, c) == _or/[f x for x in parts c] + every?(f, c) == _and/[f x for x in parts c] count(f:S -> Boolean, c:%) == _+/[1 for x in parts c | f x] - members x == parts x + members x == parts x if S has SetCategory then count(s:S, x:%) == count(y +-> s = y, x) member?(e, c) == any?(x +-> e = x,c) x = y == - size?(x, #y) and _and/[a = b for a in parts x for b in parts y] + size?(x, #y) and _and/[a = b for a in parts x for b in parts y] coerce(x:%):OutputForm == - bracket - commaSeparate [a::OutputForm for a in parts x]$List(OutputForm) + bracket + commaSeparate [a::OutputForm for a in parts x]$List(OutputForm) @ <>= @@ -5672,7 +5714,9 @@ These exports come from \refto{TranscendentalFunctionCategory}(): ++ Author: Manuel Bronstein ++ Date Created: ??? ++ Date Last Updated: 14 May 1991 -++ Description: Category for the transcendental Liouvillian functions; +++ Description: +++ Category for the transcendental Liouvillian functions; + LiouvillianFunctionCategory(): Category == Join(PrimitiveFunctionCategory, TranscendentalFunctionCategory) with Ei : $ -> $ @@ -5809,8 +5853,9 @@ These exports come from \refto{SetCategory}(): ++ N. Jacobson: Structure and Representations of Jordan Algebras ++ AMS, Providence, 1968 ++ Description: -++ Monad is the class of all multiplicative monads, i.e. sets -++ with a binary operation. +++ Monad is the class of all multiplicative monads, i.e. sets +++ with a binary operation. + Monad(): Category == SetCategory with "*": (%,%) -> % ++ a*b is the product of \spad{a} and b in a set with @@ -5962,12 +6007,15 @@ These exports come from \refto{SetCategory}(): ++ describing the set of Numerical Integration \axiom{domains} with ++ \axiomFun{measure} and \axiomFun{numericalIntegration}. -EDFE ==> Expression DoubleFloat -SOCDFE ==> Segment OrderedCompletion DoubleFloat -DFE ==> DoubleFloat -NIAE ==> Record(var:Symbol,fn:EDFE,range:SOCDFE,abserr:DFE,relerr:DFE) -MDNIAE ==> Record(fn:EDFE,range:List SOCDFE,abserr:DFE,relerr:DFE) -NumericalIntegrationCategory(): Category == SetCategory with +NumericalIntegrationCategory(): Category == Exports where + + EDFE ==> Expression DoubleFloat + SOCDFE ==> Segment OrderedCompletion DoubleFloat + DFE ==> DoubleFloat + NIAE ==> Record(var:Symbol,fn:EDFE,range:SOCDFE,abserr:DFE,relerr:DFE) + MDNIAE ==> Record(fn:EDFE,range:List SOCDFE,abserr:DFE,relerr:DFE) + + Exports ==> SetCategory with measure:(RoutinesTable,NIAE) -> _ Record(measure:Float,explanations:String,extra:Result) @@ -6110,13 +6158,17 @@ These exports come from \refto{SetCategory}(): ++ describing the set of Numerical Optimization \axiom{domains} with ++ \axiomFun{measure} and \axiomFun{optimize}. -LDFH ==> List DoubleFloat -LEDFH ==> List Expression DoubleFloat -LSAH ==> Record(lfn:LEDFH, init:LDFH) -EDFH ==> Expression DoubleFloat -LOCDFH ==> List OrderedCompletion DoubleFloat -NOAH ==> Record(fn:EDFH, init:LDFH, lb:LOCDFH, cf:LEDFH, ub:LOCDFH) -NumericalOptimizationCategory(): Category == SetCategory with +NumericalOptimizationCategory(): Category == Exports where + + LDFH ==> List DoubleFloat + LEDFH ==> List Expression DoubleFloat + LSAH ==> Record(lfn:LEDFH, init:LDFH) + EDFH ==> Expression DoubleFloat + LOCDFH ==> List OrderedCompletion DoubleFloat + NOAH ==> Record(fn:EDFH, init:LDFH, lb:LOCDFH, cf:LEDFH, ub:LOCDFH) + + Exports ==> SetCategory with + measure:(RoutinesTable,NOAH)->Record(measure:Float,explanations:String) ++ measure(R,args) calculates an estimate of the ability of a particular ++ method to solve an optimization problem. @@ -6254,12 +6306,15 @@ These exports come from \refto{SetCategory}(): ++ \axiom{category} for describing the set of ODE solver \axiom{domains} ++ with \axiomFun{measure} and \axiomFun{ODEsolve}. -DFF ==> DoubleFloat -VEDFF ==> Vector Expression DoubleFloat -LDFF ==> List DoubleFloat -EDFF ==> Expression DoubleFloat -ODEAF ==> Record(xinit:DFF,xend:DFF,fn:VEDFF,yinit:LDFF,intvals:LDFF,g:EDFF,abserr:DFF,relerr:DFF) -OrdinaryDifferentialEquationsSolverCategory(): Category == SetCategory with +OrdinaryDifferentialEquationsSolverCategory(): Category == Exports where + + DFF ==> DoubleFloat + VEDFF ==> Vector Expression DoubleFloat + LDFF ==> List DoubleFloat + EDFF ==> Expression DoubleFloat + ODEAF ==> Record(xinit:DFF,xend:DFF,fn:VEDFF,yinit:LDFF,intvals:LDFF,g:EDFF,abserr:DFF,relerr:DFF) + + Exports ==> SetCategory with measure:(RoutinesTable,ODEAF) -> Record(measure:Float,explanations:String) ++ measure(R,args) calculates an estimate of the ability of a particular @@ -6391,6 +6446,7 @@ These exports come from \refto{SetCategory}(): ++ pair of elements \spad{(a,b)} ++ exactly one of the following relations holds \spad{a a Boolean ++ x < y is a strict total ordering on the elements of the set. @@ -6525,7 +6581,7 @@ These exports come from \refto{Dictionary}(S:SetCategory): ++ \axiom{category} for describing the set of PDE solver \axiom{domains} ++ with \axiomFun{measure} and \axiomFun{PDEsolve}. --- PDEA ==> Record(xmin:F,xmax:F,ymin:F,ymax:F,ngx:NNI,ngy:NNI,_ +-- PDEA ==> Record(xmin:F,xmax:F,ymin:F,ymax:F,ngx:NNI,ngy:NNI,_ -- pde:List Expression Float, bounds:List List Expression Float,_ -- st:String, tol:DF) @@ -6546,17 +6602,19 @@ These exports come from \refto{Dictionary}(S:SetCategory): -- ++ PDESolve(args) performs the integration of the -- ++ function given the strategy or method returned by \axiomFun{measure}. -DFG ==> DoubleFloat -NNIG ==> NonNegativeInteger -INTG ==> Integer -MDFG ==> Matrix DoubleFloat -PDECG ==> Record(start:DFG, finish:DFG, grid:NNIG, boundaryType:INTG, +PartialDifferentialEquationsSolverCategory(): Category == Exports where + + DFG ==> DoubleFloat + NNIG ==> NonNegativeInteger + INTG ==> Integer + MDFG ==> Matrix DoubleFloat + PDECG ==> Record(start:DFG, finish:DFG, grid:NNIG, boundaryType:INTG, dStart:MDFG, dFinish:MDFG) -LEDFG ==> List Expression DoubleFloat -PDEBG ==> Record(pde:LEDFG, constraints:List PDECG, f:List LEDFG, + LEDFG ==> List Expression DoubleFloat + PDEBG ==> Record(pde:LEDFG, constraints:List PDECG, f:List LEDFG, st:String, tol:DFG) -PartialDifferentialEquationsSolverCategory(): Category == SetCategory with - + Exports ==> SetCategory with + measure:(RoutinesTable,PDEBG) -> Record(measure:Float,explanations:String) ++ measure(R,args) calculates an estimate of the ability of a particular ++ method to solve a problem. @@ -6654,10 +6712,11 @@ These exports come from \refto{SetCategory}(): ++ Author: Manuel Bronstein ++ Date Created: 28 Nov 1989 ++ Date Last Updated: 15 Mar 1990 -++ Description: -++ A set R is PatternMatchable over S if elements of R can -++ be matched to patterns over S. ++ Keywords: pattern, matching. +++ Description: +++ A set R is PatternMatchable over S if elements of R can +++ be matched to patterns over S. + PatternMatchable(S:SetCategory): Category == SetCategory with patternMatch: (%, Pattern S, PatternMatchResult(S, %)) -> PatternMatchResult(S, %) @@ -6784,6 +6843,7 @@ These exports come from \refto{SetCategory}(): ++ Description: ++ \axiomType{RealRootCharacterizationCategory} provides common acces ++ functions for all real root codings. + RealRootCharacterizationCategory(TheField, ThePols ) : Category == PUB where TheField : Join(OrderedRing, Field) @@ -6960,8 +7020,9 @@ These exports come from \refto{SegmentCategory}(OrderedRing): ++ Examples: ++ References: ++ Description: -++ This category provides an interface for expanding segments to -++ a stream of elements. +++ This category provides an interface for expanding segments to +++ a stream of elements. + SegmentExpansionCategory(S: OrderedRing, L: StreamAggregate(S)): Category == SegmentCategory(S) with expand: List % -> L @@ -7082,11 +7143,12 @@ These exports come from \refto{SetCategory}(): ++ the class of all multiplicative semigroups, i.e. a set ++ with an associative operation \spadop{*}. ++ -++ Axioms: -++ \spad{associative("*":(%,%)->%)}\tab{30}\spad{ (x*y)*z = x*(y*z)} +++ Axioms\br +++ \tab{5}\spad{associative("*":(%,%)->%)}\tab{5}\spad{ (x*y)*z = x*(y*z)} ++ -++ Conditional attributes: -++ \spad{commutative("*":(%,%)->%)}\tab{30}\spad{ x*y = y*x } +++ Conditional attributes\br +++ \tab{5}\spad{commutative("*":(%,%)->%)}\tab{5}\spad{ x*y = y*x } + SemiGroup(): Category == SetCategory with "*": (%,%) -> % ++ x*y returns the product of x and y. "**": (%,PositiveInteger) -> % ++ x**n returns the repeated product @@ -7230,13 +7292,14 @@ These exports come from \refto{SetCategory}(): ++ Date Created: July 1987 ++ Date Last Modified: 23 May 1991 ++ Description: -++ This category allows the manipulation of Lisp values while keeping -++ the grunge fairly localized. +++ This category allows the manipulation of Lisp values while keeping +++ the grunge fairly localized. -- The coerce to expression lets the -- values be displayed in the usual parenthesized way (displaying -- them as type Expression can cause the formatter to die, since -- certain magic cookies are in unexpected places). -- SMW July 87 + SExpressionCategory(Str, Sym, Int, Flt, Expr): Category == Decl where Str, Sym, Int, Flt, Expr: SetCategory @@ -7400,8 +7463,9 @@ These exports come from \refto{SetCategory}(): ++ of \spadfun{nextItem} is not required to reach all possible domain elements ++ starting from any initial element. ++ -++ Conditional attributes: -++ infinite\tab{15}repeated \spad{nextItem}'s are never "failed". +++ Conditional attributes\br +++ \tab{5}infinite\tab{5}repeated nextItem's are never "failed". + StepThrough(): Category == SetCategory with init: constant -> % ++ init() chooses an initial object for stepping. @@ -7577,7 +7641,8 @@ These exports come from \refto{SetCategory}(): ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: The category ThreeSpaceCategory is used for creating +++ Description: +++ The category ThreeSpaceCategory is used for creating ++ three dimensional objects using functions for defining points, curves, ++ polygons, constructs and the subspaces containing them. @@ -7960,18 +8025,19 @@ These exports come from \refto{AbelianSemiGroup}(): ++ The class of multiplicative monoids, i.e. semigroups with an ++ additive identity element. ++ -++ Axioms: -++ \spad{leftIdentity("+":(%,%)->%,0)}\tab{30}\spad{ 0+x=x } -++ \spad{rightIdentity("+":(%,%)->%,0)}\tab{30}\spad{ x+0=x } +++ Axioms\br +++ \tab{5}\spad{leftIdentity("+":(%,%)->%,0)}\tab{5}\spad{ 0+x=x }\br +++ \tab{5}\spad{rightIdentity("+":(%,%)->%,0)}\tab{4}\spad{ x+0=x } -- following domain must be compiled with subsumption disabled -- define SourceLevelSubset to be EQUAL + AbelianMonoid(): Category == AbelianSemiGroup with 0: constant -> % - ++ 0 is the additive identity element. + ++ 0 is the additive identity element. sample: constant -> % - ++ sample yields a value of type % + ++ sample yields a value of type % zero?: % -> Boolean - ++ zero?(x) tests if x is equal to 0. + ++ zero?(x) tests if x is equal to 0. "*": (NonNegativeInteger,%) -> % ++ n * x is left-multiplication by a non negative integer add @@ -8082,7 +8148,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{BGAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf nil} \end{itemize} @@ -8154,6 +8220,7 @@ These exports come from \refto{HomogeneousAggregate}(S:Type): ++ objects, and where the order in which objects are inserted determines ++ the order of extraction. ++ Examples of bags are stacks, queues, and dequeues. + BagAggregate(S:Type): Category == HomogeneousAggregate S with shallowlyMutable ++ shallowlyMutable means that elements of bags may be @@ -8262,8 +8329,9 @@ These exports come from \refto{OrderedSet}(): ++ Date Created: 31 Oct 1988 ++ Date Last Updated: 14 May 1991 ++ Description: -++ A cachable set is a set whose elements keep an integer as part -++ of their structure. +++ A cachable set is a set whose elements keep an integer as part +++ of their structure. + CachableSet: Category == OrderedSet with position : % -> NonNegativeInteger ++ position(x) returns the integer n associated to x. @@ -8452,6 +8520,7 @@ These exports come from \refto{ConvertibleTo}(S:Type): ++ data type, except with an initial lower case letter, e.g. ++ \spadfun{list} for \spadtype{List}, ++ \spadfun{flexibleArray} for \spadtype{FlexibleArray}, and so on. + Collection(S:Type): Category == HomogeneousAggregate(S) with construct: List S -> % ++ \axiom{construct(x,y,...,z)} returns the collection of elements @@ -8463,52 +8532,52 @@ Collection(S:Type): Category == HomogeneousAggregate(S) with ++ and "failed" otherwise. if % has finiteAggregate then reduce: ((S,S)->S,%) -> S - ++ reduce(f,u) reduces the binary operation f across u. For example, - ++ if u is \axiom{[x,y,...,z]} then \axiom{reduce(f,u)} + ++ reduce(f,u) reduces the binary operation f across u. For example, + ++ if u is \axiom{[x,y,...,z]} then \axiom{reduce(f,u)} ++ returns \axiom{f(..f(f(x,y),...),z)}. - ++ Note: if u has one element x, \axiom{reduce(f,u)} returns x. - ++ Error: if u is empty. + ++ Note that if u has one element x, \axiom{reduce(f,u)} returns x. + ++ Error: if u is empty. ++ ++C )clear all ++X reduce(+,[C[i]*x**i for i in 1..5]) reduce: ((S,S)->S,%,S) -> S - ++ reduce(f,u,x) reduces the binary operation f across u, where x is - ++ the identity operation of f. - ++ Same as \axiom{reduce(f,u)} if u has 2 or more elements. - ++ Returns \axiom{f(x,y)} if u has one element y, - ++ x if u is empty. - ++ For example, \axiom{reduce(+,u,0)} returns the - ++ sum of the elements of u. + ++ reduce(f,u,x) reduces the binary operation f across u, where x is + ++ the identity operation of f. + ++ Same as \axiom{reduce(f,u)} if u has 2 or more elements. + ++ Returns \axiom{f(x,y)} if u has one element y, + ++ x if u is empty. + ++ For example, \axiom{reduce(+,u,0)} returns the + ++ sum of the elements of u. remove: (S->Boolean,%) -> % - ++ remove(p,u) returns a copy of u removing all elements x such that - ++ \axiom{p(x)} is true. - ++ Note: \axiom{remove(p,u) == [x for x in u | not p(x)]}. + ++ remove(p,u) returns a copy of u removing all elements x such that + ++ \axiom{p(x)} is true. + ++ Note that \axiom{remove(p,u) == [x for x in u | not p(x)]}. select: (S->Boolean,%) -> % - ++ select(p,u) returns a copy of u containing only those elements - ++ such \axiom{p(x)} is true. - ++ Note: \axiom{select(p,u) == [x for x in u | p(x)]}. + ++ select(p,u) returns a copy of u containing only those elements + ++ such \axiom{p(x)} is true. + ++ Note that \axiom{select(p,u) == [x for x in u | p(x)]}. if S has SetCategory then - reduce: ((S,S)->S,%,S,S) -> S - ++ reduce(f,u,x,z) reduces the binary operation f across u, - ++ stopping when an "absorbing element" z is encountered. - ++ As for \axiom{reduce(f,u,x)}, x is the identity operation of f. - ++ Same as \axiom{reduce(f,u,x)} when u contains no element z. - ++ Thus the third argument x is returned when u is empty. - remove: (S,%) -> % - ++ remove(x,u) returns a copy of u with all - ++ elements \axiom{y = x} removed. - ++ Note: \axiom{remove(y,c) == [x for x in c | x ^= y]}. - removeDuplicates: % -> % - ++ removeDuplicates(u) returns a copy of u with all duplicates + reduce: ((S,S)->S,%,S,S) -> S + ++ reduce(f,u,x,z) reduces the binary operation f across u, + ++ stopping when an "absorbing element" z is encountered. + ++ As for \axiom{reduce(f,u,x)}, x is the identity operation of f. + ++ Same as \axiom{reduce(f,u,x)} when u contains no element z. + ++ Thus the third argument x is returned when u is empty. + remove: (S,%) -> % + ++ remove(x,u) returns a copy of u with all + ++ elements \axiom{y = x} removed. + ++ Note that \axiom{remove(y,c) == [x for x in c | x ^= y]}. + removeDuplicates: % -> % + ++ removeDuplicates(u) returns a copy of u with all duplicates ++ removed. if S has ConvertibleTo InputForm then ConvertibleTo InputForm add if % has finiteAggregate then - #c == # parts c + #c == # parts c count(f:S -> Boolean, c:%) == _+/[1 for x in parts c | f x] - any?(f, c) == _or/[f x for x in parts c] - every?(f, c) == _and/[f x for x in parts c] + any?(f, c) == _or/[f x for x in parts c] + every?(f, c) == _and/[f x for x in parts c] find(f:S -> Boolean, c:%) == find(f, parts c) reduce(f:(S,S)->S, x:%) == reduce(f, parts x) reduce(f:(S,S)->S, x:%, s:S) == reduce(f, parts x, s) @@ -8652,50 +8721,50 @@ These exports come from \refto{RetractableTo}(S:OrderedSet): ++ Keywords: differential indeterminates, ranking, order, weight ++ References:Ritt, J.F. "Differential Algebra" (Dover, 1950). ++ Description: -++ \spadtype{DifferentialVariableCategory} constructs the -++ set of derivatives of a given set of -++ (ordinary) differential indeterminates. -++ If x,...,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 -++ x,\spad{x'},\spad{x''},..., y,\spad{y'},\spad{y''},... -++ (Note: in the interpreter, the n-th derivative of y is displayed as -++ y with a subscript 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. +++ \spadtype{DifferentialVariableCategory} constructs the +++ set of derivatives of a given set of +++ (ordinary) differential indeterminates. +++ If x,...,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 +++ x,\spad{x'},\spad{x''},..., y,\spad{y'},\spad{y''},... +++ (Note that in the interpreter, the n-th derivative of y is displayed as +++ y with a subscript 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. ++ -++ 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. +++ 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. ++ -++ 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. +++ 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. + DifferentialVariableCategory(S:OrderedSet): Category == Join(OrderedSet, RetractableTo S) with -- Examples: @@ -8946,9 +9015,10 @@ These exports come from \refto{Evalable}(a:SetCategory): ++ Author: Manuel Bronstein ++ Date Created: 22 March 1988 ++ Date Last Updated: 27 May 1994 +++ Keywords: operator, kernel, expression, space. ++ Description: ++ An expression space is a set which is closed under certain operators; -++ Keywords: operator, kernel, expression, space. + ExpressionSpace(): Category == Defn where N ==> NonNegativeInteger K ==> Kernel % @@ -9407,12 +9477,12 @@ These exports come from \refto{RetractableTo}(R:CommutativeRing): ++ Examples: ++ References: Encyclopedic Dictionary of Mathematics, MIT Press, 1977 ++ Description: -++ GradedAlgebra(R,E) denotes ``E-graded R-algebra''. -++ A graded algebra is a graded module together with a degree preserving -++ R-linear map, called the {\em product}. +++ GradedAlgebra(R,E) denotes ``E-graded R-algebra''. +++ A graded algebra is a graded module together with a degree preserving +++ R-linear map, called the product. ++ -++ The name ``product'' is written out in full so inner and outer products -++ with the same mapping type can be distinguished by name. +++ The name ``product'' is written out in full so inner and outer products +++ with the same mapping type can be distinguished by name. GradedAlgebra(R: CommutativeRing, E: AbelianMonoid): Category == Join(GradedModule(R, E),RetractableTo(R)) with @@ -9551,7 +9621,7 @@ digraph pic { is true if it is an aggregate with a finite number of elements. \item {\bf \cross{IXAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \end{itemize} @@ -9638,6 +9708,7 @@ These exports come from \refto{EltableAggregate}(Index:SetCategory,Entry:Type): ++ 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. + IndexedAggregate(Index: SetCategory, Entry: Type): Category == Join(HomogeneousAggregate(Entry), EltableAggregate(Index, Entry)) with entries: % -> List Entry @@ -9656,30 +9727,30 @@ IndexedAggregate(Index: SetCategory, Entry: Type): Category == -- ++ c.i = f(a(i,x),b(i,x)) | index?(i,a) or index?(i,b) if Entry has SetCategory and % has finiteAggregate then entry?: (Entry,%) -> Boolean - ++ entry?(x,u) tests if x equals \axiom{u . i} for some index i. + ++ entry?(x,u) tests if x equals \axiom{u . i} for some index i. if Index has OrderedSet then maxIndex: % -> Index - ++ maxIndex(u) returns the maximum index i of aggregate u. - ++ Note: in general, - ++ \axiom{maxIndex(u) = reduce(max,[i for i in indices u])}; - ++ if u is a list, \axiom{maxIndex(u) = #u}. + ++ maxIndex(u) returns the maximum index i of aggregate u. + ++ Note that in general, + ++ \axiom{maxIndex(u) = reduce(max,[i for i in indices u])}; + ++ if u is a list, \axiom{maxIndex(u) = #u}. minIndex: % -> Index - ++ minIndex(u) returns the minimum index i of aggregate u. - ++ Note: in general, - ++ \axiom{minIndex(a) = reduce(min,[i for i in indices a])}; - ++ for lists, \axiom{minIndex(a) = 1}. + ++ minIndex(u) returns the minimum index i of aggregate u. + ++ Note that in general, + ++ \axiom{minIndex(a) = reduce(min,[i for i in indices a])}; + ++ for lists, \axiom{minIndex(a) = 1}. first : % -> Entry - ++ first(u) returns the first element x of u. - ++ Note: for collections, \axiom{first([x,y,...,z]) = x}. - ++ Error: if u is empty. + ++ first(u) returns the first element x of u. + ++ Note that for collections, \axiom{first([x,y,...,z]) = x}. + ++ Error: if u is empty. if % has shallowlyMutable then fill_!: (%,Entry) -> % - ++ fill!(u,x) replaces each entry in aggregate u by x. - ++ The modified u is returned as value. + ++ fill!(u,x) replaces each entry in aggregate u by x. + ++ The modified u is returned as value. swap_!: (%,Index,Index) -> Void - ++ swap!(u,i,j) interchanges elements i and j of aggregate u. - ++ No meaningful value is returned. + ++ swap!(u,i,j) interchanges elements i and j of aggregate u. + ++ No meaningful value is returned. add elt(a, i, x) == (index?(i, a) => qelt(a, i); x) @@ -9834,16 +9905,19 @@ These exports come from \refto{Monad}(): ++ Keywords: ++ Keywords: Monad with unit, binary operation ++ Reference: -++ N. Jacobson: Structure and Representations of Jordan Algebras -++ AMS, Providence, 1968 +++ N. Jacobson: Structure and Representations of Jordan Algebras +++ AMS, Providence, 1968 ++ Description: -++ MonadWithUnit is the class of multiplicative monads with unit, -++ i.e. sets with a binary operation and a unit element. -++ Axioms -++ leftIdentity("*":(%,%)->%,1) \tab{30} 1*x=x -++ rightIdentity("*":(%,%)->%,1) \tab{30} x*1=x -++ Common Additional Axioms -++ unitsKnown---if "recip" says "failed", that PROVES input wasn't a unit +++ MonadWithUnit is the class of multiplicative monads with unit, +++ i.e. sets with a binary operation and a unit element. +++ +++ Axioms\br +++ \tab{5}leftIdentity("*":(%,%)->%,1) e.g. 1*x=x\br +++ \tab{5}rightIdentity("*":(%,%)->%,1) e.g x*1=x +++ +++ Common Additional Axioms\br +++ \tab{5}unitsKnown - if "recip" says "failed", it PROVES input wasn't a unit + MonadWithUnit(): Category == Monad with 1: constant -> % ++ 1 returns the unit element, denoted by 1. @@ -10011,12 +10085,13 @@ These exports come from \refto{SemiGroup}(): ++ The class of multiplicative monoids, i.e. semigroups with a ++ multiplicative identity element. ++ -++ Axioms: -++ \spad{leftIdentity("*":(%,%)->%,1)}\tab{30}\spad{1*x=x} -++ \spad{rightIdentity("*":(%,%)->%,1)}\tab{30}\spad{x*1=x} +++ Axioms\br +++ \tab{5}\spad{leftIdentity("*":(%,%)->%,1)}\tab{5}\spad{1*x=x}\br +++ \tab{5}\spad{rightIdentity("*":(%,%)->%,1)}\tab{4}\spad{x*1=x} ++ -++ Conditional attributes: -++ unitsKnown\tab{15}\spadfun{recip} only returns "failed" on non-units +++ Conditional attributes\br +++ \tab{5}unitsKnown - \spadfun{recip} only returns "failed" on non-units + Monoid(): Category == SemiGroup with 1: constant -> % ++ 1 is the multiplicative identity. @@ -10270,7 +10345,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{RCAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \end{itemize} @@ -10348,12 +10423,13 @@ These exports come from \refto{HomogeneousAggregate}(S:Type): ++ Description: ++ A recursive aggregate over a type S is a model for a ++ a directed graph containing values of type S. -++ Recursively, a recursive aggregate is a {\em node} +++ Recursively, a recursive aggregate is a node ++ consisting of a \spadfun{value} from S and 0 or more \spadfun{children} ++ which are recursive aggregates. ++ 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. + RecursiveAggregate(S:Type): Category == HomogeneousAggregate(S) with children: % -> List % ++ children(u) returns a list of the children of aggregate u. @@ -10377,19 +10453,19 @@ RecursiveAggregate(S:Type): Category == HomogeneousAggregate(S) with ++ distance(u,v) returns the path length (an integer) from node u to v. if S has SetCategory then child?: (%,%) -> Boolean - ++ child?(u,v) tests if node u is a child of node v. + ++ child?(u,v) tests if node u is a child of node v. node?: (%,%) -> Boolean - ++ node?(u,v) tests if node u is contained in node v - ++ (either as a child, a child of a child, etc.). + ++ node?(u,v) tests if node u is contained in node v + ++ (either as a child, a child of a child, etc.). if % has shallowlyMutable then setchildren_!: (%,List %)->% - ++ setchildren!(u,v) replaces the current children of node u - ++ with the members of v in left-to-right order. + ++ setchildren!(u,v) replaces the current children of node u + ++ with the members of v in left-to-right order. setelt: (%,"value",S) -> S - ++ setelt(a,"value",x) (also written \axiom{a . value := x}) - ++ is equivalent to \axiom{setvalue!(a,x)} + ++ setelt(a,"value",x) (also written \axiom{a . value := x}) + ++ is equivalent to \axiom{setvalue!(a,x)} setvalue_!: (%,S) -> S - ++ setvalue!(u,x) sets the value of node u to x. + ++ setvalue!(u,x) sets the value of node u to x. add elt(x,"value") == value x if % has shallowlyMutable then @@ -10498,7 +10574,7 @@ first column in an array and vice versa. is true if it is an aggregate with a finite number of elements. \item {\bf \cross{ARR2CAT}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf nil} \end{itemize} @@ -10507,7 +10583,7 @@ domain are irrevelant to the shallowlyMutable proper. \begin{itemize} \item {\bf \cross{ARR2CAT}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \end{itemize} @@ -10571,13 +10647,15 @@ These exports come from \refto{HomogeneousAggregate}(R:Type) <>= )abbrev category ARR2CAT TwoDimensionalArrayCategory -++ Two dimensional array categories and domains ++ Author: ++ Date Created: 27 October 1989 ++ Date Last Updated: 27 June 1990 ++ Keywords: array, data structure ++ Examples: ++ References: +++ Description: +++ Two dimensional array categories and domains + TwoDimensionalArrayCategory(R,Row,Col): Category == Definition where R : Type Row : FiniteLinearAggregate R @@ -11045,7 +11123,7 @@ digraph pic { is true if it is an aggregate with a finite number of elements. \item {\bf \cross{BRAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \end{itemize} @@ -11131,6 +11209,7 @@ These exports come from \refto{RecursiveAggregate}(S:Type) ++ Description: ++ 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 + BinaryRecursiveAggregate(S:Type):Category == RecursiveAggregate S with -- needs preorder, inorder and postorder iterators left: % -> % @@ -11145,15 +11224,15 @@ BinaryRecursiveAggregate(S:Type):Category == RecursiveAggregate S with ++ is equivalent to \axiom{right(a)}. if % has shallowlyMutable then setelt: (%,"left",%) -> % - ++ setelt(a,"left",b) (also written \axiom{a . left := b}) is - ++ equivalent to \axiom{setleft!(a,b)}. + ++ setelt(a,"left",b) (also written \axiom{a . left := b}) is + ++ equivalent to \axiom{setleft!(a,b)}. setleft_!: (%,%) -> % - ++ setleft!(a,b) sets the left child of \axiom{a} to be b. + ++ setleft!(a,b) sets the left child of \axiom{a} to be b. setelt: (%,"right",%) -> % - ++ setelt(a,"right",b) (also written \axiom{b . right := b}) - ++ is equivalent to \axiom{setright!(a,b)}. + ++ setelt(a,"right",b) (also written \axiom{b . right := b}) + ++ is equivalent to \axiom{setright!(a,b)}. setright_!: (%,%) -> % - ++ setright!(a,x) sets the right child of t to be x. + ++ setright!(a,x) sets the right child of t to be x. add cycleMax ==> 1000 @@ -11186,22 +11265,22 @@ BinaryRecursiveAggregate(S:Type):Category == RecursiveAggregate S with value x = value y and left x = left y and right x = right y if % has finiteAggregate then member?(x,u) == - empty? u => false - x = value u => true - member?(x,left u) or member?(x,right u) + empty? u => false + x = value u => true + member?(x,left u) or member?(x,right u) if S has SetCategory then coerce(t:%): OutputForm == empty? t => "[]"::OutputForm v := value(t):: OutputForm empty? left t => - empty? right t => v - r := coerce(right t)@OutputForm - bracket ["."::OutputForm, v, r] + empty? right t => v + r := coerce(right t)@OutputForm + bracket ["."::OutputForm, v, r] l := coerce(left t)@OutputForm r := - empty? right t => "."::OutputForm - coerce(right t)@OutputForm + empty? right t => "."::OutputForm + coerce(right t)@OutputForm bracket [l, v, r] if % has finiteAggregate then @@ -11216,7 +11295,7 @@ BinaryRecursiveAggregate(S:Type):Category == RecursiveAggregate S with isCycle?: (%, List %) -> Boolean eqMember?: (%, List %) -> Boolean - cyclic? x == not empty? x and isCycle?(x,empty()$(List %)) + cyclic? x == not empty? x and isCycle?(x,empty()$(List %)) isCycle?(x,acc) == empty? x => false eqMember?(x,acc) => true @@ -11329,13 +11408,12 @@ These exports come from \refto{AbelianMonoid}(): ++ Keywords: ++ References: Davenport & Trager I ++ Description: -++ This is an \spadtype{AbelianMonoid} with the cancellation property, i.e. -++ \spad{ a+b = a+c => b=c }. +++ This is an \spadtype{AbelianMonoid} with the cancellation property, i.e.\br +++ \tab{5}\spad{ a+b = a+c => b=c }.\br ++ This is formalised by the partial subtraction operator, -++ which satisfies the axioms listed below: -++ -++ Axioms: -++ \spad{c = a+b <=> c-b = a} +++ which satisfies the Axioms\br +++ \tab{5}\spad{c = a+b <=> c-b = a} + CancellationAbelianMonoid(): Category == AbelianMonoid with subtractIfCan: (%,%) -> Union(%,"failed") ++ subtractIfCan(x, y) returns an element z such that \spad{z+y=x} @@ -11451,7 +11529,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{DIOPS}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf nil} \end{itemize} @@ -11548,6 +11626,7 @@ These exports come from \refto{Collection}(S:SetCategory) ++ Description: ++ This category is a collection of operations common to both ++ categories \spadtype{Dictionary} and \spadtype{MultiDictionary} + DictionaryOperations(S:SetCategory): Category == Join(BagAggregate S, Collection(S)) with dictionary: () -> % @@ -11555,8 +11634,8 @@ DictionaryOperations(S:SetCategory): Category == dictionary: List S -> % ++ dictionary([x,y,...,z]) creates a dictionary consisting of ++ entries \axiom{x,y,...,z}. --- insert: (S,%) -> S ++ insert an entry --- member?: (S,%) -> Boolean ++ search for an entry +-- insert: (S,%) -> S ++ insert an entry +-- member?: (S,%) -> Boolean ++ search for an entry -- remove_!: (S,%,NonNegativeInteger) -> % -- ++ remove!(x,d,n) destructively changes dictionary d by removing -- ++ up to n entries y such that \axiom{y = x}. @@ -11580,7 +11659,7 @@ DictionaryOperations(S:SetCategory): Category == copy d == dictionary parts d coerce(s:%):OutputForm == prefix("dictionary"@String :: OutputForm, - [x::OutputForm for x in parts s]) + [x::OutputForm for x in parts s]) @ <>= @@ -11695,7 +11774,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{DLAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \end{itemize} @@ -11778,6 +11857,7 @@ These exports come from \refto{RecursiveAggregate}(S:Type): ++ A doubly-linked aggregate serves as a model for a doubly-linked ++ list, that is, a list which can has links to both next and previous ++ nodes and thus can be efficiently traversed in both directions. + DoublyLinkedAggregate(S:Type): Category == RecursiveAggregate S with last: % -> S ++ last(l) returns the last element of a doubly-linked aggregate l. @@ -11793,21 +11873,21 @@ DoublyLinkedAggregate(S:Type): Category == RecursiveAggregate S with ++ previous(l) returns the doubly-link list beginning with its previous ++ element. ++ Error: if l has no previous element. - ++ Note: \axiom{next(previous(l)) = l}. + ++ Note that \axiom{next(previous(l)) = l}. next: % -> % ++ next(l) returns the doubly-linked aggregate beginning with its next ++ element. ++ Error: if l has no next element. - ++ Note: \axiom{next(l) = rest(l)} and \axiom{previous(next(l)) = l}. + ++ Note that \axiom{next(l) = rest(l)} and \axiom{previous(next(l)) = l}. if % has shallowlyMutable then concat_!: (%,%) -> % - ++ concat!(u,v) destructively concatenates doubly-linked aggregate v + ++ concat!(u,v) destructively concatenates doubly-linked aggregate v ++ to the end of doubly-linked aggregate u. setprevious_!: (%,%) -> % - ++ setprevious!(u,v) destructively sets the previous node of + ++ setprevious!(u,v) destructively sets the previous node of ++ doubly-linked aggregate u to v, returning v. setnext_!: (%,%) -> % - ++ setnext!(u,v) destructively sets the next node of doubly-linked + ++ setnext!(u,v) destructively sets the next node of doubly-linked ++ aggregate u to v, returning v. @ @@ -11931,9 +12011,10 @@ These exports come from \refto{Monoid}(): ++ The class of multiplicative groups, i.e. monoids with ++ multiplicative inverses. ++ -++ Axioms: -++ \spad{leftInverse("*":(%,%)->%,inv)}\tab{30}\spad{ inv(x)*x = 1 } -++ \spad{rightInverse("*":(%,%)->%,inv)}\tab{30}\spad{ x*inv(x) = 1 } +++ Axioms\br +++ \tab{5}\spad{leftInverse("*":(%,%)->%,inv)}\tab{5}\spad{ inv(x)*x = 1 }\br +++ \tab{5}\spad{rightInverse("*":(%,%)->%,inv)}\tab{4}\spad{ x*inv(x) = 1 } + Group(): Category == Monoid with inv: % -> % ++ inv(x) returns the inverse of x. @@ -12095,7 +12176,7 @@ digraph pic { is true if it is an aggregate with a finite number of elements. \item {\bf \cross{LNAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \end{itemize} @@ -12212,20 +12293,21 @@ These exports come from \refto{Collection}(S:Type): ++ arguments. Most of the operations exported here apply to infinite ++ objects (e.g. streams) as well to finite ones. ++ For finite linear aggregates, see \spadtype{FiniteLinearAggregate}. + LinearAggregate(S:Type): Category == Join(IndexedAggregate(Integer, S), Collection(S)) with - new : (NonNegativeInteger,S) -> % + new : (NonNegativeInteger,S) -> % ++ new(n,x) returns \axiom{fill!(new n,x)}. concat: (%,S) -> % ++ concat(u,x) returns aggregate u with additional element x at the end. - ++ Note: for lists, \axiom{concat(u,x) == concat(u,[x])} + ++ Note that for lists, \axiom{concat(u,x) == concat(u,[x])} concat: (S,%) -> % ++ concat(x,u) returns aggregate u with additional element at the front. - ++ Note: for lists: \axiom{concat(x,u) == concat([x],u)}. + ++ Note that for lists: \axiom{concat(x,u) == concat([x],u)}. concat: (%,%) -> % ++ concat(u,v) returns an aggregate consisting of the elements of u ++ followed by the elements of v. - ++ Note: if \axiom{w = concat(u,v)} then + ++ Note that if \axiom{w = concat(u,v)} then ++ \axiom{w.i = u.i for i in indices u} ++ and \axiom{w.(j + maxIndex u) = v.j for j in indices v}. concat: List % -> % @@ -12233,44 +12315,44 @@ LinearAggregate(S:Type): Category == ++ returns a single aggregate consisting of the elements of \axiom{a} ++ followed by those ++ of b followed ... by the elements of c. - ++ Note: \axiom{concat(a,b,...,c) = concat(a,concat(b,...,c))}. + ++ Note that \axiom{concat(a,b,...,c) = concat(a,concat(b,...,c))}. map: ((S,S)->S,%,%) -> % ++ map(f,u,v) returns a new collection w with elements ++ \axiom{z = f(x,y)} for corresponding elements x and y from u and v. - ++ Note: for linear aggregates, \axiom{w.i = f(u.i,v.i)}. + ++ Note that for linear aggregates, \axiom{w.i = f(u.i,v.i)}. elt: (%,UniversalSegment(Integer)) -> % ++ elt(u,i..j) (also written: \axiom{a(i..j)}) returns the aggregate of ++ elements \axiom{u} for k from i to j in that order. - ++ Note: in general, \axiom{a.s = [a.k for i in s]}. + ++ Note that in general, \axiom{a.s = [a.k for i in s]}. delete: (%,Integer) -> % ++ delete(u,i) returns a copy of u with the \axiom{i}th - ++ element deleted. Note: for lists, + ++ element deleted. Note that for lists, ++ \axiom{delete(a,i) == concat(a(0..i - 1),a(i + 1,..))}. delete: (%,UniversalSegment(Integer)) -> % ++ delete(u,i..j) returns a copy of u with the \axiom{i}th through ++ \axiom{j}th element deleted. - ++ Note: \axiom{delete(a,i..j) = concat(a(0..i-1),a(j+1..))}. + ++ Note that \axiom{delete(a,i..j) = concat(a(0..i-1),a(j+1..))}. insert: (S,%,Integer) -> % ++ insert(x,u,i) returns a copy of u having x as its ++ \axiom{i}th element. - ++ Note: \axiom{insert(x,a,k) = concat(concat(a(0..k-1),x),a(k..))}. + ++ Note that \axiom{insert(x,a,k) = concat(concat(a(0..k-1),x),a(k..))}. insert: (%,%,Integer) -> % ++ insert(v,u,k) returns a copy of u having v inserted beginning at the ++ \axiom{i}th element. - ++ Note: \axiom{insert(v,u,k) = concat( u(0..k-1), v, u(k..) )}. + ++ Note that \axiom{insert(v,u,k) = concat( u(0..k-1), v, u(k..) )}. if % has shallowlyMutable then setelt: (%,UniversalSegment(Integer),S) -> S ++ setelt(u,i..j,x) (also written: \axiom{u(i..j) := x}) destructively ++ replaces each element in the segment \axiom{u(i..j)} by x. ++ The value x is returned. - ++ Note: u is destructively change so + ++ Note that u is destructively change so ++ that \axiom{u.k := x for k in i..j}; ++ its length remains unchanged. add - indices a == [i for i in minIndex a .. maxIndex a] - index?(i, a) == i >= minIndex a and i <= maxIndex a - concat(a:%, x:S) == concat(a, new(1, x)) - concat(x:S, y:%) == concat(new(1, x), y) + indices a == [i for i in minIndex a .. maxIndex a] + index?(i, a) == i >= minIndex a and i <= maxIndex a + concat(a:%, x:S) == concat(a, new(1, x)) + concat(x:S, y:%) == concat(new(1, x), y) insert(x:S, a:%, i:Integer) == insert(new(1, x), a, i) if % has finiteAggregate then maxIndex l == #l - 1 + minIndex l @@ -13613,7 +13695,7 @@ should be put into these packages. is true if it is an aggregate with a finite number of elements. \item {\bf \cross{MATCAT}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf nil} \end{itemize} @@ -13735,16 +13817,17 @@ Col:FiniteLinearAggregate(R): ++ Examples: ++ References: ++ Description: -++ \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 colums 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. +++ \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 colums 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. + MatrixCategory(R,Row,Col): Category == Definition where R : Ring Row : FiniteLinearAggregate R @@ -13814,7 +13897,7 @@ MatrixCategory(R,Row,Col): Category == Definition where diagonalMatrix: List % -> % ++ \spad{diagonalMatrix([m1,...,mk])} creates a block diagonal matrix - ++ M with block matrices {\em m1},...,{\em mk} down the diagonal, + ++ M with block matrices m1,...,mk down the diagonal, ++ with 0 block matrices elsewhere. ++ More precisly: if \spad{ri := nrows mi}, \spad{ci := ncols mi}, ++ then m is an (r1+..+rk) by (c1+..+ck) - matrix with entries @@ -14600,8 +14683,11 @@ These exports come from \refto{AbelianMonoid}(): ++ References: ++ Description: ++ Ordered sets which are also abelian semigroups, such that the addition -++ preserves the ordering. -++ \spad{ x < y => x+z < y+z} +++ preserves the ordering.\br +++ +++ Axiom\br +++ \tab{5} x < y => x+z < y+z + OrderedAbelianSemiGroup(): Category == Join(OrderedSet, AbelianMonoid) @ @@ -14738,9 +14824,9 @@ These exports come from \refto{OrderedSet}(): ++ Ordered sets which are also monoids, such that multiplication ++ preserves the ordering. ++ -++ Axioms: -++ \spad{x < y => x*z < y*z} -++ \spad{x < y => z*x < z*y} +++ Axioms\br +++ \tab{5}\spad{x < y => x*z < y*z}\br +++ \tab{5}\spad{x < y => z*x < z*y} OrderedMonoid(): Category == Join(OrderedSet, Monoid) @@ -14975,7 +15061,8 @@ These exports come from \refto{IntegralDomain}(): ++ AMS Classifications: ++ Keywords: polynomial, multivariate, ordered variables set ++ References: -++ Description: A category for finite subsets of a polynomial ring. +++ Description: +++ 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 @@ -14984,7 +15071,6 @@ These exports come from \refto{IntegralDomain}(): ++ 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. -++ Version: 2 PolynomialSetCategory(R:Ring, E:OrderedAbelianMonoidSup,_ VarSet:OrderedSet, P:RecursivePolynomialCategory(R,E,VarSet)): Category == @@ -15457,7 +15543,7 @@ digraph pic { is true if it is an aggregate with a finite number of elements. \item {\bf \cross{PROAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \end{itemize} @@ -15525,6 +15611,7 @@ These exports come from \refto{BagAggregate}(S:OrderedSet): ++ Description: ++ A priority queue is a bag of items from an ordered set where the item ++ extracted is always the maximum element. + PriorityQueueAggregate(S:OrderedSet): Category == BagAggregate S with finiteAggregate max: % -> S @@ -15634,7 +15721,7 @@ digraph pic { is true if it is an aggregate with a finite number of elements. \item {\bf \cross{QUAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \end{itemize} @@ -15705,6 +15792,7 @@ These exports come from \refto{BagAggregate}(S:Type): ++ Description: ++ A queue is a bag where the first item inserted is the first ++ item extracted. + QueueAggregate(S:Type): Category == BagAggregate S with finiteAggregate enqueue_!: (S, %) -> S @@ -15716,10 +15804,10 @@ QueueAggregate(S:Type): Category == BagAggregate S with rotate_!: % -> % ++ rotate! q rotates queue q so that the element at the front of ++ the queue goes to the back of the queue. - ++ Note: rotate! q is equivalent to enqueue!(dequeue!(q)). + ++ Note that rotate! q is equivalent to enqueue!(dequeue!(q)). length: % -> NonNegativeInteger ++ length(q) returns the number of elements in the queue. - ++ Note: \axiom{length(q) = #q}. + ++ Note that \axiom{length(q) = #q}. front: % -> S ++ front(q) returns the element at the front of the queue. ++ The queue q is unchanged by this operation. @@ -15939,6 +16027,7 @@ These exports come from \refto{Collection}(S:SetCategory): ++ Although the operations defined for set categories are ++ common to both, the relationship between the two cannot ++ be described by inclusion or inheritance. + SetAggregate(S:SetCategory): Category == Join(SetCategory, Collection(S)) with partiallyOrderedSet @@ -15953,36 +16042,36 @@ SetAggregate(S:SetCategory): ++ brace([x,y,...,z]) ++ creates a set aggregate containing items x,y,...,z. ++ This form is considered obsolete. Use \axiomFun{set} instead. - set : () -> % + set : () -> % ++ set()$D creates an empty set aggregate of type D. - set : List S -> % + set : List S -> % ++ set([x,y,...,z]) creates a set aggregate containing items x,y,...,z. intersect: (%, %) -> % ++ intersect(u,v) returns the set aggregate w consisting of ++ elements common to both set aggregates u and v. - ++ Note: equivalent to the notation (not currently supported) + ++ Note that equivalent to the notation (not currently supported) ++ {x for x in u | member?(x,v)}. difference : (%, %) -> % ++ difference(u,v) returns the set aggregate w consisting of ++ elements in set aggregate u but not in set aggregate v. ++ If u and v have no elements in common, \axiom{difference(u,v)} ++ returns a copy of u. - ++ Note: equivalent to the notation (not currently supported) + ++ Note that equivalent to the notation (not currently supported) ++ \axiom{{x for x in u | not member?(x,v)}}. difference : (%, S) -> % ++ difference(u,x) returns the set aggregate u with element x removed. ++ If u does not contain x, a copy of u is returned. - ++ Note: \axiom{difference(s, x) = difference(s, {x})}. + ++ Note that \axiom{difference(s, x) = difference(s, {x})}. symmetricDifference : (%, %) -> % ++ symmetricDifference(u,v) returns the set aggregate of elements x ++ which are members of set aggregate u or set aggregate v but ++ not both. If u and v have no elements in common, ++ \axiom{symmetricDifference(u,v)} returns a copy of u. - ++ Note: \axiom{symmetricDifference(u,v) = + ++ Note that \axiom{symmetricDifference(u,v) = ++ union(difference(u,v),difference(v,u))} subset? : (%, %) -> Boolean ++ subset?(u,v) tests if u is a subset of v. - ++ Note: equivalent to + ++ Note that equivalent to ++ \axiom{reduce(and,{member?(x,v) for x in u},true,false)}. union : (%, %) -> % ++ union(u,v) returns the set aggregate of elements which are members @@ -16106,7 +16195,7 @@ digraph pic { is true if it is an aggregate with a finite number of elements. \item {\bf \cross{SKAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \end{itemize} @@ -16174,6 +16263,7 @@ These exports come from \refto{BagAggregate}(S:Type): ++ References: ++ Description: ++ A stack is a bag where the last item inserted is the first item extracted. + StackAggregate(S:Type): Category == BagAggregate S with finiteAggregate push_!: (S,%) -> S @@ -16186,7 +16276,7 @@ StackAggregate(S:Type): Category == BagAggregate S with ++X a pop_!: % -> S ++ pop!(s) returns the top element x, destructively removing x from s. - ++ Note: Use \axiom{top(s)} to obtain x without removing it from s. + ++ Note that Use \axiom{top(s)} to obtain x without removing it from s. ++ Error: if s is empty. ++ ++X a:Stack INT:= stack [1,2,3,4,5] @@ -16194,13 +16284,13 @@ StackAggregate(S:Type): Category == BagAggregate S with ++X a top: % -> S ++ top(s) returns the top element x from s; s remains unchanged. - ++ Note: Use \axiom{pop!(s)} to obtain x and remove it from s. + ++ Note that Use \axiom{pop!(s)} to obtain x and remove it from s. ++ ++X a:Stack INT:= stack [1,2,3,4,5] ++X top a depth: % -> NonNegativeInteger ++ depth(s) returns the number of elements of stack s. - ++ Note: \axiom{depth(s) = #s}. + ++ Note that \axiom{depth(s) = #s}. ++ ++X a:Stack INT:= stack [1,2,3,4,5] ++X depth a @@ -16325,7 +16415,7 @@ digraph pic { is true if it is an aggregate with a finite number of elements. \item {\bf \cross{URAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \end{itemize} @@ -16437,15 +16527,16 @@ These exports come from \refto{RecursiveAggregate}(S:Type): ++ of the list, and the child designating the tail, or \spadfun{rest}, ++ of the list. A node with no child then designates the empty list. ++ Since these aggregates are recursive aggregates, they may be cyclic. + UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with concat: (%,%) -> % ++ concat(u,v) returns an aggregate w consisting of the elements of u ++ followed by the elements of v. - ++ Note: \axiom{v = rest(w,#a)}. + ++ Note that \axiom{v = rest(w,#a)}. concat: (S,%) -> % ++ concat(x,u) returns aggregate consisting of x followed by ++ the elements of u. - ++ Note: if \axiom{v = concat(x,u)} then \axiom{x = first v} + ++ Note that if \axiom{v = concat(x,u)} then \axiom{x = first v} ++ and \axiom{u = rest v}. first: % -> S ++ first(u) returns the first element of u @@ -16465,26 +16556,26 @@ UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with ++ equivalent to \axiom{rest u}. rest: (%,NonNegativeInteger) -> % ++ rest(u,n) returns the \axiom{n}th (n >= 0) node of u. - ++ Note: \axiom{rest(u,0) = u}. + ++ Note that \axiom{rest(u,0) = u}. last: % -> S ++ last(u) resturn the last element of u. - ++ Note: for lists, \axiom{last(u) = u . (maxIndex u) = u . (# u - 1)}. + ++ Note that for lists, \axiom{last(u)=u . (maxIndex u)=u . (# u - 1)}. elt: (%,"last") -> S ++ elt(u,"last") (also written: \axiom{u . last}) is equivalent ++ to last u. last: (%,NonNegativeInteger) -> % ++ last(u,n) returns a copy of the last n (\axiom{n >= 0}) nodes of u. - ++ Note: \axiom{last(u,n)} is a list of n elements. + ++ Note that \axiom{last(u,n)} is a list of n elements. tail: % -> % ++ tail(u) returns the last node of u. - ++ Note: if u is \axiom{shallowlyMutable}, + ++ Note that if u is \axiom{shallowlyMutable}, ++ \axiom{setrest(tail(u),v) = concat(u,v)}. second: % -> S ++ second(u) returns the second element of u. - ++ Note: \axiom{second(u) = first(rest(u))}. + ++ Note that \axiom{second(u) = first(rest(u))}. third: % -> S ++ third(u) returns the third element of u. - ++ Note: \axiom{third(u) = first(rest(rest(u)))}. + ++ Note that \axiom{third(u) = first(rest(rest(u)))}. cycleEntry: % -> % ++ cycleEntry(u) returns the head of a top-level cycle contained in ++ aggregate u, or \axiom{empty()} if none exists. @@ -16496,36 +16587,36 @@ UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with ++ empty if none exists. if % has shallowlyMutable then concat_!: (%,%) -> % - ++ concat!(u,v) destructively concatenates v to the end of u. - ++ Note: \axiom{concat!(u,v) = setlast_!(u,v)}. + ++ concat!(u,v) destructively concatenates v to the end of u. + ++ Note that \axiom{concat!(u,v) = setlast_!(u,v)}. concat_!: (%,S) -> % - ++ concat!(u,x) destructively adds element x to the end of u. - ++ Note: \axiom{concat!(a,x) = setlast!(a,[x])}. + ++ concat!(u,x) destructively adds element x to the end of u. + ++ Note that \axiom{concat!(a,x) = setlast!(a,[x])}. cycleSplit_!: % -> % - ++ cycleSplit!(u) splits the aggregate by dropping off the cycle. - ++ The value returned is the cycle entry, or nil if none exists. - ++ For example, if \axiom{w = concat(u,v)} is the cyclic list where - ++ v is the head of the cycle, \axiom{cycleSplit!(w)} will drop v - ++ off w thus destructively changing w to u, and returning v. + ++ cycleSplit!(u) splits the aggregate by dropping off the cycle. + ++ The value returned is the cycle entry, or nil if none exists. + ++ For example, if \axiom{w = concat(u,v)} is the cyclic list where + ++ v is the head of the cycle, \axiom{cycleSplit!(w)} will drop v + ++ off w thus destructively changing w to u, and returning v. setfirst_!: (%,S) -> S - ++ setfirst!(u,x) destructively changes the first element of a to x. + ++ setfirst!(u,x) destructively changes the first element of a to x. setelt: (%,"first",S) -> S - ++ setelt(u,"first",x) (also written: \axiom{u.first := x}) is - ++ equivalent to \axiom{setfirst!(u,x)}. + ++ setelt(u,"first",x) (also written: \axiom{u.first := x}) is + ++ equivalent to \axiom{setfirst!(u,x)}. setrest_!: (%,%) -> % - ++ setrest!(u,v) destructively changes the rest of u to v. + ++ setrest!(u,v) destructively changes the rest of u to v. setelt: (%,"rest",%) -> % - ++ setelt(u,"rest",v) (also written: \axiom{u.rest := v}) is - ++ equivalent to \axiom{setrest!(u,v)}. + ++ setelt(u,"rest",v) (also written: \axiom{u.rest := v}) is + ++ equivalent to \axiom{setrest!(u,v)}. setlast_!: (%,S) -> S - ++ setlast!(u,x) destructively changes the last element of u to x. + ++ setlast!(u,x) destructively changes the last element of u to x. setelt: (%,"last",S) -> S - ++ setelt(u,"last",x) (also written: \axiom{u.last := b}) - ++ is equivalent to \axiom{setlast!(u,v)}. + ++ setelt(u,"last",x) (also written: \axiom{u.last := b}) + ++ is equivalent to \axiom{setlast!(u,v)}. split_!: (%,Integer) -> % - ++ split!(u,n) splits u into two aggregates: \axiom{v = rest(u,n)} - ++ and \axiom{w = first(u,n)}, returning \axiom{v}. - ++ Note: afterwards \axiom{rest(u,n)} returns \axiom{empty()}. + ++ split!(u,n) splits u into two aggregates: \axiom{v = rest(u,n)} + ++ and \axiom{w = first(u,n)}, returning \axiom{v}. + ++ Note that afterwards \axiom{rest(u,n)} returns \axiom{empty()}. add cycleMax ==> 1000 @@ -16534,10 +16625,10 @@ UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with elt(x, "first") == first x elt(x, "last") == last x elt(x, "rest") == rest x - second x == first rest x - third x == first rest rest x - cyclic? x == not empty? x and not empty? findCycle x - last x == first tail x + second x == first rest x + third x == first rest rest x + cyclic? x == not empty? x and not empty? findCycle x + last x == first tail x nodes x == l := empty()$List(%) @@ -16635,24 +16726,24 @@ UnaryRecursiveAggregate(S:Type): Category == RecursiveAggregate S with x = y == eq?(x, y) => true for k in 0.. while not empty? x and not empty? y repeat - k = cycleMax and cyclic? x => error "cyclic list" - first x ^= first y => return false - x := rest x - y := rest y + k = cycleMax and cyclic? x => error "cyclic list" + first x ^= first y => return false + x := rest x + y := rest y empty? x and empty? y node?(u, v) == for k in 0.. while not empty? v repeat - u = v => return true - k = cycleMax and cyclic? v => error "cyclic list" - v := rest v + u = v => return true + k = cycleMax and cyclic? v => error "cyclic list" + v := rest v u=v if % has shallowlyMutable then setelt(x, "first", a) == setfirst_!(x, a) setelt(x, "last", a) == setlast_!(x, a) setelt(x, "rest", a) == setrest_!(x, a) - concat(x:%, y:%) == concat_!(copy x, y) + concat(x:%, y:%) == concat_!(copy x, y) setlast_!(x, s) == empty? x => error "setlast: empty list" @@ -16790,10 +16881,11 @@ These exports come from \refto{CancellationAbelianMonoid}(): ++ The class of abelian groups, i.e. additive monoids where ++ each element has an additive inverse. ++ -++ Axioms: -++ \spad{-(-x) = x} -++ \spad{x+(-x) = 0} +++ Axioms\br +++ \tab{5}\spad{-(-x) = x}\br +++ \tab{5}\spad{x+(-x) = 0} -- following domain must be compiled with subsumption disabled + AbelianGroup(): Category == CancellationAbelianMonoid with "-": % -> % ++ -x is the additive inverse of x. @@ -16923,7 +17015,7 @@ digraph pic { is true if it is an aggregate with a finite number of elements. \item {\bf \cross{BTCAT}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf nil} \end{itemize} @@ -16999,10 +17091,12 @@ These exports come from \refto{BinaryRecursiveAggregate}(S:SetCategory): ++ Keywords: ++ Examples: ++ References: -++ Description: \spadtype{BinaryTreeCategory(S)} is the category of +++ Description: +++ \spadtype{BinaryTreeCategory(S)} is the category of ++ binary trees: a tree which is either empty or else is a ++ \spadfun{node} consisting of a value and a \spadfun{left} and ++ \spadfun{right}, both binary trees. + BinaryTreeCategory(S: SetCategory): Category == _ BinaryRecursiveAggregate(S) with shallowlyMutable @@ -17142,7 +17236,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{DIAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf nil} \end{itemize} @@ -17234,6 +17328,7 @@ These exports come from \refto{DictionaryOperations}(S:SetCategory): ++ 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. + Dictionary(S:SetCategory): Category == DictionaryOperations S add dictionary l == @@ -17243,13 +17338,13 @@ Dictionary(S:SetCategory): Category == if % has finiteAggregate then -- remove(f:S->Boolean,t:%) == remove_!(f, copy t) - -- select(f, t) == select_!(f, copy t) - select_!(f, t) == remove_!((x:S):Boolean +-> not f(x), t) + -- select(f, t) == select_!(f, copy t) + select_!(f, t) == remove_!((x:S):Boolean +-> not f(x), t) --extract_! d == - -- empty? d => error "empty dictionary" - -- remove_!(x := first parts d, d, 1) - -- x + -- empty? d => error "empty dictionary" + -- remove_!(x := first parts d, d, 1) + -- x s = t == eq?(s,t) => true @@ -17379,7 +17474,7 @@ digraph pic { is true if it is an aggregate with a finite number of elements. \item {\bf \cross{DQAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf nil} \end{itemize} @@ -17470,6 +17565,7 @@ These exports come from \refto{QueueAggregate}(S:Type): ++ 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. + DequeueAggregate(S:Type): Category == Join(StackAggregate S,QueueAggregate S) with dequeue: () -> % @@ -17479,7 +17575,7 @@ DequeueAggregate(S:Type): ++ element x, second element y,...,and last (bottom or back) element z. height: % -> NonNegativeInteger ++ height(d) returns the number of elements in dequeue d. - ++ Note: \axiom{height(d) = # d}. + ++ Note that \axiom{height(d) = # d}. top_!: % -> S ++ top!(d) returns the element at the top (front) of the dequeue. bottom_!: % -> S @@ -17619,7 +17715,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{ELAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf nil} \end{itemize} @@ -17746,6 +17842,7 @@ These exports come from \refto{LinearAggregate}(S:Type): ++ 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. + ExtensibleLinearAggregate(S:Type):Category == LinearAggregate S with shallowlyMutable concat_!: (%,S) -> % @@ -17784,18 +17881,18 @@ ExtensibleLinearAggregate(S:Type):Category == LinearAggregate S with if S has OrderedSet then merge_!: (%,%) -> % ++ merge!(u,v) destructively merges u and v in ascending order. add - delete(x:%, i:Integer) == delete_!(copy x, i) - delete(x:%, i:UniversalSegment(Integer)) == delete_!(copy x, i) + delete(x:%, i:Integer) == delete_!(copy x, i) + delete(x:%, i:UniversalSegment(Integer)) == delete_!(copy x, i) remove(f:S -> Boolean, x:%) == remove_!(f, copy x) insert(s:S, x:%, i:Integer) == insert_!(s, copy x, i) insert(w:%, x:%, i:Integer) == insert_!(copy w, copy x, i) - select(f, x) == select_!(f, copy x) - concat(x:%, y:%) == concat_!(copy x, y) - concat(x:%, y:S) == concat_!(copy x, new(1, y)) - concat_!(x:%, y:S) == concat_!(x, new(1, y)) + select(f, x) == select_!(f, copy x) + concat(x:%, y:%) == concat_!(copy x, y) + concat(x:%, y:S) == concat_!(copy x, new(1, y)) + concat_!(x:%, y:S) == concat_!(x, new(1, y)) if S has SetCategory then - remove(s:S, x:%) == remove_!(s, copy x) - remove_!(s:S, x:%) == remove_!(y +-> y = s, x) + remove(s:S, x:%) == remove_!(s, copy x) + remove_!(s:S, x:%) == remove_!(y +-> y = s, x) removeDuplicates(x:%) == removeDuplicates_!(copy x) if S has OrderedSet then @@ -17930,7 +18027,7 @@ is true if it is an aggregate with a finite number of elements. \begin{itemize} \item {\bf \cross{FLAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \end{itemize} @@ -18074,6 +18171,7 @@ These exports come from \refto{OrderedSet}: ++ The finite property of the aggregate adds several exports to the ++ list of exports from \spadtype{LinearAggregate} such as ++ \spadfun{reverse}, \spadfun{sort}, and so on. + FiniteLinearAggregate(S:Type): Category == LinearAggregate S with finiteAggregate merge: ((S,S)->Boolean,%,%) -> % @@ -18099,49 +18197,49 @@ FiniteLinearAggregate(S:Type): Category == LinearAggregate S with ++ such that \axiom{p(x)} is true, and \axiom{minIndex(a) - 1} ++ if there is no such x. if S has SetCategory then - position: (S, %) -> Integer - ++ position(x,a) returns the index i of the first occurrence of - ++ x in a, and \axiom{minIndex(a) - 1} if there is no such x. + position: (S, %) -> Integer + ++ position(x,a) returns the index i of the first occurrence of + ++ x in a, and \axiom{minIndex(a) - 1} if there is no such x. position: (S,%,Integer) -> Integer - ++ position(x,a,n) returns the index i of the first occurrence of - ++ x in \axiom{a} where \axiom{i >= n}, and \axiom{minIndex(a) - 1} + ++ position(x,a,n) returns the index i of the first occurrence of + ++ x in \axiom{a} where \axiom{i >= n}, and \axiom{minIndex(a) - 1} ++ if no such x is found. if S has OrderedSet then OrderedSet merge: (%,%) -> % - ++ merge(u,v) merges u and v in ascending order. - ++ Note: \axiom{merge(u,v) = merge(<=,u,v)}. + ++ merge(u,v) merges u and v in ascending order. + ++ Note that \axiom{merge(u,v) = merge(<=,u,v)}. sort: % -> % - ++ sort(u) returns an u with elements in ascending order. - ++ Note: \axiom{sort(u) = sort(<=,u)}. + ++ sort(u) returns an u with elements in ascending order. + ++ Note that \axiom{sort(u) = sort(<=,u)}. sorted?: % -> Boolean - ++ sorted?(u) tests if the elements of u are in ascending order. + ++ sorted?(u) tests if the elements of u are in ascending order. if % has shallowlyMutable then copyInto_!: (%,%,Integer) -> % - ++ copyInto!(u,v,i) returns aggregate u containing a copy of - ++ v inserted at element i. + ++ copyInto!(u,v,i) returns aggregate u containing a copy of + ++ v inserted at element i. reverse_!: % -> % - ++ reverse!(u) returns u with its elements in reverse order. + ++ reverse!(u) returns u with its elements in reverse order. sort_!: ((S,S)->Boolean,%) -> % - ++ sort!(p,u) returns u with its elements ordered by p. + ++ sort!(p,u) returns u with its elements ordered by p. if S has OrderedSet then sort_!: % -> % - ++ sort!(u) returns u with its elements in ascending order. + ++ sort!(u) returns u with its elements in ascending order. add if S has SetCategory then position(x:S, t:%) == position(x, t, minIndex t) if S has OrderedSet then --- sorted? l == sorted?(_<$S, l) - sorted? l == sorted?((x,y) +-> x < y or x = y, l) +-- sorted? l == sorted?(_<$S, l) + sorted? l == sorted?((x,y) +-> x < y or x = y, l) merge(x, y) == merge(_<$S, x, y) - sort l == sort(_<$S, l) + sort l == sort(_<$S, l) if % has shallowlyMutable then - reverse x == reverse_! copy x + reverse x == reverse_! copy x sort(f, l) == sort_!(f, copy l) if S has OrderedSet then - sort_! l == sort_!(_<$S, l) + sort_! l == sort_!(_<$S, l) @ <>= @@ -18269,6 +18367,7 @@ These exports come from \refto{RetractableTo}(SetCategory): ++ A free abelian monoid on a set S is the monoid of finite sums of ++ the form \spad{reduce(+,[ni * si])} where the si's are in S, and the ni's ++ are in a given abelian monoid. The operation is commutative. + FreeAbelianMonoidCategory(S: SetCategory, E:CancellationAbelianMonoid): _ Category == Join(CancellationAbelianMonoid, RetractableTo S) with "+" : (S, $) -> $ @@ -18428,7 +18527,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{MDAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf nil} \end{itemize} @@ -18518,8 +18617,9 @@ These exports come from \refto{DictionaryOperations}(S:SetCategory): ++ 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. + MultiDictionary(S:SetCategory): Category == DictionaryOperations S with --- count: (S,%) -> NonNegativeInteger ++ multiplicity count +-- count: (S,%) -> NonNegativeInteger ++ multiplicity count insert_!: (S,%,NonNegativeInteger) -> % ++ insert!(x,d,n) destructively inserts n copies of x into dictionary d. -- remove_!: (S,%,NonNegativeInteger) -> % @@ -18530,7 +18630,7 @@ MultiDictionary(S:SetCategory): Category == DictionaryOperations S with ++ in dictionary d. duplicates: % -> List Record(entry:S,count:NonNegativeInteger) ++ duplicates(d) returns a list of values which have duplicates in d --- ++ duplicates(d) returns a list of ++ duplicates iterator +-- ++ duplicates(d) returns a list of ++ duplicates iterator -- to become duplicates: % -> Iterator(D,D) @ @@ -18645,6 +18745,7 @@ These exports come from \refto{AbelianMonoid}(): ++ Description: ++ Ordered sets which are also abelian monoids, such that the addition ++ preserves the ordering. + OrderedAbelianMonoid(): Category == Join(OrderedAbelianSemiGroup, AbelianMonoid) @@ -18787,35 +18888,36 @@ These exports come from \refto{OrderedSet}(): ++ AMS Classifications: ++ Keywords: permutation, symmetric group ++ References: -++ Description: PermutationCategory provides a categorial environment -++ for subgroups of bijections of a set (i.e. permutations) +++ Description: +++ PermutationCategory provides a categorial environment +++ for subgroups of bijections of a set (i.e. permutations) PermutationCategory(S:SetCategory): Category == Group with cycle : List S -> % - ++ cycle(ls) coerces a cycle {\em ls}, 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. + ++ cycle(ls) coerces a cycle ls, i.e. a list with not + ++ repetitions to a permutation, which maps ls.i to + ++ ls.i+1, indices modulo the length of the list. ++ Error: if repetitions occur. cycles : List List S -> % - ++ cycles(lls) coerces a list list of cycles {\em lls} + ++ cycles(lls) coerces a list list of cycles lls ++ to a permutation, each cycle being a list with not ++ repetitions, is coerced to the permutation, which maps - ++ {\em ls.i} to {\em ls.i+1}, indices modulo the length of the list, + ++ ls.i to ls.i+1, indices modulo the length of the list, ++ then these permutations are mutiplied. ++ Error: if repetitions occur in one cycle. eval : (%,S) -> S - ++ eval(p, el) returns the image of {\em el} under the + ++ eval(p, el) returns the image of el under the ++ permutation p. elt : (%,S) -> S - ++ elt(p, el) returns the image of {\em el} under the + ++ elt(p, el) returns the image of el under the ++ permutation p. orbit : (%,S) -> Set S - ++ orbit(p, el) returns the orbit of {\em el} under the + ++ orbit(p, el) returns the orbit of el under the ++ permutation p, i.e. the set which is given by applications of - ++ the powers of p to {\em el}. + ++ the powers of p to el. "<" : (%,%) -> Boolean ++ p < q is an order relation on permutations. - ++ Note: this order is only total if and only if S is totally ordered + ++ Note that this order is only total if and only if S is totally ordered ++ or S is finite. if S has OrderedSet then OrderedSet if S has Finite then OrderedSet @@ -18983,7 +19085,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{STAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \end{itemize} @@ -19149,24 +19251,25 @@ These exports come from \refto{LinearAggregate}(S:Type): ++ structures such power series can be built. A stream aggregate may ++ also be infinite since it may be cyclic. ++ For example, see \spadtype{DecimalExpansion}. + StreamAggregate(S:Type): Category == Join(UnaryRecursiveAggregate S, LinearAggregate S) with explicitlyFinite?: % -> Boolean - ++ explicitlyFinite?(s) tests if the stream has a finite - ++ number of elements, and false otherwise. - ++ Note: for many datatypes, + ++ explicitlyFinite?(s) tests if the stream has a finite + ++ number of elements, and false otherwise. + ++ Note that for many datatypes, ++ \axiom{explicitlyFinite?(s) = not possiblyInfinite?(s)}. possiblyInfinite?: % -> Boolean - ++ possiblyInfinite?(s) tests if the stream s could possibly - ++ have an infinite number of elements. - ++ Note: for many datatypes, + ++ possiblyInfinite?(s) tests if the stream s could possibly + ++ have an infinite number of elements. + ++ Note that for many datatypes, ++ \axiom{possiblyInfinite?(s) = not explictlyFinite?(s)}. add c2: (%, %) -> S explicitlyFinite? x == not cyclic? x possiblyInfinite? x == cyclic? x - first(x, n) == construct [c2(x, x := rest x) for i in 1..n] + first(x, n) == construct [c2(x, x := rest x) for i in 1..n] c2(x, r) == empty? x => error "Index out of range" @@ -19195,8 +19298,8 @@ StreamAggregate(S:Type): Category == map_!(f, l) == y := l while not empty? l repeat - setfirst_!(l, f first l) - l := rest l + setfirst_!(l, f first l) + l := rest l y fill_!(x, s) == @@ -19371,7 +19474,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{TSETCAT}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf \cross{TSETCAT}{finiteAggregate}} is true if it is an aggregate with a finite number of elements. @@ -19510,6 +19613,9 @@ V:OrderedSet, P:RecursivePolynomialCategory(R,E,V)): ++ Also See: ++ AMS Classifications: ++ Keywords: polynomial, multivariate, ordered variables set +++ References : +++ [1] P. AUBRY, D. LAZARD and M. MORENO MAZA "On the Theories +++ of Triangular Sets" Journal of Symbol. Comp. (to appear) ++ Description: ++ The category of triangular sets of multivariate polynomials ++ with coefficients in an integral domain. @@ -19527,11 +19633,7 @@ V:OrderedSet, P:RecursivePolynomialCategory(R,E,V)): ++ \axiom{Q} if the degree of \axiom{P} in the main variable of \axiom{Q} ++ is less than the main degree of \axiom{Q}. ++ A polynomial \axiom{P} is reduced w.r.t a triangular set \axiom{T} -++ if it is reduced w.r.t. every polynomial of \axiom{T}. \newline -++ References : -++ [1] P. AUBRY, D. LAZARD and M. MORENO MAZA "On the Theories -++ of Triangular Sets" Journal of Symbol. Comp. (to appear) -++ Version: 4. +++ if it is reduced w.r.t. every polynomial of \axiom{T}. TriangularSetCategory(R:IntegralDomain,E:OrderedAbelianMonoidSup,_ V:OrderedSet,P:RecursivePolynomialCategory(R,E,V)): @@ -20164,12 +20266,12 @@ These exports come from \refto{AbelianGroup}(): ++ Author: Manuel Bronstein ++ Date Created: 19 May 1993 ++ Date Last Updated: 19 May 1993 +++ Keywords: divisor, algebraic, curve. ++ Description: ++ This category describes finite rational divisors on a curve, that ++ is finite formal sums SUM(n * P) where the n's are integers and the ++ P's are finite rational points on the curve. -++ Keywords: divisor, algebraic, curve. -++ Examples: )r FDIV INPUT + FiniteDivisorCategory(F, UP, UPUP, R): Category == Result where F : Field UP : UnivariatePolynomialCategory F @@ -20333,7 +20435,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{FSAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf \cross{FSAGG}{finiteAggregate}} is true if it is an aggregate with a finite number of elements. @@ -20466,32 +20568,33 @@ These exports come from \refto{SetAggregate}(S:SetCategory): ++ a collection of elements characterized by membership, but not ++ by order or multiplicity. ++ See \spadtype{Set} for an example. + FiniteSetAggregate(S:SetCategory): Category == Join(Dictionary S, SetAggregate S) with finiteAggregate cardinality: % -> NonNegativeInteger ++ cardinality(u) returns the number of elements of u. - ++ Note: \axiom{cardinality(u) = #u}. + ++ Note that \axiom{cardinality(u) = #u}. if S has Finite then Finite complement: % -> % - ++ complement(u) returns the complement of the set u, - ++ i.e. the set of all values not in u. + ++ complement(u) returns the complement of the set u, + ++ i.e. the set of all values not in u. universe: () -> % - ++ universe()$D returns the universal set for finite set aggregate D. + ++ universe()$D returns the universal set for finite set aggregate D. if S has OrderedSet then max: % -> S - ++ max(u) returns the largest element of aggregate u. + ++ max(u) returns the largest element of aggregate u. min: % -> S - ++ min(u) returns the smallest element of aggregate u. + ++ min(u) returns the smallest element of aggregate u. add - s < t == #s < #t and s = intersect(s,t) - s = t == #s = #t and empty? difference(s,t) - brace l == construct l - set l == construct l + s < t == #s < #t and s = intersect(s,t) + s = t == #s = #t and empty? difference(s,t) + brace l == construct l + set l == construct l cardinality s == #s - construct l == (s := set(); for x in l repeat insert_!(x,s); s) + construct l == (s := set(); for x in l repeat insert_!(x,s); s) count(x:S, s:%) == (member?(x, s) => 1; 0) subset?(s, t) == #s < #t and _and/[member?(x, t) for x in parts s] @@ -20520,7 +20623,7 @@ FiniteSetAggregate(S:SetCategory): Category == u if S has Finite then - universe() == {index(i::PositiveInteger) for i in 1..size()$S} + universe() == {index(i::PositiveInteger) for i in 1..size()$S} complement s == difference(universe(), s ) size() == 2 ** size()$S index i == @@ -20645,7 +20748,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{KDAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf nil} \end{itemize} @@ -20755,6 +20858,7 @@ and S=Record(key: Key,entry: Entry) ++ Description: ++ A keyed dictionary is a dictionary of key-entry pairs for which there is ++ a unique entry for each key. + KeyedDictionary(Key:SetCategory, Entry:SetCategory): Category == Dictionary Record(key:Key,entry:Entry) with key?: (Key, %) -> Boolean @@ -21097,7 +21201,7 @@ LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with remove: (S -> Boolean,%) -> % ++ remove(f,st) returns a stream consisting of those elements of stream ++ st which do not satisfy the predicate f. - ++ Note: \spad{remove(f,st) = [x for x in st | not f(x)]}. + ++ Note that \spad{remove(f,st) = [x for x in st | not f(x)]}. ++ ++X m:=[i for i in 1..] ++X f(i:PositiveInteger):Boolean == even? i @@ -21106,7 +21210,7 @@ LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with select: (S -> Boolean,%) -> % ++ select(f,st) returns a stream consisting of those elements of stream ++ st satisfying the predicate f. - ++ Note: \spad{select(f,st) = [x for x in st | f(x)]}. + ++ Note that \spad{select(f,st) = [x for x in st | f(x)]}. ++ ++X m:=[i for i in 0..] ++X select(x+->prime? x,m) @@ -21121,7 +21225,7 @@ LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with explicitlyEmpty?: % -> Boolean ++ explicitlyEmpty?(s) returns true if the stream is an ++ (explicitly) empty stream. - ++ Note: this is a null test which will not cause lazy evaluation. + ++ Note that this is a null test which will not cause lazy evaluation. ++ ++X m:=[i for i in 0..] ++X explicitlyEmpty? m @@ -21138,7 +21242,7 @@ LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with ++ lazyEvaluate(s) causes one lazy evaluation of stream s. ++ Caution: the first node must be a lazy evaluation mechanism ++ (satisfies \spad{lazy?(s) = true}) as there is no error check. - ++ Note: a call to this function may + ++ Note that a call to this function may ++ or may not produce an explicit first entry frst: % -> S ++ frst(s) returns the first element of stream s. @@ -21717,10 +21821,11 @@ These exports come from \refto{AbelianGroup}(): ++ This is an abelian group which supports left multiplation by elements of ++ the rng. ++ -++ Axioms: -++ \spad{ (a*b)*x = a*(b*x) } -++ \spad{ (a+b)*x = (a*x)+(b*x) } -++ \spad{ a*(x+y) = (a*x)+(a*y) } +++ Axioms\br +++ \tab{5}\spad{ (a*b)*x = a*(b*x) }\br +++ \tab{5}\spad{ (a+b)*x = (a*x)+(b*x) }\br +++ \tab{5}\spad{ a*(x+y) = (a*x)+(a*y) } + LeftModule(R:Rng):Category == AbelianGroup with "*": (R,%) -> % ++ r*x returns the left multiplication of the module element x @@ -21890,7 +21995,7 @@ digraph pic { is true if it is an aggregate with a finite number of elements. \item {\bf \cross{LSAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf nil} \end{itemize} @@ -22088,22 +22193,23 @@ These exports come from \refto{ExtensibleLinearAggregate}(S:Type): ++ A linked list is a versatile ++ data structure. Insertion and deletion are efficient and ++ searching is a linear operation. + ListAggregate(S:Type): Category == Join(StreamAggregate S, FiniteLinearAggregate S, ExtensibleLinearAggregate S) with list: S -> % - ++ list(x) returns the list of one element x. + ++ list(x) returns the list of one element x. add cycleMax ==> 1000 mergeSort: ((S, S) -> Boolean, %, Integer) -> % - sort_!(f, l) == mergeSort(f, l, #l) - list x == concat(x, empty()) - reduce(f, x) == + sort_!(f, l) == mergeSort(f, l, #l) + list x == concat(x, empty()) + reduce(f, x) == empty? x => _ error "reducing over an empty list needs the 3 argument form" reduce(f, rest x, first x) - merge(f, p, q) == merge_!(f, copy p, copy q) + merge(f, p, q) == merge_!(f, copy p, copy q) select_!(f, x) == while not empty? x and not f first x repeat x := rest x @@ -22112,7 +22218,7 @@ ListAggregate(S:Type): Category == Join(StreamAggregate S, z := rest y while not empty? z repeat if f first z then (y := z; z := rest z) - else (z := rest z; setrest_!(y, z)) + else (z := rest z; setrest_!(y, z)) x merge_!(f, p, q) == @@ -22124,8 +22230,8 @@ ListAggregate(S:Type): Category == Join(StreamAggregate S, else (r := t := q; q := rest q) while not empty? p and not empty? q repeat if f(first p, first q) - then (setrest_!(t, p); t := p; p := rest p) - else (setrest_!(t, q); t := q; q := rest q) + then (setrest_!(t, p); t := p; p := rest p) + else (setrest_!(t, q); t := q; q := rest q) setrest_!(t, if empty? p then q else p) r @@ -22153,7 +22259,7 @@ ListAggregate(S:Type): Category == Join(StreamAggregate S, q := rest x while not empty? q repeat if f first q then q := setrest_!(p, rest q) - else (p := q; q := rest q) + else (p := q; q := rest q) x delete_!(x:%, i:Integer) == @@ -22207,11 +22313,11 @@ ListAggregate(S:Type): Category == Join(StreamAggregate S, if S has SetCategory then reduce(f, x, i,a) == - r := i - while not empty? x and r ^= a repeat - r := f(r, first x) - x := rest x - r + r := i + while not empty? x and r ^= a repeat + r := f(r, first x) + x := rest x + r new(n, s) == l := empty() @@ -22234,9 +22340,9 @@ ListAggregate(S:Type): Category == Join(StreamAggregate S, -- y := rest y -- z := reverseInPlace z -- if not empty? x then --- z := concat_!(z, map(f(#1, d), x)) +-- z := concat_!(z, map(f(#1, d), x)) -- if not empty? y then --- z := concat_!(z, map(f(d, #1), y)) +-- z := concat_!(z, map(f(d, #1), y)) -- z reverse_! x == @@ -22272,24 +22378,24 @@ ListAggregate(S:Type): Category == Join(StreamAggregate S, s < (m := minIndex x) => error "index out of range" x := rest(x, (s - m)::NonNegativeInteger) for k in s.. while not empty? x and w ^= first x repeat - x := rest x + x := rest x empty? x => minIndex x - 1 k removeDuplicates_! l == p := l while not empty? p repeat - p := setrest_!(p, remove_!((x:S):Boolean +-> x = first p, rest p)) + p := setrest_!(p, remove_!((x:S):Boolean +-> x = first p, rest p)) l if S has OrderedSet then x < y == - while not empty? x and not empty? y repeat - first x ^= first y => return(first x < first y) - x := rest x - y := rest y - empty? x => not empty? y - false + while not empty? x and not empty? y repeat + first x ^= first y => return(first x < first y) + x := rest x + y := rest y + empty? x => not empty? y + false @ <>= @@ -22412,7 +22518,7 @@ is true if a set with $<$ which is transitive, but not($a < b$ or $a = b$) does not necessarily imply $b a=0 or b=0 +++ NonAssociativeRng is a basic ring-type structure, not necessarily +++ commutative or associative, and not necessarily with unit.\br +++ Axioms\br +++ \tab{5}x*(y+z) = x*y + x*z\br +++ \tab{5}(x+y)*z = x*z + y*z\br +++ +++ Common Additional Axioms\br +++ \tab{5}noZeroDivisors\tab{5} ab = 0 => a=0 or b=0 + NonAssociativeRng(): Category == Join(AbelianGroup,Monad) with associator: (%,%,%) -> % ++ associator(a,b,c) returns \spad{(a*b)*c-a*(b*c)}. @@ -22789,7 +22898,7 @@ digraph pic { is true if it is an aggregate with a finite number of elements. \item {\bf \cross{A1AGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf nil} \end{itemize} @@ -22933,41 +23042,42 @@ These exports come from \refto{FiniteLinearAggregate}(S:Type): ++ (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. + OneDimensionalArrayAggregate(S:Type): Category == FiniteLinearAggregate S with shallowlyMutable add - parts x == [qelt(x, i) for i in minIndex x .. maxIndex x] + parts x == [qelt(x, i) for i in minIndex x .. maxIndex x] sort_!(f, a) == quickSort(f, a)$FiniteLinearAggregateSort(S, %) any?(f, a) == for i in minIndex a .. maxIndex a repeat - f qelt(a, i) => return true + f qelt(a, i) => return true false every?(f, a) == for i in minIndex a .. maxIndex a repeat - not(f qelt(a, i)) => return false + not(f qelt(a, i)) => return false true position(f:S -> Boolean, a:%) == for i in minIndex a .. maxIndex a repeat - f qelt(a, i) => return i + f qelt(a, i) => return i minIndex(a) - 1 find(f, a) == for i in minIndex a .. maxIndex a repeat - f qelt(a, i) => return qelt(a, i) + f qelt(a, i) => return qelt(a, i) "failed" count(f:S->Boolean, a:%) == n:NonNegativeInteger := 0 for i in minIndex a .. maxIndex a repeat - if f(qelt(a, i)) then n := n+1 + if f(qelt(a, i)) then n := n+1 n map_!(f, a) == for i in minIndex a .. maxIndex a repeat - qsetelt_!(a, i, f qelt(a, i)) + qsetelt_!(a, i, f qelt(a, i)) a setelt(a:%, s:UniversalSegment(Integer), x:S) == @@ -22984,14 +23094,14 @@ OneDimensionalArrayAggregate(S:Type): Category == reduce(f, a, identity) == for k in minIndex a .. maxIndex a repeat - identity := f(identity, qelt(a, k)) + identity := f(identity, qelt(a, k)) identity if S has SetCategory then reduce(f, a, identity,absorber) == - for k in minIndex a .. maxIndex a while identity ^= absorber - repeat identity := f(identity, qelt(a, k)) - identity + for k in minIndex a .. maxIndex a while identity ^= absorber + repeat identity := f(identity, qelt(a, k)) + identity -- this is necessary since new has disappeared. stupidnew: (NonNegativeInteger, %, %) -> % @@ -23003,7 +23113,7 @@ OneDimensionalArrayAggregate(S:Type): Category == -- at least one element of l must be non-empty stupidget l == for a in l repeat - not empty? a => return first a + not empty? a => return first a error "Should not happen" map(f, a, b) == @@ -23012,7 +23122,7 @@ OneDimensionalArrayAggregate(S:Type): Category == l := max(0, n - m + 1)::NonNegativeInteger c := stupidnew(l, a, b) for i in minIndex(c).. for j in m..n repeat - qsetelt_!(c, i, f(qelt(a, j), qelt(b, j))) + qsetelt_!(c, i, f(qelt(a, j), qelt(b, j))) c -- map(f, a, b, x) == @@ -23021,7 +23131,7 @@ OneDimensionalArrayAggregate(S:Type): Category == -- l := (n - m + 1)::NonNegativeInteger -- c := new l -- for i in minIndex(c).. for j in m..n repeat --- qsetelt_!(c, i, f(a(j, x), b(j, x))) +-- qsetelt_!(c, i, f(a(j, x), b(j, x))) -- c merge(f, a, b) == @@ -23031,12 +23141,12 @@ OneDimensionalArrayAggregate(S:Type): Category == j := minIndex b n := maxIndex b for k in minIndex(r).. while i <= m and j <= n repeat - if f(qelt(a, i), qelt(b, j)) then - qsetelt_!(r, k, qelt(a, i)) - i := i+1 - else - qsetelt_!(r, k, qelt(b, j)) - j := j+1 + if f(qelt(a, i), qelt(b, j)) then + qsetelt_!(r, k, qelt(a, i)) + i := i+1 + else + qsetelt_!(r, k, qelt(b, j)) + j := j+1 for k in k.. for i in i..m repeat qsetelt_!(r, k, elt(a, i)) for k in k.. for j in j..n repeat qsetelt_!(r, k, elt(b, j)) r @@ -23047,7 +23157,7 @@ OneDimensionalArrayAggregate(S:Type): Category == l < minIndex a or h > maxIndex a => error "index out of range" r := stupidnew(max(0, h - l + 1)::NonNegativeInteger, a, a) for k in minIndex r.. for i in l..h repeat - qsetelt_!(r, k, qelt(a, i)) + qsetelt_!(r, k, qelt(a, i)) r insert(a:%, b:%, i:Integer) == @@ -23056,23 +23166,23 @@ OneDimensionalArrayAggregate(S:Type): Category == i < m or i > n => error "index out of range" y := stupidnew(#a + #b, a, b) for k in minIndex y.. for j in m..i-1 repeat - qsetelt_!(y, k, qelt(b, j)) + qsetelt_!(y, k, qelt(b, j)) for k in k.. for j in minIndex a .. maxIndex a repeat - qsetelt_!(y, k, qelt(a, j)) + qsetelt_!(y, k, qelt(a, j)) for k in k.. for j in i..n repeat qsetelt_!(y, k, qelt(b, j)) y copy x == y := stupidnew(#x, x, x) for i in minIndex x .. maxIndex x for j in minIndex y .. repeat - qsetelt_!(y, j, qelt(x, i)) + qsetelt_!(y, j, qelt(x, i)) y copyInto_!(y, x, s) == s < minIndex y or s + #x > maxIndex y + 1 => - error "index out of range" + error "index out of range" for i in minIndex x .. maxIndex x for j in s.. repeat - qsetelt_!(y, j, qelt(x, i)) + qsetelt_!(y, j, qelt(x, i)) y construct l == @@ -23088,18 +23198,18 @@ OneDimensionalArrayAggregate(S:Type): Category == h < l => copy a r := stupidnew((#a - h + l - 1)::NonNegativeInteger, a, a) for k in minIndex(r).. for i in minIndex a..l-1 repeat - qsetelt_!(r, k, qelt(a, i)) + qsetelt_!(r, k, qelt(a, i)) for k in k.. for i in h+1 .. maxIndex a repeat - qsetelt_!(r, k, qelt(a, i)) + qsetelt_!(r, k, qelt(a, i)) r delete(x:%, i:Integer) == i < minIndex x or i > maxIndex x => error "index out of range" y := stupidnew((#x - 1)::NonNegativeInteger, x, x) for i in minIndex(y).. for j in minIndex x..i-1 repeat - qsetelt_!(y, i, qelt(x, j)) + qsetelt_!(y, i, qelt(x, j)) for i in i .. for j in i+1 .. maxIndex x repeat - qsetelt_!(y, i, qelt(x, j)) + qsetelt_!(y, i, qelt(x, j)) y reverse_! x == @@ -23113,13 +23223,13 @@ OneDimensionalArrayAggregate(S:Type): Category == n := _+/[#a for a in l] i := minIndex(r := new(n, stupidget l)) for a in l repeat - copyInto_!(r, a, i) - i := i + #a + copyInto_!(r, a, i) + i := i + #a r sorted?(f, a) == for i in minIndex(a)..maxIndex(a)-1 repeat - not f(qelt(a, i), qelt(a, i + 1)) => return false + not f(qelt(a, i), qelt(a, i + 1)) => return false true concat(x:%, y:%) == @@ -23130,28 +23240,28 @@ OneDimensionalArrayAggregate(S:Type): Category == if S has SetCategory then x = y == - #x ^= #y => false - for i in minIndex x .. maxIndex x repeat - not(qelt(x, i) = qelt(y, i)) => return false - true + #x ^= #y => false + for i in minIndex x .. maxIndex x repeat + not(qelt(x, i) = qelt(y, i)) => return false + true coerce(r:%):OutputForm == - bracket commaSeparate - [qelt(r, k)::OutputForm for k in minIndex r .. maxIndex r] + bracket commaSeparate + [qelt(r, k)::OutputForm for k in minIndex r .. maxIndex r] position(x:S, t:%, s:Integer) == - n := maxIndex t - s < minIndex t or s > n => error "index out of range" - for k in s..n repeat - qelt(t, k) = x => return k - minIndex(t) - 1 + n := maxIndex t + s < minIndex t or s > n => error "index out of range" + for k in s..n repeat + qelt(t, k) = x => return k + minIndex(t) - 1 if S has OrderedSet then a < b == - for i in minIndex a .. maxIndex a - for j in minIndex b .. maxIndex b repeat - qelt(a, i) ^= qelt(b, j) => return a.i < b.j - #a < #b + for i in minIndex a .. maxIndex a + for j in minIndex b .. maxIndex b repeat + qelt(a, i) ^= qelt(b, j) => return a.i < b.j + #a < #b @ @@ -23273,6 +23383,7 @@ These exports come from \refto{CancellationAbelianMonoid}(): ++ Description: ++ Ordered sets which are also abelian cancellation monoids, ++ such that the addition preserves the ordering. + OrderedCancellationAbelianMonoid(): Category == Join(OrderedAbelianMonoid, CancellationAbelianMonoid) @@ -23430,7 +23541,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{RSETCAT}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf \cross{RSETCAT}{finiteAggregate}} is true if it is an aggregate with a finite number of elements. @@ -23592,6 +23703,15 @@ P:RecursivePolynomialCategory(R,E,V)): ++ Also See: essai Graphisme ++ AMS Classifications: ++ Keywords: polynomial, multivariate, ordered variables set +++ References : +++ [1] M. KALKBRENER "Three contributions to elimination theory" +++ Phd Thesis, University of Linz, Austria, 1991. +++ [2] M. KALKBRENER "Algorithmic properties of polynomial rings" +++ Journal of Symbol. Comp. 1998 +++ [3] P. AUBRY, D. LAZARD and M. MORENO MAZA "On the Theories +++ of Triangular Sets" Journal of Symbol. Comp. (to appear) +++ [4] M. MORENO MAZA "A new algorithm for computing triangular +++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. ++ Description: ++ The category of regular triangular sets, introduced under ++ the name regular chains in [1] (and other papers). @@ -23629,18 +23749,8 @@ P:RecursivePolynomialCategory(R,E,V)): ++ 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 -++ References : -++ [1] M. KALKBRENER "Three contributions to elimination theory" -++ Phd Thesis, University of Linz, Austria, 1991. -++ [2] M. KALKBRENER "Algorithmic properties of polynomial rings" -++ Journal of Symbol. Comp. 1998 -++ [3] P. AUBRY, D. LAZARD and M. MORENO MAZA "On the Theories -++ of Triangular Sets" Journal of Symbol. Comp. (to appear) -++ [4] M. MORENO MAZA "A new algorithm for computing triangular -++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. -++ Version: 2 +++ See the example illustrating the RegularTriangularSet constructor for more +++ explanations about decompositions by means of regular triangular sets. RegularTriangularSetCategory(R:GcdDomain, E:OrderedAbelianMonoidSup,_ V:OrderedSet,P:RecursivePolynomialCategory(R,E,V)): @@ -23660,9 +23770,9 @@ RegularTriangularSetCategory(R:GcdDomain, E:OrderedAbelianMonoidSup,_ ++ \spad{purelyAlgebraic?(ts)} returns true iff for every algebraic ++ variable \spad{v} of \spad{ts} we have ++ \spad{algebraicCoefficients?(t_v,ts_v_-)} where \spad{ts_v} - ++ is \axiomOpFrom{select}{TriangularSetCategory}(ts,v) and + ++ is select from TriangularSetCategory(ts,v) and ++ \spad{ts_v_-} is - ++ \axiomOpFrom{collectUnder}{TriangularSetCategory}(ts,v). + ++ collectUnder from TriangularSetCategory(ts,v). purelyAlgebraicLeadingMonomial?: (P, $) -> Boolean ++ \spad{purelyAlgebraicLeadingMonomial?(p,ts)} returns true iff ++ the main variable of any non-constant iterarted initial @@ -24047,10 +24157,11 @@ These exports come from \refto{AbelianGroup}(): ++ with unit). This is an abelian group which supports right ++ multiplication by elements of the rng. ++ -++ Axioms: -++ \spad{ x*(a*b) = (x*a)*b } -++ \spad{ x*(a+b) = (x*a)+(x*b) } -++ \spad{ (x+y)*x = (x*a)+(y*a) } +++ Axioms\br +++ \tab{5}\spad{ x*(a*b) = (x*a)*b }\br +++ \tab{5}\spad{ x*(a+b) = (x*a)+(x*b) }\br +++ \tab{5}\spad{ (x+y)*x = (x*a)+(y*a) } + RightModule(R:Rng):Category == AbelianGroup with "*": (%,R) -> % ++ x*r returns the right multiplication of the module element x @@ -24166,12 +24277,13 @@ These exports come from \refto{SemiGroup}(): ++ necessarily with a 1. This is a combination of an abelian group ++ and a semigroup, with multiplication distributing over addition. ++ -++ Axioms: -++ \spad{ x*(y+z) = x*y + x*z} -++ \spad{ (x+y)*z = x*z + y*z } +++ Axioms\br +++ \tab{5}\spad{ x*(y+z) = x*y + x*z}\br +++ \tab{5}\spad{ (x+y)*z = x*z + y*z } ++ -++ Conditional attributes: -++ \spadnoZeroDivisors\tab{25}\spad{ ab = 0 => a=0 or b=0} +++ Conditional attributes\br +++ \tab{5}noZeroDivisors\tab{5}\spad{ ab = 0 => a=0 or b=0} + Rng(): Category == Join(AbelianGroup,SemiGroup) @ @@ -24306,8 +24418,9 @@ These exports come from \refto{RightModule}(S:Ring): ++ A \spadtype{BiModule} is both a left and right module with respect ++ to potentially different rings. ++ -++ Axiom: -++ \spad{ r*(x*s) = (r*x)*s } +++ Axiom\br +++ \tab{5}\spad{ r*(x*s) = (r*x)*s } + BiModule(R:Ring,S:Ring):Category == Join(LeftModule(R),RightModule(S)) with leftUnitary @@ -24461,7 +24574,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{BTAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf \cross{BTAGG}{finiteAggregate}} is true if it is an aggregate with a finite number of elements. @@ -24623,33 +24736,34 @@ These exports come from \refto{OneDimensionalArrayAggregate}(Boolean): ++ Description: ++ The bit aggregate category models aggregates representing large ++ quantities of Boolean data. + BitAggregate(): Category == Join(OrderedSet, Logic, OneDimensionalArrayAggregate Boolean) with "not": % -> % - ++ not(b) returns the logical {\em not} of bit aggregate + ++ not(b) returns the logical not of bit aggregate ++ \axiom{b}. "^" : % -> % - ++ ^ b returns the logical {\em not} of bit aggregate + ++ ^ b returns the logical not of bit aggregate ++ \axiom{b}. nand : (%, %) -> % - ++ nand(a,b) returns the logical {\em nand} of bit aggregates + ++ nand(a,b) returns the logical nand of bit aggregates ++ \axiom{a} and \axiom{b}. - nor : (%, %) -> % - ++ nor(a,b) returns the logical {\em nor} of bit aggregates + nor : (%, %) -> % + ++ nor(a,b) returns the logical nor of bit aggregates ++ \axiom{a} and \axiom{b}. _and : (%, %) -> % - ++ a and b returns the logical {\em and} of bit aggregates + ++ a and b returns the logical and of bit aggregates ++ \axiom{a} and \axiom{b}. - _or : (%, %) -> % - ++ a or b returns the logical {\em or} of bit aggregates + _or : (%, %) -> % + ++ a or b returns the logical or of bit aggregates ++ \axiom{a} and \axiom{b}. - xor : (%, %) -> % - ++ xor(a,b) returns the logical {\em exclusive-or} of bit aggregates + xor : (%, %) -> % + ++ xor(a,b) returns the logical exclusive-or of bit aggregates ++ \axiom{a} and \axiom{b}. add not v == map(_not, v) - _^ v == map(_not, v) + _^ v == map(_not, v) _~(v) == map(_~, v) _/_\(v, u) == map(_/_\, v, u) _\_/(v, u) == map(_\_/, v, u) @@ -24824,8 +24938,9 @@ These exports come from \refto{MonadWithUnit}(): ++ R.D. Schafer: An Introduction to Nonassociative Algebras ++ Academic Press, New York, 1966 ++ Description: -++ A NonAssociativeRing is a non associative rng which has a unit, -++ the multiplication is not necessarily commutative or associative. +++ A NonAssociativeRing is a non associative rng which has a unit, +++ the multiplication is not necessarily commutative or associative. + NonAssociativeRing(): Category == Join(NonAssociativeRng,MonadWithUnit) with characteristic: -> NonNegativeInteger ++ characteristic() returns the characteristic of the ring. @@ -25000,7 +25115,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{NTSCAT}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf \cross{NTSCAT}{finiteAggregate}} is true if it is an aggregate with a finite number of elements. @@ -25155,15 +25270,6 @@ P:RecursivePolynomialCategory(R,E,V)): ++ Also See: essai Graphisme ++ AMS Classifications: ++ Keywords: polynomial, multivariate, ordered variables set -++ Description: -++ 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 w.r.t. every polynomial in \spad{collectUnder(ts,v)}. -++ A polynomial \spad{p} is said normalized w.r.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 w.r.t. \spad{q}. One of the important -++ features of normalized triangular sets is that they are regular sets.\newline ++ References : ++ [1] D. LAZARD "A new method for solving algebraic systems of ++ positive dimension" Discr. App. Math. 33:147-160,1991 @@ -25175,7 +25281,15 @@ P:RecursivePolynomialCategory(R,E,V)): ++ [4] M. MORENO MAZA "Calculs de pgcd au-dessus des tours ++ d'extensions simples et resolution des systemes d'equations ++ algebriques" These, Universite P.etM. Curie, Paris, 1997. - +++ Description: +++ 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 w.r.t. every polynomial in \spad{collectUnder(ts,v)}. +++ A polynomial \spad{p} is said normalized w.r.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 w.r.t. \spad{q}. One of the important +++ features of normalized triangular sets is that they are regular sets. NormalizedTriangularSetCategory(R:GcdDomain,E:OrderedAbelianMonoidSup,_ V:OrderedSet,P:RecursivePolynomialCategory(R,E,V)): @@ -25319,6 +25433,7 @@ These exports come from \refto{AbelianGroup}(): ++ Description: ++ Ordered sets which are also abelian groups, such that the ++ addition preserves the ordering. + OrderedAbelianGroup(): Category == Join(OrderedCancellationAbelianMonoid, AbelianGroup) @@ -25437,10 +25552,10 @@ These exports come from \refto{OrderedCancellationAbelianMonoid}(): ++ partial order imposed by \spadop{-}, rather than with respect to ++ the total \spad{>} order (since that is "max"). ++ -++ Axioms: -++ \spad{sup(a,b)-a \~~= "failed"} -++ \spad{sup(a,b)-b \~~= "failed"} -++ \spad{x-a \~~= "failed" and x-b \~~= "failed" => x >= sup(a,b)} +++ Axioms\br +++ \tab{5}\spad{sup(a,b)-a \~~= "failed"}\br +++ \tab{5}\spad{sup(a,b)-b \~~= "failed"}\br +++ \tab{5}\spad{x-a \~~= "failed" and x-b \~~= "failed" => x >= sup(a,b)}\br OrderedAbelianMonoidSup(): Category == OrderedCancellationAbelianMonoid with sup: (%,%) -> % @@ -25565,7 +25680,7 @@ is true if a set with $<$ which is transitive, but not($a < b$ or $a = b$) does not necessarily imply $b S ++ smallest entry in the set + -- max: % -> S ++ smallest entry in the set -- duplicates: % -> List Record(entry:S,count:NonNegativeInteger) ++ to become an in order iterator - -- parts: % -> List S ++ in order iterator + -- parts: % -> List S ++ in order iterator min: % -> S - ++ min(u) returns the smallest entry in the multiset aggregate u. + ++ min(u) returns the smallest entry in the multiset aggregate u. @ <>= @@ -25859,6 +25975,7 @@ These exports come from \refto{Monoid}(): ++ Description: ++ The category of rings with unity, always associative, but ++ not necessarily commutative. + Ring(): Category == Join(Rng,Monoid,LeftModule(%)) with characteristic: () -> NonNegativeInteger ++ characteristic() returns the characteristic of the ring @@ -25872,7 +25989,7 @@ Ring(): Category == Join(Rng,Monoid,LeftModule(%)) with unitsKnown ++ recip truly yields ++ reciprocal or "failed" if not a unit. - ++ Note: \spad{recip(0) = "failed"}. + ++ Note that \spad{recip(0) = "failed"}. add n:Integer coerce(n) == n * 1$% @@ -26040,7 +26157,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{SFRTCAT}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf \cross{SFRTCAT}{finiteAggregate}} is true if it is an aggregate with a finite number of elements. @@ -26195,15 +26312,6 @@ P:RecursivePolynomialCategory(R,E,V)): ++ Also See: essai Graphisme ++ AMS Classifications: ++ Keywords: polynomial, multivariate, ordered variables set -++ Description: -++ The category of square-free regular triangular sets. -++ A regular triangular set \spad{ts} is square-free if -++ the gcd of any polynomial \spad{p} in \spad{ts} and -++ \spad{differentiate(p,mvar(p))} w.r.t. -++ \axiomOpFrom{collectUnder}{TriangularSetCategory} -++ (ts,\axiomOpFrom{mvar}{RecursivePolynomialCategory}(p)) -++ has degree zero w.r.t. \spad{mvar(p)}. Thus any square-free regular -++ set defines a tower of square-free simple extensions.\newline ++ References : ++ [1] D. LAZARD "A new method for solving algebraic systems of ++ positive dimension" Discr. App. Math. 33:147-160,1991 @@ -26211,6 +26319,14 @@ P:RecursivePolynomialCategory(R,E,V)): ++ Habilitation Thesis, ETZH, Zurich, 1995. ++ [3] M. MORENO MAZA "A new algorithm for computing triangular ++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. +++ Description: +++ The category of square-free regular triangular sets. +++ A regular triangular set \spad{ts} is square-free if +++ the gcd of any polynomial \spad{p} in \spad{ts} and +++ differentiate(p,mvar(p)) w.r.t. collectUnder(ts,mvar(p)) +++ has degree zero w.r.t. \spad{mvar(p)}. Thus any square-free regular +++ set defines a tower of square-free simple extensions. + SquareFreeRegularTriangularSetCategory(R:GcdDomain,E:OrderedAbelianMonoidSup,_ V:OrderedSet,P:RecursivePolynomialCategory(R,E,V)): Category == @@ -26372,7 +26488,7 @@ digraph pic { is true if it is an aggregate with a finite number of elements. \item {\bf \cross{SRAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf nil} \end{itemize} @@ -26554,30 +26670,31 @@ These exports come from \refto{OneDimensionalArrayAggregate}(Character): ++ Description: ++ A string aggregate is a category for strings, that is, ++ one dimensional arrays of characters. + StringAggregate: Category == OneDimensionalArrayAggregate Character with - lowerCase : % -> % + lowerCase : % -> % ++ lowerCase(s) returns the string with all characters in lower case. lowerCase_!: % -> % ++ lowerCase!(s) destructively replaces the alphabetic characters ++ in s by lower case. - upperCase : % -> % + upperCase : % -> % ++ upperCase(s) returns the string with all characters in upper case. upperCase_!: % -> % ++ upperCase!(s) destructively replaces the alphabetic characters ++ in s by upper case characters. - prefix? : (%, %) -> Boolean + prefix? : (%, %) -> Boolean ++ prefix?(s,t) tests if the string s is the initial substring of t. - ++ Note: \axiom{prefix?(s,t) == + ++ Note that \axiom{prefix?(s,t) == ++ reduce(and,[s.i = t.i for i in 0..maxIndex s])}. - suffix? : (%, %) -> Boolean + suffix? : (%, %) -> Boolean ++ suffix?(s,t) tests if the string s is the final substring of t. - ++ Note: \axiom{suffix?(s,t) == + ++ Note that \axiom{suffix?(s,t) == ++ reduce(and,[s.i = t.(n - m + i) for i in 0..maxIndex s])} ++ where m and n denote the maxIndex of s and t respectively. substring?: (%, %, Integer) -> Boolean ++ substring?(s,t,i) tests if s is a substring of t beginning at ++ index i. - ++ Note: \axiom{substring?(s,t,0) = prefix?(s,t)}. + ++ Note that \axiom{substring?(s,t,0) = prefix?(s,t)}. match: (%, %, Character) -> NonNegativeInteger ++ match(p,s,wc) tests if pattern \axiom{p} matches subject \axiom{s} ++ where \axiom{wc} is a wild card character. If no match occurs, @@ -26591,16 +26708,16 @@ StringAggregate: Category == OneDimensionalArrayAggregate Character with ++ match?(s,t,c) tests if s matches t except perhaps for ++ multiple and consecutive occurrences of character c. ++ Typically c is the blank character. - replace : (%, UniversalSegment(Integer), %) -> % + replace : (%, UniversalSegment(Integer), %) -> % ++ replace(s,i..j,t) replaces the substring \axiom{s(i..j)} ++ of s by string t. - position : (%, %, Integer) -> Integer + position : (%, %, Integer) -> Integer ++ position(s,t,i) returns the position j of the substring s in ++ string t, where \axiom{j >= i} is required. - position : (CharacterClass, %, Integer) -> Integer + position : (CharacterClass, %, Integer) -> Integer ++ position(cc,t,i) returns the position \axiom{j >= i} in t of ++ the first character belonging to cc. - coerce : Character -> % + coerce : Character -> % ++ coerce(c) returns c as a string s with the character c. split: (%, Character) -> List % ++ split(s,c) returns a list of substrings delimited by character c. @@ -26638,13 +26755,13 @@ StringAggregate: Category == OneDimensionalArrayAggregate Character with ++ allow juxtaposition of strings to work as concatenation. ++ For example, \axiom{"smoo" "shed"} returns \axiom{"smooshed"}. add - trim(s: %, c: Character) == leftTrim(rightTrim(s, c), c) + trim(s: %, c: Character) == leftTrim(rightTrim(s, c), c) trim(s: %, cc: CharacterClass) == leftTrim(rightTrim(s, cc), cc) - lowerCase s == lowerCase_! copy s - upperCase s == upperCase_! copy s - prefix?(s, t) == substring?(s, t, minIndex t) + lowerCase s == lowerCase_! copy s + upperCase s == upperCase_! copy s + prefix?(s, t) == substring?(s, t, minIndex t) coerce(c:Character):% == new(1, c) - elt(s:%, t:%): % == concat(s,t)$% + elt(s:%, t:%): % == concat(s,t)$% @ <>= @@ -26762,7 +26879,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{TBAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf nil} \end{itemize} @@ -26953,9 +27070,10 @@ and RecKE=Record(key: Key,entry: Entry): ++ Description: ++ A table aggregate is a model of a table, i.e. a discrete many-to-one ++ mapping from keys to entries. + TableAggregate(Key:SetCategory, Entry:SetCategory): Category == Join(KeyedDictionary(Key,Entry),IndexedAggregate(Key,Entry)) with - setelt: (%,Key,Entry) -> Entry -- setelt_! later + setelt: (%,Key,Entry) -> Entry -- setelt_! later ++ setelt(t,k,e) (also written \axiom{t.k := e}) is equivalent ++ to \axiom{(insert([k,e],t); e)}. table: () -> % @@ -26973,16 +27091,16 @@ TableAggregate(Key:SetCategory, Entry:SetCategory): Category == ++ elements fn(x,y) where x and y are corresponding elements from t1 ++ and t2 respectively. add - table() == empty() - table l == dictionary l --- empty() == dictionary() + table() == empty() + table l == dictionary l +-- empty() == dictionary() insert_!(p, t) == (t(p.key) := p.entry; t) - indices t == keys t + indices t == keys t coerce(t:%):OutputForm == prefix("table"::OutputForm, - [k::OutputForm = (t.k)::OutputForm for k in keys t]) + [k::OutputForm = (t.k)::OutputForm for k in keys t]) elt(t, k) == (r := search(k, t)) case Entry => r::Entry @@ -27017,23 +27135,23 @@ TableAggregate(Key:SetCategory, Entry:SetCategory): Category == eq?(s,t) => true #s ^= #t => false for k in keys s repeat - (e := search(k, t)) _ + (e := search(k, t)) _ case "failed" or (e::Entry) ^= s.k => return false true map(f: Record(key:Key,entry:Entry)->Record(key:Key,entry:Entry),t:%):%== z := table() for k in keys t repeat - ke: Record(key:Key,entry:Entry) := f [k, t.k] - z ke.key := ke.entry + ke: Record(key:Key,entry:Entry) := f [k, t.k] + z ke.key := ke.entry z map_!(f:Record(key:Key,entry:Entry)->Record(key:Key,entry:Entry),t:%):%_ == lke: List Record(key:Key,entry:Entry) := nil() for k in keys t repeat - lke := cons(f [k, remove_!(k,t)::Entry], lke) + lke := cons(f [k, remove_!(k,t)::Entry], lke) for ke in lke repeat - t ke.key := ke.entry + t ke.key := ke.entry t inspect(t: %): Record(key:Key,entry:Entry) == @@ -27224,7 +27342,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{VECTCAT}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf \cross{VECTCAT}{finiteAggregate}} is true if it is an aggregate with a finite number of elements. @@ -27602,7 +27720,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{ALAGG}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf \cross{ALAGG}{finiteAggregate}} is true if it is an aggregate with a finite number of elements. @@ -27925,14 +28043,15 @@ and RecKE=Record(key: Key,entry: Entry) ++ References: ++ Description: ++ 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: +++ as a table. It is a poor mans version of a table: ++ searching for a key is a linear operation. + AssociationListAggregate(Key:SetCategory,Entry:SetCategory): Category == Join(TableAggregate(Key, Entry), _ ListAggregate Record(key:Key,entry:Entry)) with assoc: (Key, %) -> Union(Record(key:Key,entry:Entry), "failed") - ++ assoc(k,u) returns the element x in association list u stored - ++ with key k, or "failed" if u has no key k. + ++ assoc(k,u) returns the element x in association list u stored + ++ with key k, or "failed" if u has no key k. @ <>= @@ -28080,6 +28199,7 @@ These exports come from \refto{Ring}(): ++ References: ++ Description: ++ Rings of Characteristic Non Zero + CharacteristicNonZero():Category == Ring with charthRoot: % -> Union(%,"failed") ++ charthRoot(x) returns the pth root of x @@ -28227,6 +28347,7 @@ These exports come from \refto{Ring}(): ++ References: ++ Description: ++ Rings of Characteristic Zero. + CharacteristicZero():Category == Ring @ @@ -28381,8 +28502,9 @@ These exports come from \refto{Ring}(): ++ References: ++ Description: ++ The category of commutative rings with unity, i.e. rings where -++ \spadop{*} is commutative, and which have a multiplicative identity. +++ \spadop{*} is commutative, and which have a multiplicative identity ++ element. + --CommutativeRing():Category == Join(Ring,BiModule(%:Ring,%:Ring)) with CommutativeRing():Category == Join(Ring,BiModule(%,%)) with commutative("*") ++ multiplication is commutative. @@ -28554,9 +28676,9 @@ These exports come from \refto{Ring}(): ++ An ordinary differential ring, that is, a ring with an operation ++ \spadfun{differentiate}. ++ -++ Axioms: -++ \spad{differentiate(x+y) = differentiate(x)+differentiate(y)} -++ \spad{differentiate(x*y) = x*differentiate(y) + differentiate(x)*y} +++ Axioms\br +++ \tab{5}\spad{differentiate(x+y) = differentiate(x)+differentiate(y)}\br +++ \tab{5}\spad{differentiate(x*y) = x*differentiate(y) + differentiate(x)*y} DifferentialRing(): Category == Ring with differentiate: % -> % @@ -28724,9 +28846,10 @@ These exports come from \refto{Ring}(): ++ Entire Rings (non-commutative Integral Domains), i.e. a ring ++ not necessarily commutative which has no zero divisors. ++ -++ Axioms: -++ \spad{ab=0 => a=0 or b=0} -- known as noZeroDivisors -++ \spad{not(1=0)} +++ Axioms\br +++ \tab{5}\spad{ab=0 => a=0 or b=0} -- known as noZeroDivisors\br +++ \tab{5}\spad{not(1=0)} + --EntireRing():Category == Join(Ring,BiModule(%:Ring,%:Ring)) with EntireRing():Category == Join(Ring,BiModule(%,%)) with noZeroDivisors ++ if a product is zero then one of the factors @@ -28900,17 +29023,16 @@ These exports come from \refto{RetractableTo}(Basis:SetCategory): ++ Keywords: ++ References: ++ Description: -++ 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{FreeModuleCat} -++ category constructor. -++ Author: Michel Petitot (petitot@lifl.fr) +++ 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{FreeModuleCat} +++ category constructor. FreeModuleCat(R, Basis):Category == Exports where R: Ring @@ -29094,12 +29216,13 @@ These exports come from \refto{LeftModule}(R:Type): )abbrev category LALG LeftAlgebra ++ Author: Larry A. Lambe ++ Date : 03/01/89; revised 03/17/89; revised 12/02/90. -++ Description: The category of all left algebras over an arbitrary -++ ring. +++ Description: +++ The category of all left algebras over an arbitrary ring. + LeftAlgebra(R:Ring): Category == Join(Ring, LeftModule R) with coerce: R -> % - ++ coerce(r) returns r * 1 where 1 is the identity of the - ++ left algebra. + ++ coerce(r) returns r * 1 where 1 is the identity of the + ++ left algebra. add coerce(x:R):% == x * 1$% @@ -29241,6 +29364,7 @@ These exports come from \refto{Ring}(): ++ References: ++ Description: ++ An extension ring with an explicit linear dependence test. + LinearlyExplicitRingOver(R:Ring): Category == Ring with reducedSystem: Matrix % -> Matrix R ++ reducedSystem(A) returns a matrix B such that \spad{A x = 0} @@ -29389,11 +29513,12 @@ These exports come from \refto{BiModule}(a:Ring,b:Ring): ++ Description: ++ The category of modules over a commutative ring. ++ -++ Axioms: -++ \spad{1*x = x} -++ \spad{(a*b)*x = a*(b*x)} -++ \spad{(a+b)*x = (a*x)+(b*x)} -++ \spad{a*(x+y) = (a*x)+(a*y)} +++ Axioms\br +++ \tab{5}\spad{1*x = x}\br +++ \tab{5}\spad{(a*b)*x = a*(b*x)}\br +++ \tab{5}\spad{(a+b)*x = (a*x)+(b*x)}\br +++ \tab{5}\spad{a*(x+y) = (a*x)+(a*y)} + Module(R:CommutativeRing): Category == BiModule(R,R) add if not(R is %) then x:%*r:R == r*x @@ -29565,8 +29690,9 @@ These exports come from \refto{Ring}(): ++ Ordered sets which are also rings, that is, domains where the ring ++ operations are compatible with the ordering. ++ -++ Axiom: -++ \spad{0 ab< ac} +++ Axiom\br +++ \tab{5}\spad{0 ab< ac} + OrderedRing(): Category == Join(OrderedAbelianGroup,Ring,Monoid) with positive?: % -> Boolean ++ positive?(x) tests whether x is strictly greater than 0. @@ -29756,9 +29882,9 @@ These exports come from \refto{Ring}(): ++ A partial differential ring with differentiations indexed by a ++ parameter type S. ++ -++ Axioms: -++ \spad{differentiate(x+y,e) = differentiate(x,e)+differentiate(y,e)} -++ \spad{differentiate(x*y,e) = x*differentiate(y,e)+differentiate(x,e)*y} +++ Axioms\br +++ \tab{5}\spad{differentiate(x+y,e)=differentiate(x,e)+differentiate(y,e)}\br +++ \tab{5}\spad{differentiate(x*y,e)=x*differentiate(y,e)+differentiate(x,e)*y} PartialDifferentialRing(S:SetCategory): Category == Ring with differentiate: (%, S) -> % @@ -29960,7 +30086,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{PTCAT}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf \cross{PTCAT}{finiteAggregate}} is true if it is an aggregate with a finite number of elements. @@ -30086,7 +30212,8 @@ These exports come from \refto{VectorCategory}(R:Ring): ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: PointCategory is the category of points in space which +++ Description: +++ 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. @@ -30103,7 +30230,7 @@ PointCategory(R:Ring) : Category == VectorCategory(R) with ++ cross(p,q) computes the cross product of the two points \spad{p} ++ and \spad{q}. Error if the p and q are not 3 dimensional extend : (%,List R) -> % - ++ extend(x,l,r) \undocumented + ++ extend(x,l,r) \undocumented @ <>= @@ -30334,10 +30461,10 @@ These exports come from \refto{HomogeneousAggregate}(Ring)" ++ Examples: ++ References: ++ Description: -++ \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 R-modules and will be -++ non-mutable. +++ \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 R-modules and will be non-mutable. + RectangularMatrixCategory(m,n,R,Row,Col): Category == Definition where m,n : NonNegativeInteger R : Ring @@ -30407,8 +30534,8 @@ RectangularMatrixCategory(m,n,R,Row,Col): Category == Definition where qelt: (%,Integer,Integer) -> R ++ \spad{qelt(m,i,j)} returns the element in the \spad{i}th row and ++ \spad{j}th column of - ++ the matrix m. Note: there is NO error check to determine if indices - ++ are in the proper ranges. + ++ the matrix m. Note that there is NO error check to determine + ++ if indices are in the proper ranges. elt: (%,Integer,Integer,R) -> R ++ \spad{elt(m,i,j,r)} returns the element in the \spad{i}th row and ++ \spad{j}th column of the matrix m, if m has an \spad{i}th row and a @@ -30643,7 +30770,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{SNTSCAT}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf \cross{SNTSCAT}{finiteAggregate}} is true if it is an aggregate with a finite number of elements. @@ -30798,13 +30925,14 @@ P:RecursivePolynomialCategory(R,E,V)): ++ Also See: essai Graphisme ++ AMS Classifications: ++ Keywords: polynomial, multivariate, ordered variables set +++ References : +++ [1] D. LAZARD "A new method for solving algebraic systems of +++ positive dimension" Discr. App. Math. 33:147-160,1991 ++ Description: ++ The category of square-free and normalized triangular sets. ++ Thus, up to the primitivity axiom of [1], these sets are Lazard -++ triangular sets.\newline -++ References : -++ [1] D. LAZARD "A new method for solving algebraic systems of -++ positive dimension" Discr. App. Math. 33:147-160,1991 +++ triangular sets. + SquareFreeNormalizedTriangularSetCategory(R:GcdDomain,_ E:OrderedAbelianMonoidSup,_ V:OrderedSet,_ @@ -30948,7 +31076,7 @@ digraph pic { \begin{itemize} \item {\bf \cross{STRICAT}{shallowlyMutable}} is true if its values have immediate components that are -updateable (mutable). Note: the properties of any component +updateable (mutable). Note that the properties of any component domain are irrevelant to the shallowlyMutable proper. \item {\bf \cross{STRICAT}{finiteAggregate}} is true if it is an aggregate with a finite number of elements. @@ -31356,13 +31484,13 @@ These exports come from \refto{FullyRetractableTo}(R:Ring): ++ Date Created: 19 October 1993 ++ Date Last Updated: 1 February 1994 ++ Description: -++ 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 -++ MonogenicLinearOperator, OppositeMonogenicLinearOperator, and -++ NonCommutativeOperatorDivision -++ developped by Jean Della Dora and Stephen M. Watt. +++ 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 +++ MonogenicLinearOperator, OppositeMonogenicLinearOperator, and +++ NonCommutativeOperatorDivision + UnivariateSkewPolynomialCategory(R:Ring): Category == Join(Ring, BiModule(R, R), FullyRetractableTo R) with degree: $ -> NonNegativeInteger @@ -31787,11 +31915,9 @@ These exports come from \refto{BiModule}(R:Ring,R:Ring): ++ Keywords: ++ References: ++ Description: -++ This is the category of algebras over non-commutative rings. -++ It is used by constructors of non-commutative algebras such as: -++ \spadtype{XPolynomialRing}. -++ \spadtype{XFreeAlgebra} -++ Author: Michel Petitot (petitot@lifl.fr) +++ This is the category of algebras over non-commutative rings. +++ It is used by constructors of non-commutative algebras such as +++ XPolynomialRing and XFreeAlgebra XAlgebra(R: Ring): Category == Join(Ring, BiModule(R,R)) with @@ -31970,12 +32096,13 @@ These exports come from \refto{Module}(R:CommutativeRing): ++ Description: ++ The category of associative algebras (modules which are themselves rings). ++ -++ Axioms: -++ \spad{(b+c)::% = (b::%) + (c::%)} -++ \spad{(b*c)::% = (b::%) * (c::%)} -++ \spad{(1::R)::% = 1::%} -++ \spad{b*x = (b::%)*x} -++ \spad{r*(a*b) = (r*a)*b = a*(r*b)} +++ Axioms\br +++ \tab{5}\spad{(b+c)::% = (b::%) + (c::%)}\br +++ \tab{5}\spad{(b*c)::% = (b::%) * (c::%)}\br +++ \tab{5}\spad{(1::R)::% = 1::%}\br +++ \tab{5}\spad{b*x = (b::%)*x}\br +++ \tab{5}\spad{r*(a*b) = (r*a)*b = a*(r*b)} + Algebra(R:CommutativeRing): Category == Join(Ring, Module R) with coerce: R -> % @@ -32407,6 +32534,7 @@ These exports come from \refto{LinearlyExplicitRingOver}(a:Ring): ++ S is \spadtype{FullyLinearlyExplicitRingOver R} means that S is a ++ \spadtype{LinearlyExplicitRingOver R} and, in addition, if R is a ++ \spadtype{LinearlyExplicitRingOver Integer}, then so is S + FullyLinearlyExplicitRingOver(R:Ring):Category == LinearlyExplicitRingOver R with if (R has LinearlyExplicitRingOver Integer) then @@ -32568,28 +32696,22 @@ These exports come from \refto{Module}(R:Ring): ++ Author: Michel Petitot (petitot@lifl.fr). ++ Date Created: 91 ++ Date Last Updated: 7 Juillet 92 -++ Fix History: compilation v 2.1 le 13 dec 98 -++ Basic Functions: -++ Related Constructors: -++ Also See: -++ AMS Classifications: ++ Keywords: ++ References: ++ Description: ++ The category of Lie Algebras. -++ It is used by the following domains of non-commutative algebra: -++ \axiomType{LiePolynomial} and -++ \axiomType{XPBWPolynomial}. \newline -++ Author : Michel Petitot (petitot@lifl.fr). +++ It is used by the domains of non-commutative algebra, +++ LiePolynomial and XPBWPolynomial. + LieAlgebra(R: CommutativeRing): Category == Module(R) with + construct: ($,$) -> $ + ++ \axiom{construct(x,y)} returns the Lie bracket of \axiom{x} + ++ and \axiom{y}. NullSquare ++ \axiom{NullSquare} means that \axiom{[x,x] = 0} holds. JacobiIdentity ++ \axiom{JacobiIdentity} means that ++ \axiom{[x,[y,z]]+[y,[z,x]]+[z,[x,y]] = 0} holds. - construct: ($,$) -> $ - ++ \axiom{construct(x,y)} returns the Lie bracket of \axiom{x} - ++ and \axiom{y}. if R has Field then "/" : ($,R) -> $ ++ \axiom{x/r} returns the division of \axiom{x} by \axiom{r}. @@ -32824,11 +32946,13 @@ These exports come from \refto{Eltable}(A:Ring,A:Ring): ++ Date Last Updated: 15 April 1994 ++ Keywords: differential operator ++ Description: -++ \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: -++ \spad{(L1 * L2).(f) = L1 L2 f} +++ LinearOrdinaryDifferentialOperatorCategory is the category +++ of differential operators with coefficients in a ring A with a given +++ derivation. +++ +++ Multiplication of operators corresponds to functional composition:\br +++ (L1 * L2).(f) = L1 L2 f + LinearOrdinaryDifferentialOperatorCategory(A:Ring): Category == Join(UnivariateSkewPolynomialCategory A, Eltable(A, A)) with D: () -> % @@ -33061,13 +33185,15 @@ These exports come from \refto{Module}(R:CommutativeRing): ++ AMS Classifications: ++ Keywords: nonassociative algebra ++ Reference: -++ R.D. Schafer: An Introduction to Nonassociative Algebras -++ Academic Press, New York, 1966 +++ R.D. Schafer: An Introduction to Nonassociative Algebras +++ Academic Press, New York, 1966 ++ Description: -++ NonAssociativeAlgebra is the category of non associative algebras -++ (modules which are themselves non associative rngs). -++ Axioms -++ r*(a*b) = (r*a)*b = a*(r*b) +++ NonAssociativeAlgebra is the category of non associative algebras +++ (modules which are themselves non associative rngs).\br +++ +++ Axioms\br +++ \tab{5}r*(a*b) = (r*a)*b = a*(r*b) + NonAssociativeAlgebra(R:CommutativeRing): Category == _ Join(NonAssociativeRng, Module R) with plenaryPower : (%,PositiveInteger) -> % @@ -33435,9 +33561,8 @@ where WORD:OrderedFreeMonoid(OrderedSet)) ++ Keywords: ++ References: ++ Description: -++ This category specifies opeations for polynomials -++ and formal series with non-commutative variables. -++ Author: Michel Petitot (petitot@lifl.fr) +++ This category specifies opeations for polynomials +++ and formal series with non-commutative variables. XFreeAlgebra(vl:OrderedSet,R:Ring):Category == Catdef where WORD ==> OrderedFreeMonoid(vl) -- monoide libre @@ -33940,7 +34065,7 @@ These exports come from \refto{OrderedAbelianMonoidSup}(): ++ Keywords: ++ References: ++ Description: -++ This category represents a finite cartesian product of a given type. +++ This category represents a finite cartesian product of a given type. ++ Many categorical properties are preserved under this construction. DirectProductCategory(dim:NonNegativeInteger, R:Type): Category == @@ -34473,8 +34598,9 @@ These exports come from \refto{NonAssociativeAlgebra}(R:CommutativeRing): ++ R. Wisbauer: Bimodule Structure of Algebra ++ Lecture Notes Univ. Duesseldorf 1991 ++ Description: -++ A FiniteRankNonAssociativeAlgebra is a non associative algebra over -++ a commutative ring R which is a free \spad{R}-module of finite rank. +++ A FiniteRankNonAssociativeAlgebra is a non associative algebra over +++ a commutative ring R which is a free \spad{R}-module of finite rank. + FiniteRankNonAssociativeAlgebra(R:CommutativeRing): Category == NonAssociativeAlgebra R with someBasis : () -> Vector % @@ -34525,14 +34651,14 @@ FiniteRankNonAssociativeAlgebra(R:CommutativeRing): ++ leftDiscriminant([v1,...,vn]) returns the determinant of the ++ \spad{n}-by-\spad{n} matrix whose element at the \spad{i}-th row ++ and \spad{j}-th column is given by the left trace of the product - ++ \spad{vi*vj}. - ++ Note: the same as \spad{determinant(leftTraceMatrix([v1,...,vn]))}. + ++ \spad{vi*vj}. Note that this is the same as + ++ \spad{determinant(leftTraceMatrix([v1,...,vn]))}. rightDiscriminant: Vector % -> R ++ rightDiscriminant([v1,...,vn]) returns the determinant of the ++ \spad{n}-by-\spad{n} matrix whose element at the \spad{i}-th row ++ and \spad{j}-th column is given by the right trace of the product - ++ \spad{vi*vj}. - ++ Note: the same as \spad{determinant(rightTraceMatrix([v1,...,vn]))}. + ++ \spad{vi*vj}. Note that this is the same as + ++ \spad{determinant(rightTraceMatrix([v1,...,vn]))}. leftTraceMatrix: Vector % -> Matrix R ++ leftTraceMatrix([v1,...,vn]) is the \spad{n}-by-\spad{n} matrix ++ whose element at the \spad{i}-th row and \spad{j}-th column is given @@ -34560,7 +34686,7 @@ FiniteRankNonAssociativeAlgebra(R:CommutativeRing): antiCommutative?:()-> Boolean ++ 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 + ++ Note that this implies \spad{a*b + b*a = 0} for all ++ \spad{a} and \spad{b}. associative?:()-> Boolean ++ associative?() tests if multiplication in algebra @@ -34572,23 +34698,23 @@ FiniteRankNonAssociativeAlgebra(R:CommutativeRing): leftAlternative?: ()-> Boolean ++ leftAlternative?() tests if \spad{2*associator(a,a,b) = 0} ++ for all \spad{a}, b in the algebra. - ++ Note: we only can test this; in general we don't know + ++ Note that we only can test this; in general we don't know ++ whether \spad{2*a=0} implies \spad{a=0}. rightAlternative?: ()-> Boolean ++ rightAlternative?() tests if \spad{2*associator(a,b,b) = 0} ++ for all \spad{a}, b in the algebra. - ++ Note: we only can test this; in general we don't know + ++ Note that we only can test this; in general we don't know ++ whether \spad{2*a=0} implies \spad{a=0}. flexible?: ()-> Boolean ++ flexible?() tests if \spad{2*associator(a,b,a) = 0} ++ for all \spad{a}, b in the algebra. - ++ Note: we only can test this; in general we don't know + ++ Note that we only can test this; in general we don't know ++ whether \spad{2*a=0} implies \spad{a=0}. alternative?: ()-> Boolean ++ alternative?() tests if ++ \spad{2*associator(a,a,b) = 0 = 2*associator(a,b,b)} ++ for all \spad{a}, b in the algebra. - ++ Note: we only can test this; in general we don't know + ++ Note that we only can test this; in general we don't know ++ whether \spad{2*a=0} implies \spad{a=0}. powerAssociative?:()-> Boolean ++ powerAssociative?() tests if all subalgebras @@ -34652,13 +34778,13 @@ FiniteRankNonAssociativeAlgebra(R:CommutativeRing): leftMinimalPolynomial : % -> SparseUnivariatePolynomial R ++ leftMinimalPolynomial(a) returns the polynomial determined by the ++ smallest non-trivial linear combination of left powers of - ++ \spad{a}. Note: the polynomial never has a constant term as in + ++ \spad{a}. Note that the polynomial never has a constant term as in ++ general the algebra has no unit. rightMinimalPolynomial : % -> SparseUnivariatePolynomial R ++ rightMinimalPolynomial(a) returns the polynomial determined by the ++ smallest non-trivial linear ++ combination of right powers of \spad{a}. - ++ Note: the polynomial never has a constant term as in general + ++ Note that the polynomial never has a constant term as in general ++ the algebra has no unit. leftUnits:() -> Union(Record(particular: %, basis: List %), "failed") ++ leftUnits() returns the affine space of all left units of the @@ -35284,7 +35410,7 @@ These exports come from \refto{LieAlgebra}(CommutativeRing): ++ 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.fr) +++ \spadtype{XPBWPolynomial}. FreeLieAlgebra(VarSet:OrderedSet, R:CommutativeRing) :Category == _ CatDef where @@ -35524,10 +35650,10 @@ These exports come from \refto{Algebra}(a:IntegralDomain): ++ The category of commutative integral domains, i.e. commutative ++ rings with no zero divisors. ++ -++ Conditional attributes: -++ canonicalUnitNormal\tab{20}the canonical field is the same for -++ all associates canonicalsClosed\tab{20}the product of two -++ canonicals is itself canonical +++ Conditional attributes\br +++ canonicalUnitNormal\tab{5}the canonical field is the same for +++ all associates\br +++ canonicalsClosed\tab{5}the product of two canonicals is itself canonical IntegralDomain(): Category == Join(CommutativeRing, Algebra(%), EntireRing) with @@ -35733,18 +35859,18 @@ These exports come from \refto{Algebra}(R:CommutativeRing): ++ Examples: ++ References: ++ Description: -++ This is the category of linear operator rings with one generator. -++ The generator is not named by the category but can always be -++ constructed as \spad{monomial(1,1)}. +++ This is the category of linear operator rings with one generator. +++ The generator is not named by the category but can always be +++ constructed as \spad{monomial(1,1)}. ++ -++ For convenience, call the generator \spad{G}. -++ Then each value is equal to -++ \spad{sum(a(i)*G**i, i = 0..n)} -++ for some unique \spad{n} and \spad{a(i)} in \spad{R}. +++ For convenience, call the generator \spad{G}. +++ Then each value is equal to +++ \spad{sum(a(i)*G**i, i = 0..n)} +++ for some unique \spad{n} and \spad{a(i)} in \spad{R}. ++ -++ Note that multiplication is not necessarily commutative. -++ In fact, if \spad{a} is in \spad{R}, it is quite normal -++ to have \spad{a*G \^= G*a}. +++ Note that multiplication is not necessarily commutative. +++ In fact, if \spad{a} is in \spad{R}, it is quite normal +++ to have \spad{a*G \^= G*a}. MonogenicLinearOperator(R): Category == Defn where E ==> NonNegativeInteger @@ -36048,11 +36174,10 @@ These exports come from \refto{CharacteristicNonZero}(): ++ Hypercomplex Numbers, Springer Verlag Heidelberg, 1989, ++ ISBN 0-387-96980-2 ++ Description: -++ OctonionCategory gives the categorial frame for the -++ octonions, and eight-dimensional non-associative algebra, -++ doubling the the quaternions in the same way as doubling -++ the Complex numbers to get the quaternions. --- Examples: octonion.input +++ OctonionCategory gives the categorial frame for the +++ octonions, and eight-dimensional non-associative algebra, +++ doubling the the quaternions in the same way as doubling +++ the Complex numbers to get the quaternions. OctonionCategory(R: CommutativeRing): Category == -- we are cheating a little bit, algebras in \Language{} @@ -36564,8 +36689,8 @@ These exports come from \refto{CharacteristicNonZero}(): ++ AMS Classifications: 11R52 ++ Keywords: quaternions, division ring, algebra ++ Description: -++ \spadtype{QuaternionCategory} describes the category of quaternions -++ and implements functions that are not representation specific. +++ \spadtype{QuaternionCategory} describes the category of quaternions +++ and implements functions that are not representation specific. QuaternionCategory(R: CommutativeRing): Category == Join(Algebra R, FullyRetractableTo R, DifferentialExtension R, @@ -36611,7 +36736,7 @@ QuaternionCategory(R: CommutativeRing): Category == rationalIfCan: $ -> Union(Fraction Integer, "failed") ++ rationalIfCan(q) returns \spad{q} as a rational number, ++ or "failed" if this is not possible. - ++ Note: if \spad{rational?(q)} is true, the conversion + ++ Note that if \spad{rational?(q)} is true, the conversion ++ can be done and the rational number will be returned. add @@ -37067,10 +37192,11 @@ These exports come from \refto{FullyLinearlyExplicitRingOver}(R:Ring): ++ Examples: ++ References: ++ Description: -++ \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 colums returned as objects of type Col. +++ \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 colums returned as objects of type Col. + SquareMatrixCategory(ndim,R,Row,Col): Category == Definition where ndim : NonNegativeInteger R : Ring @@ -37465,10 +37591,9 @@ These exports come from \refto{SetCategory}(): ++ Keywords: ++ References: ++ Description: -++ The Category of polynomial rings with non-commutative variables. -++ The coefficient ring may be non-commutative too. -++ However coefficients commute with vaiables. -++ Author: Michel Petitot (petitot@lifl.fr) +++ The Category of polynomial rings with non-commutative variables. +++ The coefficient ring may be non-commutative too. +++ However coefficients commute with vaiables. XPolynomialsCat(vl:OrderedSet,R:Ring):Category == Export where WORD ==> OrderedFreeMonoid(vl) @@ -37736,6 +37861,7 @@ These exports come from \refto{Algebra}(Fraction(Integer)): ++ 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. + AbelianMonoidRing(R:Ring, E:OrderedAbelianMonoid): Category == Join(Ring,BiModule(R,R)) with leadingCoefficient: % -> R @@ -37986,8 +38112,10 @@ These exports come from \refto{RetractableTo}(Integer): ++ Keywords: ++ Examples: ++ References: -++ Description: A category of domains which model machine arithmetic +++ Description: +++ A category of domains which model machine arithmetic ++ used by machines in the AXIOM-NAG link. + FortranMachineTypeCategory():Category == Join(IntegralDomain,OrderedSet, RetractableTo(Integer) ) @@ -38301,10 +38429,11 @@ where R:CommutativeRing: ++ R.D. Schafer: An Introduction to Nonassociative Algebras ++ Academic Press, New York, 1966 ++ Description: -++ FramedNonAssociativeAlgebra(R) is a -++ \spadtype{FiniteRankNonAssociativeAlgebra} (i.e. a non associative -++ algebra over R which is a free \spad{R}-module of finite rank) -++ over a commutative ring R together with a fixed \spad{R}-module basis. +++ FramedNonAssociativeAlgebra(R) is a +++ \spadtype{FiniteRankNonAssociativeAlgebra} (i.e. a non associative +++ algebra over R which is a free \spad{R}-module of finite rank) +++ over a commutative ring R together with a fixed \spad{R}-module basis. + FramedNonAssociativeAlgebra(R:CommutativeRing): Category == FiniteRankNonAssociativeAlgebra(R) with basis: () -> Vector % @@ -38347,7 +38476,7 @@ FramedNonAssociativeAlgebra(R:CommutativeRing): ++ is given by the left trace of the product \spad{vi*vj}, where ++ \spad{v1},...,\spad{vn} are the ++ elements of the fixed \spad{R}-module basis. - ++ Note: the same as \spad{determinant(leftTraceMatrix())}. + ++ Note that the same as \spad{determinant(leftTraceMatrix())}. rightDiscriminant : () -> R ++ rightDiscriminant() returns the determinant of the ++ \spad{n}-by-\spad{n} matrix whose element at the \spad{i}-th row @@ -38355,7 +38484,7 @@ FramedNonAssociativeAlgebra(R:CommutativeRing): ++ given by the right trace of the product \spad{vi*vj}, where ++ \spad{v1},...,\spad{vn} are the elements of ++ the fixed \spad{R}-module basis. - ++ Note: the same as \spad{determinant(rightTraceMatrix())}. + ++ Note that the same as \spad{determinant(rightTraceMatrix())}. leftTraceMatrix : () -> Matrix R ++ leftTraceMatrix() is the \spad{n}-by-\spad{n} ++ matrix whose element at the \spad{i}-th row and \spad{j}-th column @@ -39023,7 +39152,6 @@ These exports come from \refto{OrderedRing}(): ++ Description: ++ The category of ordered commutative integral domains, where ordering ++ and the arithmetic operations are compatible -++ OrderedIntegralDomain(): Category == Join(IntegralDomain, OrderedRing) @@ -39269,9 +39397,9 @@ These exports come from \refto{FullyRetractableTo}(R:Ring): ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: This category is -++ similar to AbelianMonoidRing, except that the sum is assumed to be finite. -++ It is a useful model for polynomials, +++ Description: +++ 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. FiniteAbelianMonoidRing(R:Ring, E:OrderedAbelianMonoid): Category == @@ -39689,18 +39817,19 @@ These exports come from \refto{RetractableTo}(Integer): <>= )abbrev category INTCAT IntervalCategory -+++ Author: Mike Dewar -+++ Date Created: November 1996 -+++ Date Last Updated: -+++ Basic Functions: -+++ Related Constructors: -+++ Also See: -+++ AMS Classifications: -+++ Keywords: -+++ References: -+++ Description: -+++ This category implements of interval arithmetic and transcendental -+++ functions over intervals. +++ Author: Mike Dewar +++ Date Created: November 1996 +++ Date Last Updated: +++ Basic Functions: +++ Related Constructors: +++ Also See: +++ AMS Classifications: +++ Keywords: +++ References: +++ Description: +++ This category implements of interval arithmetic and transcendental +++ functions over intervals. + IntervalCategory(R: Join(FloatingPointSystem,TranscendentalFunctionCategory)): Category == _ Join(GcdDomain, OrderedSet, TranscendentalFunctionCategory, _ @@ -39961,8 +40090,9 @@ where Coef:Ring and Expon:OrderedAbelianMonoid: ++ Examples: ++ References: ++ Description: -++ \spadtype{PowerSeriesCategory} is the most general power series -++ category with exponents in an ordered abelian monoid. +++ \spadtype{PowerSeriesCategory} is the most general power series +++ category with exponents in an ordered abelian monoid. + PowerSeriesCategory(Coef,Expon,Var): Category == Definition where Coef : Ring Expon : OrderedAbelianMonoid @@ -39990,7 +40120,7 @@ PowerSeriesCategory(Coef,Expon,Var): Category == Definition where ++ \spad{pole?(f)} determines if the power series f has a pole. complete: % -> % ++ \spad{complete(f)} causes all terms of f to be computed. - ++ Note: this results in an infinite loop + ++ Note that this results in an infinite loop ++ if f has infinitely many terms. add @@ -40646,9 +40776,9 @@ These exports come from \refto{PrincipalIdealDomain}(): ++ a quotient and a remainder where the remainder is either zero ++ or is smaller (\spadfun{euclideanSize}) than the divisor. ++ -++ Conditional attributes: -++ multiplicativeValuation\tab{25}\spad{Size(a*b)=Size(a)*Size(b)} -++ additiveValuation\tab{25}\spad{Size(a*b)=Size(a)+Size(b)} +++ Conditional attributes\br +++ \tab{5}multiplicativeValuation\tab{5}Size(a*b)=Size(a)*Size(b)\br +++ \tab{5}additiveValuation\tab{11}Size(a*b)=Size(a)+Size(b) EuclideanDomain(): Category == PrincipalIdealDomain with sizeLess?: (%,%) -> Boolean @@ -41088,8 +41218,9 @@ These exports come from \refto{TranscendentalFunctionCategory}(): ++ Examples: ++ References: ++ Description: -++ \spadtype{MultivariateTaylorSeriesCategory} is the most general -++ multivariate Taylor series category. +++ \spadtype{MultivariateTaylorSeriesCategory} is the most general +++ multivariate Taylor series category. + MultivariateTaylorSeriesCategory(Coef,Var): Category == Definition where Coef : Ring Var : OrderedSet @@ -41676,13 +41807,14 @@ These exports come from \refto{PartialDifferentialRing}(Symbol): ++ Examples: ++ References: ++ Description: -++ \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. +++ \spadtype{UnivariatePowerSeriesCategory} is the most general +++ univariate power series category with exponents in an ordered +++ abelian monoid. +++ Note that this category exports a substitution function if it is +++ possible to multiply exponents. +++ Also note that this category exports a derivative operation if it is +++ possible to multiply coefficients by exponents. + UnivariatePowerSeriesCategory(Coef,Expon): Category == Definition where Coef : Ring Expon : OrderedAbelianMonoid @@ -42045,9 +42177,9 @@ These exports come from \refto{DivisionRing}(): ++ where all non-zero elements have multiplicative inverses. ++ The \spadfun{factor} operation while trivial is useful to have defined. ++ -++ Axioms: -++ \spad{a*(b/a) = b} -++ \spad{inv(a) = 1/a} +++ Axioms\br +++ \tab{5}\spad{a*(b/a) = b}\br +++ \tab{5}\spad{inv(a) = 1/a} Field(): Category == Join(EuclideanDomain,UniqueFactorizationDomain, DivisionRing) with @@ -42389,14 +42521,11 @@ These exports come from \refto{LinearlyExplicitRingOver}(Integer): <>= )abbrev category INS IntegerNumberSystem ++ Author: Stephen M. Watt -++ Date Created: -++ January 1988 +++ Date Created: January 1988 ++ Change History: -++ Basic Operations: -++ addmod, base, bit?, copy, dec, even?, hash, inc, invmod, length, mask, -++ positiveRemainder, symmetricRemainder, multiplicativeValuation, mulmod, -++ odd?, powmod, random, rational, rational?, rationalIfCan, shift, submod -++ Description: An \spad{IntegerNumberSystem} is a model for the integers. +++ Description: +++ An \spad{IntegerNumberSystem} is a model for the integers. + IntegerNumberSystem(): Category == Join(UniqueFactorizationDomain, EuclideanDomain, OrderedIntegralDomain, DifferentialRing, ConvertibleTo Integer, RetractableTo Integer, @@ -42787,8 +42916,10 @@ These exports come from \refto{EuclideanDomain}(): ++ Keywords: p-adic, completion ++ Examples: ++ References: -++ Description: This is the category of stream-based representations of -++ the p-adic integers. +++ Description: +++ This is the category of stream-based representations of +++ the p-adic integers. + PAdicIntegerCategory(p): Category == Definition where p : Integer I ==> Integer @@ -43358,7 +43489,7 @@ PolynomialCategory(R:Ring, E:OrderedAbelianMonoidSup, VarSet:OrderedSet): ++ appearing in the polynomial p. primitiveMonomials: % -> List % ++ primitiveMonomials(p) gives the list of monomials of the - ++ polynomial p with their coefficients removed. Note: + ++ polynomial p with their coefficients removed. Note that ++ \spad{primitiveMonomials(sum(a_(i) X^(i))) = [X^(1),...,X^(n)]}. if R has OrderedSet then OrderedSet -- OrderedRing view removed to allow EXPR to define abs @@ -44099,8 +44230,9 @@ These exports come from \refto{RadicalCategory}(): ++ Examples: ++ References: ++ Description: -++ \spadtype{UnivariateTaylorSeriesCategory} is the category of Taylor -++ series in one variable. +++ \spadtype{UnivariateTaylorSeriesCategory} is the category of Taylor +++ series in one variable. + UnivariateTaylorSeriesCategory(Coef): Category == Definition where Coef : Ring I ==> Integer @@ -44856,9 +44988,9 @@ These exports come from \refto{RadicalCategory}(): ++ Author: Manuel Bronstein ++ Date Created: 22 Mar 1988 ++ Date Last Updated: 27 November 1991 -++ Description: -++ Model for algebraically closed fields. ++ Keywords: algebraic, closure, field. +++ Description: +++ Model for algebraically closed fields. AlgebraicallyClosedField(): Category == Join(Field,RadicalCategory) with rootOf: Polynomial $ -> $ @@ -44880,7 +45012,7 @@ AlgebraicallyClosedField(): Category == Join(Field,RadicalCategory) with ++X rootOf(a,x) rootsOf: Polynomial $ -> List $ ++ rootsOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}. - ++ Note: the returned symbols y1,...,yn are bound in the + ++ Note that the returned symbols y1,...,yn are bound in the ++ interpreter to respective root values. ++ Error: if p has more than one variable y. ++ @@ -44888,7 +45020,7 @@ AlgebraicallyClosedField(): Category == Join(Field,RadicalCategory) with ++X rootsOf(a) rootsOf: SparseUnivariatePolynomial $ -> List $ ++ rootsOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}. - ++ Note: the returned symbols y1,...,yn are bound in the interpreter + ++ Note that the returned symbols y1,...,yn are bound in the interpreter ++ to respective root values. ++ ++X a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13 @@ -44896,7 +45028,7 @@ AlgebraicallyClosedField(): Category == Join(Field,RadicalCategory) with rootsOf: (SparseUnivariatePolynomial $, Symbol) -> List $ ++ rootsOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}; ++ The returned roots display as \spad{'y1},...,\spad{'yn}. - ++ Note: the returned symbols y1,...,yn are bound in the interpreter + ++ Note that the returned symbols y1,...,yn are bound in the interpreter ++ to respective root values. ++ ++X a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13 @@ -45489,31 +45621,30 @@ These exports come from \refto{Evalable}(%:DPOLCAT): ++ References:Kolchin, E.R. "Differential Algebra and Algebraic Groups" ++ (Academic Press, 1973). ++ Description: -++ \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}. -++ -++ To construct a domain using this constructor, one needs -++ to provide a ground ring R, an ordered set S of differential -++ indeterminates, a ranking V on the set of derivatives -++ of the differential indeterminates, and a set E of -++ exponents in bijection with the set of differential monomials -++ in the given differential indeterminates. +++ \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}. ++ +++ To construct a domain using this constructor, one needs +++ to provide a ground ring R, an ordered set S of differential +++ indeterminates, a ranking V on the set of derivatives +++ of the differential indeterminates, and a set E of +++ exponents in bijection with the set of differential monomials +++ in the given differential indeterminates. DifferentialPolynomialCategory(R:Ring,S:OrderedSet, V:DifferentialVariableCategory S, E:OrderedAbelianMonoidSup): @@ -45531,7 +45662,7 @@ DifferentialPolynomialCategory(R:Ring,S:OrderedSet, ++ indeterminate, in such a way that the n-th ++ derivative of s may be simply referenced as z.n ++ where z :=makeVariable(s). - ++ Note: In the interpreter, z is + ++ Note that In the interpreter, z is ++ given as an internal map, which may be ignored. -- Example: makeVariable('s); %.5 @@ -45573,7 +45704,7 @@ DifferentialPolynomialCategory(R:Ring,S:OrderedSet, leader: $ -> V ++ leader(p) returns the derivative of the highest rank ++ appearing in the differential polynomial p - ++ Note: an error occurs if p is in the ground ring. + ++ Note that an error occurs if p is in the ground ring. initial:$ -> $ ++ initial(p) returns the ++ leading coefficient when the differential polynomial p @@ -45591,7 +45722,7 @@ DifferentialPolynomialCategory(R:Ring,S:OrderedSet, ++ ring, in such a way that the n-th ++ derivative of p may be simply referenced as z.n ++ where z := makeVariable(p). - ++ Note: In the interpreter, z is + ++ Note that In the interpreter, z is ++ given as an internal map, which may be ignored. -- Example: makeVariable(p); %.5; makeVariable(%**2); %.2 @@ -45974,10 +46105,11 @@ These exports come from \refto{CharacteristicNonZero}(): ++ J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM. ++ AXIOM Technical Report Series, ATR/5 NP2522. ++ Description: -++ FieldOfPrimeCharacteristic is the category of fields of prime -++ characteristic, e.g. finite fields, algebraic closures of -++ fields of prime characteristic, transcendental extensions of -++ of fields of prime characteristic. +++ FieldOfPrimeCharacteristic is the category of fields of prime +++ characteristic, e.g. finite fields, algebraic closures of +++ fields of prime characteristic, transcendental extensions of +++ of fields of prime characteristic. + FieldOfPrimeCharacteristic:Category == _ Join(Field,CharacteristicNonZero) with order: $ -> OnePointCompletion PositiveInteger @@ -46776,10 +46908,10 @@ These exports come from \refto{RetractableTo}(Fraction(Integer)): ++ Author: Manuel Bronstein ++ Date Created: 22 March 1988 ++ Date Last Updated: 14 February 1994 -++ Description: -++ A space of formal functions with arguments in an arbitrary -++ ordered set. ++ Keywords: operator, kernel, function. +++ Description: +++ A space of formal functions with arguments in an arbitrary ordered set. + FunctionSpace(R:OrderedSet): Category == Definition where OP ==> BasicOperator O ==> OutputForm @@ -47921,8 +48053,9 @@ These exports come from \refto{PolynomialFactorizationExplicit}(): ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: QuotientField(S) is the -++ category of fractions of an Integral Domain S. +++ Description: +++ QuotientField(S) is the category of fractions of an Integral Domain S. + QuotientFieldCategory(S: IntegralDomain): Category == Join(Field, Algebra S, RetractableTo S, FullyEvalableOver S, DifferentialExtension S, FullyLinearlyExplicitRingOver S, @@ -48386,6 +48519,7 @@ These exports come from \refto{Algebra}(Integer): ++ Description: ++ \axiomType{RealClosedField} provides common acces ++ functions for all real closed fields. + RealClosedField : Category == PUB where E ==> OutputForm @@ -48803,7 +48937,6 @@ These exports come from \refto{CharacteristicZero}(): ++ Date Created: ++ January 1988 ++ Change History: -++ Basic Operations: abs, ceiling, wholePart, floor, fractionPart, norm, round, truncate ++ Related Constructors: ++ Keywords: real numbers ++ Description: @@ -48812,6 +48945,7 @@ These exports come from \refto{CharacteristicZero}(): ++ we have purposely not included \spadtype{DifferentialRing} or ++ the elementary functions (see \spadtype{TranscendentalFunctionCategory}) ++ in the definition. + RealNumberSystem(): Category == Join(Field, OrderedRing, RealConstant, RetractableTo Integer, RetractableTo Fraction Integer, RadicalCategory, @@ -49416,7 +49550,6 @@ where R:Ring, E:OrderedAbelianMonoidSup, V:OrderedSet: ++ Author: Marc Moreno Maza ++ Date Created: 04/22/1994 ++ Date Last Updated: 14/12/1998 -++ Basic Functions: mvar, mdeg, init, head, tail, prem, lazyPrem ++ Related Constructors: ++ Also See: ++ AMS Classifications: @@ -49763,7 +49896,7 @@ RecursivePolynomialCategory(R:Ring, E:OrderedAbelianMonoidSup, V:OrderedSet):_ next_subResultant2: ($, $, $, $) -> $ ++ \axiom{nextsubResultant2(p,q,z,s)} is the multivariate version ++ of the operation - ++ \axiomOpFrom{next_sousResultant2}{PseudoRemainderSequence} from + ++ next_sousResultant2 from PseudoRemainderSequence from ++ the \axiomType{PseudoRemainderSequence} constructor. if R has GcdDomain @@ -51059,8 +51192,9 @@ These exports come from \refto{Field}(): ++ Examples: ++ References: ++ Description: -++ \spadtype{UnivariateLaurentSeriesCategory} is the category of -++ Laurent series in one variable. +++ \spadtype{UnivariateLaurentSeriesCategory} is the category of +++ Laurent series in one variable. + UnivariateLaurentSeriesCategory(Coef): Category == Definition where Coef : Ring I ==> Integer @@ -51531,8 +51665,9 @@ These exports come from \refto{RadicalCategory}(): ++ Examples: ++ References: ++ Description: -++ \spadtype{UnivariatePuiseuxSeriesCategory} is the category of Puiseux -++ series in one variable. +++ \spadtype{UnivariatePuiseuxSeriesCategory} is the category of Puiseux +++ series in one variable. + UnivariatePuiseuxSeriesCategory(Coef): Category == Definition where Coef : Ring NNI ==> NonNegativeInteger @@ -52181,7 +52316,7 @@ UnivariatePolynomialCategory(R:Ring): Category == ++ unmakeSUP(sup) converts sup of type ++ \spadtype{SparseUnivariatePolynomial(R)} ++ to be a member of the given type. - ++ Note: converse of makeSUP. + ++ Note that converse of makeSUP. multiplyExponents: (%,NonNegativeInteger) -> % ++ multiplyExponents(p,n) returns a new polynomial resulting from ++ multiplying all exponents of the polynomial p by the non negative @@ -53036,9 +53171,10 @@ where R:Join(OrderedSet, IntegralDomain)): ++ Author: Manuel Bronstein ++ Date Created: 31 October 1988 ++ Date Last Updated: 7 October 1991 -++ Description: -++ Model for algebraically closed function spaces. ++ Keywords: algebraic, closure, field. +++ Description: +++ Model for algebraically closed function spaces. + AlgebraicallyClosedFunctionSpace(R:Join(OrderedSet, IntegralDomain)): Category == Join(AlgebraicallyClosedField, FunctionSpace R) with rootOf : $ -> $ @@ -53046,7 +53182,7 @@ AlgebraicallyClosedFunctionSpace(R:Join(OrderedSet, IntegralDomain)): ++ Error: if p has more than one variable y. rootsOf: $ -> List $ ++ rootsOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}; - ++ Note: the returned symbols y1,...,yn are bound in the interpreter + ++ Note that the returned symbols y1,...,yn are bound in the interpreter ++ to respective root values. ++ Error: if p has more than one variable y. rootOf : ($, Symbol) -> $ @@ -53055,7 +53191,7 @@ AlgebraicallyClosedFunctionSpace(R:Join(OrderedSet, IntegralDomain)): rootsOf: ($, Symbol) -> List $ ++ rootsOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}; ++ The returned roots display as \spad{'y1},...,\spad{'yn}. - ++ Note: the returned symbols y1,...,yn are bound in the interpreter + ++ Note that the returned symbols y1,...,yn are bound in the interpreter ++ to respective root values. zeroOf : $ -> $ ++ zeroOf(p) returns y such that \spad{p(y) = 0}. @@ -53422,8 +53558,8 @@ These exports come from \refto{FieldOfPrimeCharacteristic}(): ++ J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM. ++ AXIOM Technical Report Series, ATR/5 NP2522. ++ Description: -++ ExtensionField {\em F} is the category of fields which extend -++ the field F +++ ExtensionField F is the category of fields which extend the field F + ExtensionField(F:Field) : Category == _ Join(Field,RetractableTo F,VectorSpace F) with if F has CharacteristicZero then CharacteristicZero @@ -53754,14 +53890,14 @@ These exports come from \refto{DifferentialRing}(): ++ J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM. ++ AXIOM Technical Report Series, ATR/5 NP2522. ++ Description: -++ FiniteFieldCategory is the category of finite fields +++ FiniteFieldCategory is the category of finite fields FiniteFieldCategory() : Category ==_ Join(FieldOfPrimeCharacteristic,Finite,StepThrough,DifferentialRing) with -- ,PolynomialFactorizationExplicit) with charthRoot: $ -> $ - ++ charthRoot(a) takes the characteristic'th root of {\em a}. - ++ Note: such a root is alway defined in finite fields. + ++ charthRoot(a) takes the characteristic'th root of a. + ++ Note that such a root is alway defined in finite fields. conditionP: Matrix $ -> Union(Vector $,"failed") ++ conditionP(mat), given a matrix representing a homogeneous system ++ of equations, returns a vector whose characteristic'th powers @@ -53803,7 +53939,7 @@ FiniteFieldCategory() : Category ==_ ++ primitive?(b) tests whether the element b is a generator of the ++ (cyclic) multiplicative group of the field, i.e. is a primitive ++ element. - ++ Implementation Note: see ch.IX.1.3, th.2 in D. Lipson. + ++ Implementation Note that see ch.IX.1.3, th.2 in D. Lipson. discreteLog: $ -> NonNegativeInteger ++ discreteLog(a) computes the discrete logarithm of \spad{a} ++ with respect to \spad{primitiveElement()} of the field. @@ -54285,12 +54421,10 @@ These exports come from \refto{RealNumberSystem}(): ++ exactly representable by floating point numbers. ++ A floating point system is characterized by the following: ++ -++ 1: \spadfunFrom{base}{FloatingPointSystem} of the -++ \spadfunFrom{exponent}{FloatingPointSystem}. -++ (actual implemenations are usually binary or decimal) -++ 2: \spadfunFrom{precision}{FloatingPointSystem} of the -++ \spadfunFrom{mantissa}{FloatingPointSystem} (arbitrary or fixed) -++ 3: rounding error for operations +++ 1: base of the exponent where the actual implemenations are +++ usually binary or decimal)\br +++ 2: precision of the mantissa (arbitrary or fixed)\br +++ 3: rounding error for operations --++ 4: when, and what happens if exponent overflow/underflow occurs ++ ++ Because a Float is an approximation to the real numbers, even though @@ -54298,6 +54432,7 @@ These exports come from \refto{RealNumberSystem}(): ++ the attributes do not hold. In particular associative("+") ++ does not hold. Algorithms defined over a field need special ++ considerations when the field is a floating point system. + FloatingPointSystem(): Category == RealNumberSystem() with approximate ++ \spad{approximate} means "is an approximation to the real numbers". @@ -54307,7 +54442,7 @@ FloatingPointSystem(): Category == RealNumberSystem() with ++ float(a,e,b) returns \spad{a * b ** e}. order: % -> Integer ++ order x is the order of magnitude of x. - ++ Note: \spad{base ** order x <= |x| < base ** (1 + order x)}. + ++ Note that \spad{base ** order x <= |x| < base ** (1 + order x)}. base: () -> PositiveInteger ++ base() returns the base of the ++\spadfunFrom{exponent}{FloatingPointSystem}. @@ -55201,11 +55336,12 @@ where UTS:UnivariateLaurentSeriesCategory(Coef:Ring) ++ Examples: ++ References: ++ Description: -++ 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 n is an arbitrary integer and \spad{f(x)} -++ is a Taylor series. This pair represents the Laurent series -++ \spad{x**n * f(x)}. +++ 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 n is an arbitrary integer and \spad{f(x)} +++ is a Taylor series. This pair represents the Laurent series +++ \spad{x**n * f(x)}. + UnivariateLaurentSeriesConstructorCategory(Coef,UTS):_ Category == Definition where Coef: Ring @@ -55231,7 +55367,7 @@ UnivariateLaurentSeriesConstructorCategory(Coef,UTS):_ ++ 'leading zero' is removed from the Laurent series as follows: ++ the series is rewritten by increasing the exponent by 1 and ++ dividing the Taylor series by its variable. - ++ Note: \spad{removeZeroes(f)} removes all leading zeroes from f + ++ Note that \spad{removeZeroes(f)} removes all leading zeroes from f removeZeroes: (I,%) -> % ++ \spad{removeZeroes(n,f(x))} removes up to n leading zeroes from ++ the Laurent series \spad{f(x)}. @@ -55674,11 +55810,12 @@ These exports come from \refto{UnivariatePuiseuxSeriesCategory}(Coef:Ring): ++ Examples: ++ References: ++ Description: -++ 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 r is a positive rational number and -++ \spad{f(x)} is a Laurent series. This pair represents the Puiseux -++ series \spad{f(x^r)}. +++ 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 r is a positive rational number and +++ \spad{f(x)} is a Laurent series. This pair represents the Puiseux +++ series \spad{f(x^r)}. + UnivariatePuiseuxSeriesConstructorCategory(Coef,ULS):_ Category == Definition where Coef : Ring @@ -56086,29 +56223,29 @@ These exports come from \refto{FiniteFieldCategory}(): ++ ISBN 0 521 30240 4 J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM. ++ AXIOM Technical Report Series, ATR/5 NP2522. ++ Description: -++ 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 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:K,f:SparseUnivariatePolynomial F) -++ which is linear over {\em F}, 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,f) plus {\em d} times -++ \spadfun{linearAssociatedExp}(a,g). -++ Therefore \spadfun{linearAssociatedExp} is defined completely by -++ its action on monomials from {\em F[X]}: -++ \spadfun{linearAssociatedExp}(a,monomial(1,k)\$SUP(F)) is defined to be -++ \spadfun{Frobenius}(a,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. +++ FiniteAlgebraicExtensionField F is the category of fields +++ which are finite algebraic extensions of the field F. +++ If F is finite then any finite algebraic extension of F +++ is finite, too. Let K be a finite algebraic extension of the +++ finite field F. The exponentiation of elements of K +++ defines a Z-module structure on the multiplicative group of K. +++ The additive group of K becomes a module over the ring of +++ polynomials over F via the operation +++ \spadfun{linearAssociatedExp}(a:K,f:SparseUnivariatePolynomial F) +++ which is linear over F, i.e. for elements a from K, +++ c,d from F and f,g univariate polynomials over F +++ we have \spadfun{linearAssociatedExp}(a,cf+dg) equals c times +++ \spadfun{linearAssociatedExp}(a,f) plus d times +++ \spadfun{linearAssociatedExp}(a,g). +++ Therefore \spadfun{linearAssociatedExp} is defined completely by +++ its action on monomials from F[X]: +++ \spadfun{linearAssociatedExp}(a,monomial(1,k)\$SUP(F)) is defined to be +++ \spadfun{Frobenius}(a,k) which is a**(q**k) where 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. FiniteAlgebraicExtensionField(F : Field) : Category == _ Join(ExtensionField F, RetractableTo F) with @@ -56156,12 +56293,13 @@ FiniteAlgebraicExtensionField(F : Field) : Category == _ ++ norm(a,d) computes the norm of \spad{a} with respect to the field ++ of extension degree d over the ground field of size. ++ Error: if d does not divide the extension degree of \spad{a}. - ++ Note: norm(a,d) = reduce(*,[a**(q**(d*i)) for i in 0..n/d]) + ++ Note that norm(a,d) = reduce(*,[a**(q**(d*i)) for i in 0..n/d]) trace: ($,PositiveInteger) -> $ ++ trace(a,d) computes the trace of \spad{a} with respect to the ++ field of extension degree d over the ground field of size q. ++ Error: if d does not divide the extension degree of \spad{a}. - ++ Note: \spad{trace(a,d)=reduce(+,[a**(q**(d*i)) for i in 0..n/d])}. + ++ Note that + ++ \spad{trace(a,d)=reduce(+,[a**(q**(d*i)) for i in 0..n/d])}. createNormalElement: () -> $ ++ createNormalElement() computes a normal element over the ground ++ field F, that is, @@ -56188,28 +56326,28 @@ FiniteAlgebraicExtensionField(F : Field) : Category == _ ++ This element generates the field as an algebra over the ground ++ field. linearAssociatedExp:($,SparseUnivariatePolynomial F) -> $ - ++ linearAssociatedExp(a,f) is linear over {\em F}, i.e. - ++ for elements {\em a} from {\em \$}, {\em c,d} form {\em F} and - ++ {\em f,g} univariate polynomials over {\em F} we have - ++ \spadfun{linearAssociatedExp}(a,cf+dg) equals {\em c} times - ++ \spadfun{linearAssociatedExp}(a,f) plus {\em d} times + ++ linearAssociatedExp(a,f) is linear over F, i.e. + ++ for elements a from \$, c,d form F and + ++ f,g univariate polynomials over F we have + ++ \spadfun{linearAssociatedExp}(a,cf+dg) equals c times + ++ \spadfun{linearAssociatedExp}(a,f) plus d times ++ \spadfun{linearAssociatedExp}(a,g). Therefore ++ \spadfun{linearAssociatedExp} is defined completely by its - ++ action on monomials from {\em F[X]}: + ++ action on monomials from F[X]: ++ \spadfun{linearAssociatedExp}(a,monomial(1,k)\$SUP(F)) is - ++ defined to be \spadfun{Frobenius}(a,k) which is {\em a**(q**k)}, - ++ where {\em q=size()\$F}. + ++ defined to be \spadfun{Frobenius}(a,k) which is a**(q**k), + ++ where q=size()\$F. linearAssociatedOrder: $ -> SparseUnivariatePolynomial F - ++ linearAssociatedOrder(a) retruns the monic polynomial {\em g} of + ++ linearAssociatedOrder(a) retruns the monic polynomial g of ++ least degree, such that \spadfun{linearAssociatedExp}(a,g) is 0. linearAssociatedLog: $ -> SparseUnivariatePolynomial F - ++ linearAssociatedLog(a) returns a polynomial {\em g}, such that - ++ \spadfun{linearAssociatedExp}(normalElement(),g) equals {\em a}. + ++ linearAssociatedLog(a) returns a polynomial g, such that + ++ \spadfun{linearAssociatedExp}(normalElement(),g) equals a. linearAssociatedLog: ($,$) -> _ Union(SparseUnivariatePolynomial F,"failed") - ++ linearAssociatedLog(b,a) returns a polynomial {\em g}, such - ++ that the \spadfun{linearAssociatedExp}(b,g) equals {\em a}. - ++ If there is no such polynomial {\em g}, then + ++ linearAssociatedLog(b,a) returns a polynomial g, such + ++ that the \spadfun{linearAssociatedExp}(b,g) equals a. + ++ If there is no such polynomial g, then ++ \spadfun{linearAssociatedLog} fails. add I ==> Integer @@ -57354,7 +57492,8 @@ These exports come from \refto{TranscendentalFunctionCategory}(): These exports come from \refto{PolynomialFactorizationExplicit}(): \begin{verbatim} - squareFreePolynomial : SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has EUCDOM and R has PFECAT + squareFreePolynomial : SparseUnivariatePolynomial % -> + Factored SparseUnivariatePolynomial % if R has EUCDOM and R has PFECAT \end{verbatim} <>= @@ -57369,8 +57508,8 @@ These exports come from \refto{PolynomialFactorizationExplicit}(): ++ Keywords: complex, gaussian ++ References: ++ Description: -++ This category represents the extension of a ring by a square -++ root of -1. +++ This category represents the extension of a ring by a square root of -1. + ComplexCategory(R:CommutativeRing): Category == Join(MonogenicAlgebra(R, SparseUnivariatePolynomial R), FullyRetractableTo R, DifferentialExtension R, FullyEvalableOver R, FullyPatternMatchable(R), @@ -58382,9 +58521,11 @@ UPUP:UnivariatePolynomialCategory Fraction UP ++ Author: Manuel Bronstein ++ Date Created: 1987 ++ Date Last Updated: 19 Mai 1993 -++ Description: This category is a model for the function field of a -++ plane algebraic curve. ++ Keywords: algebraic, curve, function, field. +++ Description: +++ This category is a model for the function field of a +++ plane algebraic curve. + FunctionFieldCategory(F, UP, UPUP): Category == Definition where F : UniqueFactorizationDomain UP : UnivariatePolynomialCategory F diff --git a/books/bookvol10.3.pamphlet b/books/bookvol10.3.pamphlet index 1ce747d..a46e99a 100644 --- a/books/bookvol10.3.pamphlet +++ b/books/bookvol10.3.pamphlet @@ -403,14 +403,15 @@ in the bootstrap set. Thus, ++ R.D. Schafer: An Introduction to Nonassociative Algebras ++ Academic Press, New York, 1966 ++ Description: -++ 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 n by n matrices -++ \spad{[(gammaijk) for k in 1..rank()]} defined by -++ \spad{ai * aj = gammaij1 * a1 + ... + gammaijn * an}. -++ The symbols for the fixed basis -++ have to be given as a list of symbols. +++ 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 n by n matrices +++ \spad{[(gammaijk) for k in 1..rank()]} defined by +++ \spad{ai * aj = gammaij1 * a1 + ... + gammaijn * an}. +++ The symbols for the fixed basis +++ have to be given as a list of symbols. + AlgebraGivenByStructuralConstants(R:Field, n : PositiveInteger,_ ls : List Symbol, gamma: Vector Matrix R ): public == private where @@ -911,13 +912,13 @@ AlgebraGivenByStructuralConstants(R:Field, n : PositiveInteger,_ <>= )abbrev domain ALGFF AlgebraicFunctionField -++ Function field defined by f(x, y) = 0 ++ Author: Manuel Bronstein ++ Date Created: 3 May 1988 ++ Date Last Updated: 24 Jul 1990 ++ Keywords: algebraic, curve, function, field. -++ Description: Function field defined by f(x, y) = 0. -++ Examples: )r ALGFF INPUT +++ Description: +++ Function field defined by f(x, y) = 0. + AlgebraicFunctionField(F, UP, UPUP, modulus): Exports == Impl where F : Field UP : UnivariatePolynomialCategory F @@ -934,7 +935,7 @@ AlgebraicFunctionField(F, UP, UPUP, modulus): Exports == Impl where Exports ==> FunctionFieldCategory(F, UP, UPUP) with knownInfBasis: N -> Void - ++ knownInfBasis(n) \undocumented{} + ++ knownInfBasis(n) is not documented Impl ==> SAE add import ChangeOfVariable(F, UP, UPUP) @@ -1152,12 +1153,13 @@ AlgebraicFunctionField(F, UP, UPUP, modulus): Exports == Impl where <>= )abbrev domain AN AlgebraicNumber -++ Algebraic closure of the rational numbers ++ Author: James Davenport ++ Date Created: 9 October 1995 ++ Date Last Updated: 10 October 1995 (JHD) -++ Description: Algebraic closure of the rational numbers, with mathematical = ++ Keywords: algebraic, number. +++ Description: +++ Algebraic closure of the rational numbers, with mathematical = + AlgebraicNumber(): Exports == Implementation where Z ==> Integer P ==> SparseMultivariatePolynomial(Z, Kernel %) @@ -1222,8 +1224,10 @@ AlgebraicNumber(): Exports == Implementation where <>= )abbrev domain ANON AnonymousFunction +++ Author: Mark Botch ++ Description: ++ This domain implements anonymous functions + AnonymousFunction():SetCategory == add coerce(x:%):OutputForm == x pretend OutputForm @@ -1283,16 +1287,11 @@ AnonymousFunction():SetCategory == add <>= )abbrev domain ANTISYM AntiSymm -++ Author: Larry A. Lambe -++ Date : 01/26/91. -++ Revised : 30 Nov 94 -++ -++ based on AntiSymmetric '89 -++ -++ Needs: ExtAlgBasis, FreeModule(Ring,OrderedSet), LALG, LALG- -++ -++ Description: The domain of antisymmetric polynomials. - +++ Author: Larry A. Lambe +++ Date : 01/26/91. +++ Revised : 30 Nov 94 +++ Description: +++ The domain of antisymmetric polynomials. AntiSymm(R:Ring, lVar:List Symbol): Export == Implement where LALG ==> LeftAlgebra @@ -1309,37 +1308,37 @@ AntiSymm(R:Ring, lVar:List Symbol): Export == Implement where Export == Join(LALG(R), RetractableTo(R)) with leadingCoefficient : % -> R - ++ leadingCoefficient(p) returns the leading - ++ coefficient of antisymmetric polynomial p. + ++ leadingCoefficient(p) returns the leading + ++ coefficient of antisymmetric polynomial p. -- leadingSupport : % -> EAB leadingBasisTerm : % -> % - ++ leadingBasisTerm(p) returns the leading - ++ basis term of antisymmetric polynomial p. + ++ leadingBasisTerm(p) returns the leading + ++ basis term of antisymmetric polynomial p. reductum : % -> % - ++ reductum(p), where p is an antisymmetric polynomial, + ++ reductum(p), where p is an antisymmetric polynomial, ++ returns p minus the leading - ++ term of p if p has at least two terms, and 0 otherwise. + ++ term of p if p has at least two terms, and 0 otherwise. coefficient : (%,%) -> R - ++ coefficient(p,u) returns the coefficient of - ++ the term in p containing the basis term u if such + ++ coefficient(p,u) returns the coefficient of + ++ the term in p containing the basis term u if such ++ a term exists, and 0 otherwise. - ++ Error: if the second argument u is not a basis element. + ++ Error: if the second argument u is not a basis element. generator : NNI -> % - ++ generator(n) returns the nth multiplicative generator, - ++ a basis term. + ++ generator(n) returns the nth multiplicative generator, + ++ a basis term. exp : L I -> % - ++ exp([i1,...in]) returns \spad{u_1\^{i_1} ... u_n\^{i_n}} + ++ exp([i1,...in]) returns \spad{u_1\^{i_1} ... u_n\^{i_n}} homogeneous? : % -> Boolean - ++ homogeneous?(p) tests if all of the terms of - ++ p have the same degree. + ++ homogeneous?(p) tests if all of the terms of + ++ p have the same degree. retractable? : % -> Boolean - ++ retractable?(p) tests if p is a 0-form, - ++ i.e., if degree(p) = 0. + ++ retractable?(p) tests if p is a 0-form, + ++ i.e., if degree(p) = 0. degree : % -> NNI - ++ degree(p) returns the homogeneous degree of p. + ++ degree(p) returns the homogeneous degree of p. map : (R -> R, %) -> % - ++ map(f,p) changes each coefficient of p by the - ++ application of f. + ++ map(f,p) changes each coefficient of p by the + ++ application of f. -- 1 corresponds to the empty monomial Nul = [0,...,0] @@ -1762,13 +1761,13 @@ o )show Any ++ AMS Classification: ++ Keywords: ++ Description: -++ \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}. +++ \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}. Any(): SetCategory with any : (SExpression, None) -> % @@ -2524,7 +2523,6 @@ o )show BagAggregate ++ Examples: ++ References: ++ Description: - ++ A stack represented as a flexible array. --% Dequeue and Heap data types @@ -2728,21 +2726,18 @@ ArrayStack(S:SetCategory): StackAggregate(S) with )abbrev domain ASP1 Asp1 ++ Author: Mike Dewar, Grant Keady, Godfrey Nolan ++ Date Created: Mar 1993 -++ Date Last Updated: 18 March 1994 -++ 6 October 1994 +++ Date Last Updated: 18 March 1994, 6 October 1994 ++ Related Constructors: FortranFunctionCategory, FortranProgramCategory. -++ Description: +++ Description: ++ \spadtype{Asp1} produces Fortran for Type 1 ASPs, needed for various -++ NAG routines. Type 1 ASPs take a univariate expression (in the symbol -++ X) and turn it into a Fortran Function like the following: -++\begin{verbatim} -++ DOUBLE PRECISION FUNCTION F(X) -++ DOUBLE PRECISION X -++ F=DSIN(X) -++ RETURN -++ END -++\end{verbatim} - +++ NAG routines. Type 1 ASPs take a univariate expression (in the symbol x) +++ and turn it into a Fortran Function like the following: +++ +++ \tab{5}DOUBLE PRECISION FUNCTION F(X)\br +++ \tab{5}DOUBLE PRECISION X\br +++ \tab{5}F=DSIN(X)\br +++ \tab{5}RETURN\br +++ \tab{5}END Asp1(name): Exports == Implementation where name : Symbol @@ -2858,18 +2853,17 @@ Asp1(name): Exports == Implementation where ++ 6 October 1994 ++ Related Constructors: FortranVectorFunctionCategory, FortranProgramCategory ++ Description: -++\spadtype{ASP10} produces Fortran for Type 10 ASPs, needed for NAG routine -++\axiomOpFrom{d02kef}{d02Package}. This ASP computes the values of a set of functions, for example: -++\begin{verbatim} -++ SUBROUTINE COEFFN(P,Q,DQDL,X,ELAM,JINT) -++ DOUBLE PRECISION ELAM,P,Q,X,DQDL -++ INTEGER JINT -++ P=1.0D0 -++ Q=((-1.0D0*X**3)+ELAM*X*X-2.0D0)/(X*X) -++ DQDL=1.0D0 -++ RETURN -++ END -++\end{verbatim} +++ \spadtype{ASP10} produces Fortran for Type 10 ASPs, needed for NAG routine +++ d02kef. This ASP computes the values of a set of functions, for example: +++ +++ \tab{5}SUBROUTINE COEFFN(P,Q,DQDL,X,ELAM,JINT)\br +++ \tab{5}DOUBLE PRECISION ELAM,P,Q,X,DQDL\br +++ \tab{5}INTEGER JINT\br +++ \tab{5}P=1.0D0\br +++ \tab{5}Q=((-1.0D0*X**3)+ELAM*X*X-2.0D0)/(X*X)\br +++ \tab{5}DQDL=1.0D0\br +++ \tab{5}RETURN\br +++ \tab{5}END Asp10(name): Exports == Implementation where name : Symbol @@ -3012,19 +3006,19 @@ Asp10(name): Exports == Implementation where ++ 21 June 1994 Changed print to printStatement ++ Related Constructors: ++ Description: -++\spadtype{Asp12} produces Fortran for Type 12 ASPs, needed for NAG routine -++\axiomOpFrom{d02kef}{d02Package} etc., for example: -++\begin{verbatim} -++ SUBROUTINE MONIT (MAXIT,IFLAG,ELAM,FINFO) -++ DOUBLE PRECISION ELAM,FINFO(15) -++ INTEGER MAXIT,IFLAG -++ IF(MAXIT.EQ.-1)THEN -++ PRINT*,"Output from Monit" -++ ENDIF -++ PRINT*,MAXIT,IFLAG,ELAM,(FINFO(I),I=1,4) -++ RETURN -++ END -++\end{verbatim} +++ \spadtype{Asp12} produces Fortran for Type 12 ASPs, needed for NAG routine +++ d02kef etc., for example: +++ +++ \tab{5}SUBROUTINE MONIT (MAXIT,IFLAG,ELAM,FINFO)\br +++ \tab{5}DOUBLE PRECISION ELAM,FINFO(15)\br +++ \tab{5}INTEGER MAXIT,IFLAG\br +++ \tab{5}IF(MAXIT.EQ.-1)THEN\br +++ \tab{7}PRINT*,"Output from Monit"\br +++ \tab{5}ENDIF\br +++ \tab{5}PRINT*,MAXIT,IFLAG,ELAM,(FINFO(I),I=1,4)\br +++ \tab{5}RETURN\br +++ \tab{5}END\ + Asp12(name): Exports == Implementation where name : Symbol @@ -3099,111 +3093,110 @@ Asp12(name): Exports == Implementation where ++ Description: ++\spadtype{Asp19} produces Fortran for Type 19 ASPs, evaluating a set of ++functions and their jacobian at a given point, for example: -++\begin{verbatim} -++ SUBROUTINE LSFUN2(M,N,XC,FVECC,FJACC,LJC) -++ DOUBLE PRECISION FVECC(M),FJACC(LJC,N),XC(N) -++ INTEGER M,N,LJC -++ INTEGER I,J -++ DO 25003 I=1,LJC -++ DO 25004 J=1,N -++ FJACC(I,J)=0.0D0 -++25004 CONTINUE -++25003 CONTINUE -++ FVECC(1)=((XC(1)-0.14D0)*XC(3)+(15.0D0*XC(1)-2.1D0)*XC(2)+1.0D0)/( -++ &XC(3)+15.0D0*XC(2)) -++ FVECC(2)=((XC(1)-0.18D0)*XC(3)+(7.0D0*XC(1)-1.26D0)*XC(2)+1.0D0)/( -++ &XC(3)+7.0D0*XC(2)) -++ FVECC(3)=((XC(1)-0.22D0)*XC(3)+(4.333333333333333D0*XC(1)-0.953333 -++ &3333333333D0)*XC(2)+1.0D0)/(XC(3)+4.333333333333333D0*XC(2)) -++ FVECC(4)=((XC(1)-0.25D0)*XC(3)+(3.0D0*XC(1)-0.75D0)*XC(2)+1.0D0)/( -++ &XC(3)+3.0D0*XC(2)) -++ FVECC(5)=((XC(1)-0.29D0)*XC(3)+(2.2D0*XC(1)-0.6379999999999999D0)* -++ &XC(2)+1.0D0)/(XC(3)+2.2D0*XC(2)) -++ FVECC(6)=((XC(1)-0.32D0)*XC(3)+(1.666666666666667D0*XC(1)-0.533333 -++ &3333333333D0)*XC(2)+1.0D0)/(XC(3)+1.666666666666667D0*XC(2)) -++ FVECC(7)=((XC(1)-0.35D0)*XC(3)+(1.285714285714286D0*XC(1)-0.45D0)* -++ &XC(2)+1.0D0)/(XC(3)+1.285714285714286D0*XC(2)) -++ FVECC(8)=((XC(1)-0.39D0)*XC(3)+(XC(1)-0.39D0)*XC(2)+1.0D0)/(XC(3)+ -++ &XC(2)) -++ FVECC(9)=((XC(1)-0.37D0)*XC(3)+(XC(1)-0.37D0)*XC(2)+1.285714285714 -++ &286D0)/(XC(3)+XC(2)) -++ FVECC(10)=((XC(1)-0.58D0)*XC(3)+(XC(1)-0.58D0)*XC(2)+1.66666666666 -++ &6667D0)/(XC(3)+XC(2)) -++ FVECC(11)=((XC(1)-0.73D0)*XC(3)+(XC(1)-0.73D0)*XC(2)+2.2D0)/(XC(3) -++ &+XC(2)) -++ FVECC(12)=((XC(1)-0.96D0)*XC(3)+(XC(1)-0.96D0)*XC(2)+3.0D0)/(XC(3) -++ &+XC(2)) -++ FVECC(13)=((XC(1)-1.34D0)*XC(3)+(XC(1)-1.34D0)*XC(2)+4.33333333333 -++ &3333D0)/(XC(3)+XC(2)) -++ FVECC(14)=((XC(1)-2.1D0)*XC(3)+(XC(1)-2.1D0)*XC(2)+7.0D0)/(XC(3)+X -++ &C(2)) -++ FVECC(15)=((XC(1)-4.39D0)*XC(3)+(XC(1)-4.39D0)*XC(2)+15.0D0)/(XC(3 -++ &)+XC(2)) -++ FJACC(1,1)=1.0D0 -++ FJACC(1,2)=-15.0D0/(XC(3)**2+30.0D0*XC(2)*XC(3)+225.0D0*XC(2)**2) -++ FJACC(1,3)=-1.0D0/(XC(3)**2+30.0D0*XC(2)*XC(3)+225.0D0*XC(2)**2) -++ FJACC(2,1)=1.0D0 -++ FJACC(2,2)=-7.0D0/(XC(3)**2+14.0D0*XC(2)*XC(3)+49.0D0*XC(2)**2) -++ FJACC(2,3)=-1.0D0/(XC(3)**2+14.0D0*XC(2)*XC(3)+49.0D0*XC(2)**2) -++ FJACC(3,1)=1.0D0 -++ FJACC(3,2)=((-0.1110223024625157D-15*XC(3))-4.333333333333333D0)/( -++ &XC(3)**2+8.666666666666666D0*XC(2)*XC(3)+18.77777777777778D0*XC(2) -++ &**2) -++ FJACC(3,3)=(0.1110223024625157D-15*XC(2)-1.0D0)/(XC(3)**2+8.666666 -++ &666666666D0*XC(2)*XC(3)+18.77777777777778D0*XC(2)**2) -++ FJACC(4,1)=1.0D0 -++ FJACC(4,2)=-3.0D0/(XC(3)**2+6.0D0*XC(2)*XC(3)+9.0D0*XC(2)**2) -++ FJACC(4,3)=-1.0D0/(XC(3)**2+6.0D0*XC(2)*XC(3)+9.0D0*XC(2)**2) -++ FJACC(5,1)=1.0D0 -++ FJACC(5,2)=((-0.1110223024625157D-15*XC(3))-2.2D0)/(XC(3)**2+4.399 -++ &999999999999D0*XC(2)*XC(3)+4.839999999999998D0*XC(2)**2) -++ FJACC(5,3)=(0.1110223024625157D-15*XC(2)-1.0D0)/(XC(3)**2+4.399999 -++ &999999999D0*XC(2)*XC(3)+4.839999999999998D0*XC(2)**2) -++ FJACC(6,1)=1.0D0 -++ FJACC(6,2)=((-0.2220446049250313D-15*XC(3))-1.666666666666667D0)/( -++ &XC(3)**2+3.333333333333333D0*XC(2)*XC(3)+2.777777777777777D0*XC(2) -++ &**2) -++ FJACC(6,3)=(0.2220446049250313D-15*XC(2)-1.0D0)/(XC(3)**2+3.333333 -++ &333333333D0*XC(2)*XC(3)+2.777777777777777D0*XC(2)**2) -++ FJACC(7,1)=1.0D0 -++ FJACC(7,2)=((-0.5551115123125783D-16*XC(3))-1.285714285714286D0)/( -++ &XC(3)**2+2.571428571428571D0*XC(2)*XC(3)+1.653061224489796D0*XC(2) -++ &**2) -++ FJACC(7,3)=(0.5551115123125783D-16*XC(2)-1.0D0)/(XC(3)**2+2.571428 -++ &571428571D0*XC(2)*XC(3)+1.653061224489796D0*XC(2)**2) -++ FJACC(8,1)=1.0D0 -++ FJACC(8,2)=-1.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2) -++ FJACC(8,3)=-1.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2) -++ FJACC(9,1)=1.0D0 -++ FJACC(9,2)=-1.285714285714286D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)* -++ &*2) -++ FJACC(9,3)=-1.285714285714286D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)* -++ &*2) -++ FJACC(10,1)=1.0D0 -++ FJACC(10,2)=-1.666666666666667D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2) -++ &**2) -++ FJACC(10,3)=-1.666666666666667D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2) -++ &**2) -++ FJACC(11,1)=1.0D0 -++ FJACC(11,2)=-2.2D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2) -++ FJACC(11,3)=-2.2D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2) -++ FJACC(12,1)=1.0D0 -++ FJACC(12,2)=-3.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2) -++ FJACC(12,3)=-3.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2) -++ FJACC(13,1)=1.0D0 -++ FJACC(13,2)=-4.333333333333333D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2) -++ &**2) -++ FJACC(13,3)=-4.333333333333333D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2) -++ &**2) -++ FJACC(14,1)=1.0D0 -++ FJACC(14,2)=-7.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2) -++ FJACC(14,3)=-7.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2) -++ FJACC(15,1)=1.0D0 -++ FJACC(15,2)=-15.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2) -++ FJACC(15,3)=-15.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2) -++ RETURN -++ END -++\end{verbatim} +++ +++\tab{5}SUBROUTINE LSFUN2(M,N,XC,FVECC,FJACC,LJC)\br +++\tab{5}DOUBLE PRECISION FVECC(M),FJACC(LJC,N),XC(N)\br +++\tab{5}INTEGER M,N,LJC\br +++\tab{5}INTEGER I,J\br +++\tab{5}DO 25003 I=1,LJC\br +++\tab{7}DO 25004 J=1,N\br +++\tab{9}FJACC(I,J)=0.0D0\br +++25004 CONTINUE\br +++25003 CONTINUE\br +++\tab{5}FVECC(1)=((XC(1)-0.14D0)*XC(3)+(15.0D0*XC(1)-2.1D0)*XC(2)+1.0D0)/(\br +++\tab{4}&XC(3)+15.0D0*XC(2))\br +++\tab{5}FVECC(2)=((XC(1)-0.18D0)*XC(3)+(7.0D0*XC(1)-1.26D0)*XC(2)+1.0D0)/(\br +++\tab{4}&XC(3)+7.0D0*XC(2))\br +++\tab{5}FVECC(3)=((XC(1)-0.22D0)*XC(3)+(4.333333333333333D0*XC(1)-0.953333\br +++\tab{4}&3333333333D0)*XC(2)+1.0D0)/(XC(3)+4.333333333333333D0*XC(2))\br +++\tab{5}FVECC(4)=((XC(1)-0.25D0)*XC(3)+(3.0D0*XC(1)-0.75D0)*XC(2)+1.0D0)/(\br +++\tab{4}&XC(3)+3.0D0*XC(2))\br +++\tab{5}FVECC(5)=((XC(1)-0.29D0)*XC(3)+(2.2D0*XC(1)-0.6379999999999999D0)*\br +++\tab{4}&XC(2)+1.0D0)/(XC(3)+2.2D0*XC(2))\br +++\tab{5}FVECC(6)=((XC(1)-0.32D0)*XC(3)+(1.666666666666667D0*XC(1)-0.533333\br +++\tab{4}&3333333333D0)*XC(2)+1.0D0)/(XC(3)+1.666666666666667D0*XC(2))\br +++\tab{5}FVECC(7)=((XC(1)-0.35D0)*XC(3)+(1.285714285714286D0*XC(1)-0.45D0)*\br +++\tab{4}&XC(2)+1.0D0)/(XC(3)+1.285714285714286D0*XC(2))\br +++\tab{5}FVECC(8)=((XC(1)-0.39D0)*XC(3)+(XC(1)-0.39D0)*XC(2)+1.0D0)/(XC(3)+\br +++\tab{4}&XC(2))\br +++\tab{5}FVECC(9)=((XC(1)-0.37D0)*XC(3)+(XC(1)-0.37D0)*XC(2)+1.285714285714\br +++\tab{4}&286D0)/(XC(3)+XC(2))\br +++\tab{5}FVECC(10)=((XC(1)-0.58D0)*XC(3)+(XC(1)-0.58D0)*XC(2)+1.66666666666\br +++\tab{4}&6667D0)/(XC(3)+XC(2))\br +++\tab{5}FVECC(11)=((XC(1)-0.73D0)*XC(3)+(XC(1)-0.73D0)*XC(2)+2.2D0)/(XC(3)\br +++\tab{4}&+XC(2))\br +++\tab{5}FVECC(12)=((XC(1)-0.96D0)*XC(3)+(XC(1)-0.96D0)*XC(2)+3.0D0)/(XC(3)\br +++\tab{4}&+XC(2))\br +++\tab{5}FVECC(13)=((XC(1)-1.34D0)*XC(3)+(XC(1)-1.34D0)*XC(2)+4.33333333333\br +++\tab{4}&3333D0)/(XC(3)+XC(2))\br +++\tab{5}FVECC(14)=((XC(1)-2.1D0)*XC(3)+(XC(1)-2.1D0)*XC(2)+7.0D0)/(XC(3)+X\br +++\tab{4}&C(2))\br +++\tab{5}FVECC(15)=((XC(1)-4.39D0)*XC(3)+(XC(1)-4.39D0)*XC(2)+15.0D0)/(XC(3\br +++\tab{4}&)+XC(2))\br +++\tab{5}FJACC(1,1)=1.0D0\br +++\tab{5}FJACC(1,2)=-15.0D0/(XC(3)**2+30.0D0*XC(2)*XC(3)+225.0D0*XC(2)**2)\br +++\tab{5}FJACC(1,3)=-1.0D0/(XC(3)**2+30.0D0*XC(2)*XC(3)+225.0D0*XC(2)**2)\br +++\tab{5}FJACC(2,1)=1.0D0\br +++\tab{5}FJACC(2,2)=-7.0D0/(XC(3)**2+14.0D0*XC(2)*XC(3)+49.0D0*XC(2)**2)\br +++\tab{5}FJACC(2,3)=-1.0D0/(XC(3)**2+14.0D0*XC(2)*XC(3)+49.0D0*XC(2)**2)\br +++\tab{5}FJACC(3,1)=1.0D0\br +++\tab{5}FJACC(3,2)=((-0.1110223024625157D-15*XC(3))-4.333333333333333D0)/(\br +++\tab{4}&XC(3)**2+8.666666666666666D0*XC(2)*XC(3)+18.77777777777778D0*XC(2)\br +++\tab{4}&**2)\br +++\tab{5}FJACC(3,3)=(0.1110223024625157D-15*XC(2)-1.0D0)/(XC(3)**2+8.666666\br +++\tab{4}&666666666D0*XC(2)*XC(3)+18.77777777777778D0*XC(2)**2)\br +++\tab{5}FJACC(4,1)=1.0D0\br +++\tab{5}FJACC(4,2)=-3.0D0/(XC(3)**2+6.0D0*XC(2)*XC(3)+9.0D0*XC(2)**2)\br +++\tab{5}FJACC(4,3)=-1.0D0/(XC(3)**2+6.0D0*XC(2)*XC(3)+9.0D0*XC(2)**2)\br +++\tab{5}FJACC(5,1)=1.0D0\br +++\tab{5}FJACC(5,2)=((-0.1110223024625157D-15*XC(3))-2.2D0)/(XC(3)**2+4.399\br +++\tab{4}&999999999999D0*XC(2)*XC(3)+4.839999999999998D0*XC(2)**2)\br +++\tab{5}FJACC(5,3)=(0.1110223024625157D-15*XC(2)-1.0D0)/(XC(3)**2+4.399999\br +++\tab{4}&999999999D0*XC(2)*XC(3)+4.839999999999998D0*XC(2)**2)\br +++\tab{5}FJACC(6,1)=1.0D0\br +++\tab{5}FJACC(6,2)=((-0.2220446049250313D-15*XC(3))-1.666666666666667D0)/(\br +++\tab{4}&XC(3)**2+3.333333333333333D0*XC(2)*XC(3)+2.777777777777777D0*XC(2)\br +++\tab{4}&**2)\br +++\tab{5}FJACC(6,3)=(0.2220446049250313D-15*XC(2)-1.0D0)/(XC(3)**2+3.333333\br +++\tab{4}&333333333D0*XC(2)*XC(3)+2.777777777777777D0*XC(2)**2)\br +++\tab{5}FJACC(7,1)=1.0D0\br +++\tab{5}FJACC(7,2)=((-0.5551115123125783D-16*XC(3))-1.285714285714286D0)/(\br +++\tab{4}&XC(3)**2+2.571428571428571D0*XC(2)*XC(3)+1.653061224489796D0*XC(2)\br +++\tab{4}&**2)\br +++\tab{5}FJACC(7,3)=(0.5551115123125783D-16*XC(2)-1.0D0)/(XC(3)**2+2.571428\br +++\tab{4}&571428571D0*XC(2)*XC(3)+1.653061224489796D0*XC(2)**2)\br +++\tab{5}FJACC(8,1)=1.0D0\br +++\tab{5}FJACC(8,2)=-1.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br +++\tab{5}FJACC(8,3)=-1.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br +++\tab{5}FJACC(9,1)=1.0D0\br +++\tab{5}FJACC(9,2)=-1.285714285714286D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)*\br +++\tab{4}&*2)\br +++\tab{5}FJACC(9,3)=-1.285714285714286D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)*\br +++\tab{4}&*2)\br +++\tab{5}FJACC(10,1)=1.0D0\br +++\tab{5}FJACC(10,2)=-1.666666666666667D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)\br +++\tab{4}&**2)\br +++\tab{5}FJACC(10,3)=-1.666666666666667D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)\br +++\tab{4}&**2)\br +++\tab{5}FJACC(11,1)=1.0D0\br +++\tab{5}FJACC(11,2)=-2.2D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br +++\tab{5}FJACC(11,3)=-2.2D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br +++\tab{5}FJACC(12,1)=1.0D0\br +++\tab{5}FJACC(12,2)=-3.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br +++\tab{5}FJACC(12,3)=-3.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br +++\tab{5}FJACC(13,1)=1.0D0\br +++\tab{5}FJACC(13,2)=-4.333333333333333D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)\br +++\tab{4}&**2)\br +++\tab{5}FJACC(13,3)=-4.333333333333333D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)\br +++\tab{4}&**2)\br +++\tab{5}FJACC(14,1)=1.0D0\br +++\tab{5}FJACC(14,2)=-7.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br +++\tab{5}FJACC(14,3)=-7.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br +++\tab{5}FJACC(15,1)=1.0D0\br +++\tab{5}FJACC(15,2)=-15.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br +++\tab{5}FJACC(15,3)=-15.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\br +++\tab{5}RETURN\br +++\tab{5}END Asp19(name): Exports == Implementation where name : Symbol @@ -3387,21 +3380,20 @@ Asp19(name): Exports == Implementation where ++ 6 October 1994 ++ Related Constructors: FortranVectorFunctionCategory, FortranProgramCategory ++ Description: -++\spadtype{Asp20} produces Fortran for Type 20 ASPs, for example: -++\begin{verbatim} -++ SUBROUTINE QPHESS(N,NROWH,NCOLH,JTHCOL,HESS,X,HX) -++ DOUBLE PRECISION HX(N),X(N),HESS(NROWH,NCOLH) -++ INTEGER JTHCOL,N,NROWH,NCOLH -++ HX(1)=2.0D0*X(1) -++ HX(2)=2.0D0*X(2) -++ HX(3)=2.0D0*X(4)+2.0D0*X(3) -++ HX(4)=2.0D0*X(4)+2.0D0*X(3) -++ HX(5)=2.0D0*X(5) -++ HX(6)=(-2.0D0*X(7))+(-2.0D0*X(6)) -++ HX(7)=(-2.0D0*X(7))+(-2.0D0*X(6)) -++ RETURN -++ END -++\end{verbatim} +++ \spadtype{Asp20} produces Fortran for Type 20 ASPs, for example: +++ +++ \tab{5}SUBROUTINE QPHESS(N,NROWH,NCOLH,JTHCOL,HESS,X,HX)\br +++ \tab{5}DOUBLE PRECISION HX(N),X(N),HESS(NROWH,NCOLH)\br +++ \tab{5}INTEGER JTHCOL,N,NROWH,NCOLH\br +++ \tab{5}HX(1)=2.0D0*X(1)\br +++ \tab{5}HX(2)=2.0D0*X(2)\br +++ \tab{5}HX(3)=2.0D0*X(4)+2.0D0*X(3)\br +++ \tab{5}HX(4)=2.0D0*X(4)+2.0D0*X(3)\br +++ \tab{5}HX(5)=2.0D0*X(5)\br +++ \tab{5}HX(6)=(-2.0D0*X(7))+(-2.0D0*X(6))\br +++ \tab{5}HX(7)=(-2.0D0*X(7))+(-2.0D0*X(6))\br +++ \tab{5}RETURN\br +++ \tab{5}END Asp20(name): Exports == Implementation where name : Symbol @@ -3570,19 +3562,19 @@ Asp20(name): Exports == Implementation where ++ Related Constructors: FortranScalarFunctionCategory, FortranProgramCategory ++ Description: ++\spadtype{Asp24} produces Fortran for Type 24 ASPs which evaluate a -++multivariate function at a point (needed for NAG routine \axiomOpFrom{e04jaf}{e04Package}), for example: -++\begin{verbatim} -++ SUBROUTINE FUNCT1(N,XC,FC) -++ DOUBLE PRECISION FC,XC(N) -++ INTEGER N -++ FC=10.0D0*XC(4)**4+(-40.0D0*XC(1)*XC(4)**3)+(60.0D0*XC(1)**2+5 -++ &.0D0)*XC(4)**2+((-10.0D0*XC(3))+(-40.0D0*XC(1)**3))*XC(4)+16.0D0*X -++ &C(3)**4+(-32.0D0*XC(2)*XC(3)**3)+(24.0D0*XC(2)**2+5.0D0)*XC(3)**2+ -++ &(-8.0D0*XC(2)**3*XC(3))+XC(2)**4+100.0D0*XC(2)**2+20.0D0*XC(1)*XC( -++ &2)+10.0D0*XC(1)**4+XC(1)**2 -++ RETURN -++ END -++\end{verbatim} +++multivariate function at a point (needed for NAG routine e04jaf), +++for example: +++ +++\tab{5}SUBROUTINE FUNCT1(N,XC,FC)\br +++\tab{5}DOUBLE PRECISION FC,XC(N)\br +++\tab{5}INTEGER N\br +++\tab{5}FC=10.0D0*XC(4)**4+(-40.0D0*XC(1)*XC(4)**3)+(60.0D0*XC(1)**2+5\br +++\tab{4}&.0D0)*XC(4)**2+((-10.0D0*XC(3))+(-40.0D0*XC(1)**3))*XC(4)+16.0D0*X\br +++\tab{4}&C(3)**4+(-32.0D0*XC(2)*XC(3)**3)+(24.0D0*XC(2)**2+5.0D0)*XC(3)**2+\br +++\tab{4}&(-8.0D0*XC(2)**3*XC(3))+XC(2)**4+100.0D0*XC(2)**2+20.0D0*XC(1)*XC(\br +++\tab{4}&2)+10.0D0*XC(1)**4+XC(1)**2\br +++\tab{5}RETURN\br +++\tab{5}END\br Asp24(name): Exports == Implementation where name : Symbol @@ -3601,8 +3593,8 @@ Asp24(name): Exports == Implementation where Exports ==> FortranFunctionCategory with coerce : FEXPR -> $ - ++ coerce(f) takes an object from the appropriate instantiation of - ++ \spadtype{FortranExpression} and turns it into an ASP. + ++ coerce(f) takes an object from the appropriate instantiation of + ++ \spadtype{FortranExpression} and turns it into an ASP. Implementation ==> add @@ -3701,24 +3693,23 @@ Asp24(name): Exports == Implementation where ++ Related Constructors: FortranScalarFunctionCategory, FortranProgramCategory ++ Description: ++\spadtype{Asp27} produces Fortran for Type 27 ASPs, needed for NAG routine -++\axiomOpFrom{f02fjf}{f02Package} ,for example: -++\begin{verbatim} -++ FUNCTION DOT(IFLAG,N,Z,W,RWORK,LRWORK,IWORK,LIWORK) -++ DOUBLE PRECISION W(N),Z(N),RWORK(LRWORK) -++ INTEGER N,LIWORK,IFLAG,LRWORK,IWORK(LIWORK) -++ DOT=(W(16)+(-0.5D0*W(15)))*Z(16)+((-0.5D0*W(16))+W(15)+(-0.5D0*W(1 -++ &4)))*Z(15)+((-0.5D0*W(15))+W(14)+(-0.5D0*W(13)))*Z(14)+((-0.5D0*W( -++ &14))+W(13)+(-0.5D0*W(12)))*Z(13)+((-0.5D0*W(13))+W(12)+(-0.5D0*W(1 -++ &1)))*Z(12)+((-0.5D0*W(12))+W(11)+(-0.5D0*W(10)))*Z(11)+((-0.5D0*W( -++ &11))+W(10)+(-0.5D0*W(9)))*Z(10)+((-0.5D0*W(10))+W(9)+(-0.5D0*W(8)) -++ &)*Z(9)+((-0.5D0*W(9))+W(8)+(-0.5D0*W(7)))*Z(8)+((-0.5D0*W(8))+W(7) -++ &+(-0.5D0*W(6)))*Z(7)+((-0.5D0*W(7))+W(6)+(-0.5D0*W(5)))*Z(6)+((-0. -++ &5D0*W(6))+W(5)+(-0.5D0*W(4)))*Z(5)+((-0.5D0*W(5))+W(4)+(-0.5D0*W(3 -++ &)))*Z(4)+((-0.5D0*W(4))+W(3)+(-0.5D0*W(2)))*Z(3)+((-0.5D0*W(3))+W( -++ &2)+(-0.5D0*W(1)))*Z(2)+((-0.5D0*W(2))+W(1))*Z(1) -++ RETURN -++ END -++\end{verbatim} +++f02fjf ,for example: +++ +++\tab{5}FUNCTION DOT(IFLAG,N,Z,W,RWORK,LRWORK,IWORK,LIWORK)\br +++\tab{5}DOUBLE PRECISION W(N),Z(N),RWORK(LRWORK)\br +++\tab{5}INTEGER N,LIWORK,IFLAG,LRWORK,IWORK(LIWORK)\br +++\tab{5}DOT=(W(16)+(-0.5D0*W(15)))*Z(16)+((-0.5D0*W(16))+W(15)+(-0.5D0*W(1\br +++\tab{4}&4)))*Z(15)+((-0.5D0*W(15))+W(14)+(-0.5D0*W(13)))*Z(14)+((-0.5D0*W(\br +++\tab{4}&14))+W(13)+(-0.5D0*W(12)))*Z(13)+((-0.5D0*W(13))+W(12)+(-0.5D0*W(1\br +++\tab{4}&1)))*Z(12)+((-0.5D0*W(12))+W(11)+(-0.5D0*W(10)))*Z(11)+((-0.5D0*W(\br +++\tab{4}&11))+W(10)+(-0.5D0*W(9)))*Z(10)+((-0.5D0*W(10))+W(9)+(-0.5D0*W(8))\br +++\tab{4}&)*Z(9)+((-0.5D0*W(9))+W(8)+(-0.5D0*W(7)))*Z(8)+((-0.5D0*W(8))+W(7)\br +++\tab{4}&+(-0.5D0*W(6)))*Z(7)+((-0.5D0*W(7))+W(6)+(-0.5D0*W(5)))*Z(6)+((-0.\br +++\tab{4}&5D0*W(6))+W(5)+(-0.5D0*W(4)))*Z(5)+((-0.5D0*W(5))+W(4)+(-0.5D0*W(3\br +++\tab{4}&)))*Z(4)+((-0.5D0*W(4))+W(3)+(-0.5D0*W(2)))*Z(3)+((-0.5D0*W(3))+W(\br +++\tab{4}&2)+(-0.5D0*W(1)))*Z(2)+((-0.5D0*W(2))+W(1))*Z(1)\br +++\tab{5}RETURN\br +++\tab{5}END Asp27(name): Exports == Implementation where name : Symbol @@ -3814,140 +3805,139 @@ Asp27(name): Exports == Implementation where ++ Related Constructors: FortranVectorFunctionCategory, FortranProgramCategory ++ Description: ++\spadtype{Asp28} produces Fortran for Type 28 ASPs, used in NAG routine -++\axiomOpFrom{f02fjf}{f02Package}, for example: -++\begin{verbatim} -++ SUBROUTINE IMAGE(IFLAG,N,Z,W,RWORK,LRWORK,IWORK,LIWORK) -++ DOUBLE PRECISION Z(N),W(N),IWORK(LRWORK),RWORK(LRWORK) -++ INTEGER N,LIWORK,IFLAG,LRWORK -++ W(1)=0.01707454969713436D0*Z(16)+0.001747395874954051D0*Z(15)+0.00 -++ &2106973900813502D0*Z(14)+0.002957434991769087D0*Z(13)+(-0.00700554 -++ &0882865317D0*Z(12))+(-0.01219194009813166D0*Z(11))+0.0037230647365 -++ &3087D0*Z(10)+0.04932374658377151D0*Z(9)+(-0.03586220812223305D0*Z( -++ &8))+(-0.04723268012114625D0*Z(7))+(-0.02434652144032987D0*Z(6))+0. -++ &2264766947290192D0*Z(5)+(-0.1385343580686922D0*Z(4))+(-0.116530050 -++ &8238904D0*Z(3))+(-0.2803531651057233D0*Z(2))+1.019463911841327D0*Z -++ &(1) -++ W(2)=0.0227345011107737D0*Z(16)+0.008812321197398072D0*Z(15)+0.010 -++ &94012210519586D0*Z(14)+(-0.01764072463999744D0*Z(13))+(-0.01357136 -++ &72105995D0*Z(12))+0.00157466157362272D0*Z(11)+0.05258889186338282D -++ &0*Z(10)+(-0.01981532388243379D0*Z(9))+(-0.06095390688679697D0*Z(8) -++ &)+(-0.04153119955569051D0*Z(7))+0.2176561076571465D0*Z(6)+(-0.0532 -++ &5555586632358D0*Z(5))+(-0.1688977368984641D0*Z(4))+(-0.32440166056 -++ &67343D0*Z(3))+0.9128222941872173D0*Z(2)+(-0.2419652703415429D0*Z(1 -++ &)) -++ W(3)=0.03371198197190302D0*Z(16)+0.02021603150122265D0*Z(15)+(-0.0 -++ &06607305534689702D0*Z(14))+(-0.03032392238968179D0*Z(13))+0.002033 -++ &305231024948D0*Z(12)+0.05375944956767728D0*Z(11)+(-0.0163213312502 -++ &9967D0*Z(10))+(-0.05483186562035512D0*Z(9))+(-0.04901428822579872D -++ &0*Z(8))+0.2091097927887612D0*Z(7)+(-0.05760560341383113D0*Z(6))+(- -++ &0.1236679206156403D0*Z(5))+(-0.3523683853026259D0*Z(4))+0.88929961 -++ &32269974D0*Z(3)+(-0.2995429545781457D0*Z(2))+(-0.02986582812574917 -++ &D0*Z(1)) -++ W(4)=0.05141563713660119D0*Z(16)+0.005239165960779299D0*Z(15)+(-0. -++ &01623427735779699D0*Z(14))+(-0.01965809746040371D0*Z(13))+0.054688 -++ &97337339577D0*Z(12)+(-0.014224695935687D0*Z(11))+(-0.0505181779315 -++ &6355D0*Z(10))+(-0.04353074206076491D0*Z(9))+0.2012230497530726D0*Z -++ &(8)+(-0.06630874514535952D0*Z(7))+(-0.1280829963720053D0*Z(6))+(-0 -++ &.305169742604165D0*Z(5))+0.8600427128450191D0*Z(4)+(-0.32415033802 -++ &68184D0*Z(3))+(-0.09033531980693314D0*Z(2))+0.09089205517109111D0* -++ &Z(1) -++ W(5)=0.04556369767776375D0*Z(16)+(-0.001822737697581869D0*Z(15))+( -++ &-0.002512226501941856D0*Z(14))+0.02947046460707379D0*Z(13)+(-0.014 -++ &45079632086177D0*Z(12))+(-0.05034242196614937D0*Z(11))+(-0.0376966 -++ &3291725935D0*Z(10))+0.2171103102175198D0*Z(9)+(-0.0824949256021352 -++ &4D0*Z(8))+(-0.1473995209288945D0*Z(7))+(-0.315042193418466D0*Z(6)) -++ &+0.9591623347824002D0*Z(5)+(-0.3852396953763045D0*Z(4))+(-0.141718 -++ &5427288274D0*Z(3))+(-0.03423495461011043D0*Z(2))+0.319820917706851 -++ &6D0*Z(1) -++ W(6)=0.04015147277405744D0*Z(16)+0.01328585741341559D0*Z(15)+0.048 -++ &26082005465965D0*Z(14)+(-0.04319641116207706D0*Z(13))+(-0.04931323 -++ &319055762D0*Z(12))+(-0.03526886317505474D0*Z(11))+0.22295383396730 -++ &01D0*Z(10)+(-0.07375317649315155D0*Z(9))+(-0.1589391311991561D0*Z( -++ &8))+(-0.328001910890377D0*Z(7))+0.952576555482747D0*Z(6)+(-0.31583 -++ &09975786731D0*Z(5))+(-0.1846882042225383D0*Z(4))+(-0.0703762046700 -++ &4427D0*Z(3))+0.2311852964327382D0*Z(2)+0.04254083491825025D0*Z(1) -++ W(7)=0.06069778964023718D0*Z(16)+0.06681263884671322D0*Z(15)+(-0.0 -++ &2113506688615768D0*Z(14))+(-0.083996867458326D0*Z(13))+(-0.0329843 -++ &8523869648D0*Z(12))+0.2276878326327734D0*Z(11)+(-0.067356038933017 -++ &95D0*Z(10))+(-0.1559813965382218D0*Z(9))+(-0.3363262957694705D0*Z( -++ &8))+0.9442791158560948D0*Z(7)+(-0.3199955249404657D0*Z(6))+(-0.136 -++ &2463839920727D0*Z(5))+(-0.1006185171570586D0*Z(4))+0.2057504515015 -++ &423D0*Z(3)+(-0.02065879269286707D0*Z(2))+0.03160990266745513D0*Z(1 -++ &) -++ W(8)=0.126386868896738D0*Z(16)+0.002563370039476418D0*Z(15)+(-0.05 -++ &581757739455641D0*Z(14))+(-0.07777893205900685D0*Z(13))+0.23117338 -++ &45834199D0*Z(12)+(-0.06031581134427592D0*Z(11))+(-0.14805474755869 -++ &52D0*Z(10))+(-0.3364014128402243D0*Z(9))+0.9364014128402244D0*Z(8) -++ &+(-0.3269452524413048D0*Z(7))+(-0.1396841886557241D0*Z(6))+(-0.056 -++ &1733845834199D0*Z(5))+0.1777789320590069D0*Z(4)+(-0.04418242260544 -++ &359D0*Z(3))+(-0.02756337003947642D0*Z(2))+0.07361313110326199D0*Z( -++ &1) -++ W(9)=0.07361313110326199D0*Z(16)+(-0.02756337003947642D0*Z(15))+(- -++ &0.04418242260544359D0*Z(14))+0.1777789320590069D0*Z(13)+(-0.056173 -++ &3845834199D0*Z(12))+(-0.1396841886557241D0*Z(11))+(-0.326945252441 -++ &3048D0*Z(10))+0.9364014128402244D0*Z(9)+(-0.3364014128402243D0*Z(8 -++ &))+(-0.1480547475586952D0*Z(7))+(-0.06031581134427592D0*Z(6))+0.23 -++ &11733845834199D0*Z(5)+(-0.07777893205900685D0*Z(4))+(-0.0558175773 -++ &9455641D0*Z(3))+0.002563370039476418D0*Z(2)+0.126386868896738D0*Z( -++ &1) -++ W(10)=0.03160990266745513D0*Z(16)+(-0.02065879269286707D0*Z(15))+0 -++ &.2057504515015423D0*Z(14)+(-0.1006185171570586D0*Z(13))+(-0.136246 -++ &3839920727D0*Z(12))+(-0.3199955249404657D0*Z(11))+0.94427911585609 -++ &48D0*Z(10)+(-0.3363262957694705D0*Z(9))+(-0.1559813965382218D0*Z(8 -++ &))+(-0.06735603893301795D0*Z(7))+0.2276878326327734D0*Z(6)+(-0.032 -++ &98438523869648D0*Z(5))+(-0.083996867458326D0*Z(4))+(-0.02113506688 -++ &615768D0*Z(3))+0.06681263884671322D0*Z(2)+0.06069778964023718D0*Z( -++ &1) -++ W(11)=0.04254083491825025D0*Z(16)+0.2311852964327382D0*Z(15)+(-0.0 -++ &7037620467004427D0*Z(14))+(-0.1846882042225383D0*Z(13))+(-0.315830 -++ &9975786731D0*Z(12))+0.952576555482747D0*Z(11)+(-0.328001910890377D -++ &0*Z(10))+(-0.1589391311991561D0*Z(9))+(-0.07375317649315155D0*Z(8) -++ &)+0.2229538339673001D0*Z(7)+(-0.03526886317505474D0*Z(6))+(-0.0493 -++ &1323319055762D0*Z(5))+(-0.04319641116207706D0*Z(4))+0.048260820054 -++ &65965D0*Z(3)+0.01328585741341559D0*Z(2)+0.04015147277405744D0*Z(1) -++ W(12)=0.3198209177068516D0*Z(16)+(-0.03423495461011043D0*Z(15))+(- -++ &0.1417185427288274D0*Z(14))+(-0.3852396953763045D0*Z(13))+0.959162 -++ &3347824002D0*Z(12)+(-0.315042193418466D0*Z(11))+(-0.14739952092889 -++ &45D0*Z(10))+(-0.08249492560213524D0*Z(9))+0.2171103102175198D0*Z(8 -++ &)+(-0.03769663291725935D0*Z(7))+(-0.05034242196614937D0*Z(6))+(-0. -++ &01445079632086177D0*Z(5))+0.02947046460707379D0*Z(4)+(-0.002512226 -++ &501941856D0*Z(3))+(-0.001822737697581869D0*Z(2))+0.045563697677763 -++ &75D0*Z(1) -++ W(13)=0.09089205517109111D0*Z(16)+(-0.09033531980693314D0*Z(15))+( -++ &-0.3241503380268184D0*Z(14))+0.8600427128450191D0*Z(13)+(-0.305169 -++ &742604165D0*Z(12))+(-0.1280829963720053D0*Z(11))+(-0.0663087451453 -++ &5952D0*Z(10))+0.2012230497530726D0*Z(9)+(-0.04353074206076491D0*Z( -++ &8))+(-0.05051817793156355D0*Z(7))+(-0.014224695935687D0*Z(6))+0.05 -++ &468897337339577D0*Z(5)+(-0.01965809746040371D0*Z(4))+(-0.016234277 -++ &35779699D0*Z(3))+0.005239165960779299D0*Z(2)+0.05141563713660119D0 -++ &*Z(1) -++ W(14)=(-0.02986582812574917D0*Z(16))+(-0.2995429545781457D0*Z(15)) -++ &+0.8892996132269974D0*Z(14)+(-0.3523683853026259D0*Z(13))+(-0.1236 -++ &679206156403D0*Z(12))+(-0.05760560341383113D0*Z(11))+0.20910979278 -++ &87612D0*Z(10)+(-0.04901428822579872D0*Z(9))+(-0.05483186562035512D -++ &0*Z(8))+(-0.01632133125029967D0*Z(7))+0.05375944956767728D0*Z(6)+0 -++ &.002033305231024948D0*Z(5)+(-0.03032392238968179D0*Z(4))+(-0.00660 -++ &7305534689702D0*Z(3))+0.02021603150122265D0*Z(2)+0.033711981971903 -++ &02D0*Z(1) -++ W(15)=(-0.2419652703415429D0*Z(16))+0.9128222941872173D0*Z(15)+(-0 -++ &.3244016605667343D0*Z(14))+(-0.1688977368984641D0*Z(13))+(-0.05325 -++ &555586632358D0*Z(12))+0.2176561076571465D0*Z(11)+(-0.0415311995556 -++ &9051D0*Z(10))+(-0.06095390688679697D0*Z(9))+(-0.01981532388243379D -++ &0*Z(8))+0.05258889186338282D0*Z(7)+0.00157466157362272D0*Z(6)+(-0. -++ &0135713672105995D0*Z(5))+(-0.01764072463999744D0*Z(4))+0.010940122 -++ &10519586D0*Z(3)+0.008812321197398072D0*Z(2)+0.0227345011107737D0*Z -++ &(1) -++ W(16)=1.019463911841327D0*Z(16)+(-0.2803531651057233D0*Z(15))+(-0. -++ &1165300508238904D0*Z(14))+(-0.1385343580686922D0*Z(13))+0.22647669 -++ &47290192D0*Z(12)+(-0.02434652144032987D0*Z(11))+(-0.04723268012114 -++ &625D0*Z(10))+(-0.03586220812223305D0*Z(9))+0.04932374658377151D0*Z -++ &(8)+0.00372306473653087D0*Z(7)+(-0.01219194009813166D0*Z(6))+(-0.0 -++ &07005540882865317D0*Z(5))+0.002957434991769087D0*Z(4)+0.0021069739 -++ &00813502D0*Z(3)+0.001747395874954051D0*Z(2)+0.01707454969713436D0* -++ &Z(1) -++ RETURN -++ END -++\end{verbatim} +++f02fjf, for example: +++ +++\tab{5}SUBROUTINE IMAGE(IFLAG,N,Z,W,RWORK,LRWORK,IWORK,LIWORK)\br +++\tab{5}DOUBLE PRECISION Z(N),W(N),IWORK(LRWORK),RWORK(LRWORK)\br +++\tab{5}INTEGER N,LIWORK,IFLAG,LRWORK\br +++\tab{5}W(1)=0.01707454969713436D0*Z(16)+0.001747395874954051D0*Z(15)+0.00\br +++\tab{4}&2106973900813502D0*Z(14)+0.002957434991769087D0*Z(13)+(-0.00700554\br +++\tab{4}&0882865317D0*Z(12))+(-0.01219194009813166D0*Z(11))+0.0037230647365\br +++\tab{4}&3087D0*Z(10)+0.04932374658377151D0*Z(9)+(-0.03586220812223305D0*Z(\br +++\tab{4}&8))+(-0.04723268012114625D0*Z(7))+(-0.02434652144032987D0*Z(6))+0.\br +++\tab{4}&2264766947290192D0*Z(5)+(-0.1385343580686922D0*Z(4))+(-0.116530050\br +++\tab{4}&8238904D0*Z(3))+(-0.2803531651057233D0*Z(2))+1.019463911841327D0*Z\br +++\tab{4}&(1)\br +++\tab{5}W(2)=0.0227345011107737D0*Z(16)+0.008812321197398072D0*Z(15)+0.010\br +++\tab{4}&94012210519586D0*Z(14)+(-0.01764072463999744D0*Z(13))+(-0.01357136\br +++\tab{4}&72105995D0*Z(12))+0.00157466157362272D0*Z(11)+0.05258889186338282D\br +++\tab{4}&0*Z(10)+(-0.01981532388243379D0*Z(9))+(-0.06095390688679697D0*Z(8)\br +++\tab{4}&)+(-0.04153119955569051D0*Z(7))+0.2176561076571465D0*Z(6)+(-0.0532\br +++\tab{4}&5555586632358D0*Z(5))+(-0.1688977368984641D0*Z(4))+(-0.32440166056\br +++\tab{4}&67343D0*Z(3))+0.9128222941872173D0*Z(2)+(-0.2419652703415429D0*Z(1\br +++\tab{4}&))\br +++\tab{5}W(3)=0.03371198197190302D0*Z(16)+0.02021603150122265D0*Z(15)+(-0.0\br +++\tab{4}&06607305534689702D0*Z(14))+(-0.03032392238968179D0*Z(13))+0.002033\br +++\tab{4}&305231024948D0*Z(12)+0.05375944956767728D0*Z(11)+(-0.0163213312502\br +++\tab{4}&9967D0*Z(10))+(-0.05483186562035512D0*Z(9))+(-0.04901428822579872D\br +++\tab{4}&0*Z(8))+0.2091097927887612D0*Z(7)+(-0.05760560341383113D0*Z(6))+(-\br +++\tab{4}&0.1236679206156403D0*Z(5))+(-0.3523683853026259D0*Z(4))+0.88929961\br +++\tab{4}&32269974D0*Z(3)+(-0.2995429545781457D0*Z(2))+(-0.02986582812574917\br +++\tab{4}&D0*Z(1))\br +++\tab{5}W(4)=0.05141563713660119D0*Z(16)+0.005239165960779299D0*Z(15)+(-0.\br +++\tab{4}&01623427735779699D0*Z(14))+(-0.01965809746040371D0*Z(13))+0.054688\br +++\tab{4}&97337339577D0*Z(12)+(-0.014224695935687D0*Z(11))+(-0.0505181779315\br +++\tab{4}&6355D0*Z(10))+(-0.04353074206076491D0*Z(9))+0.2012230497530726D0*Z\br +++\tab{4}&(8)+(-0.06630874514535952D0*Z(7))+(-0.1280829963720053D0*Z(6))+(-0\br +++\tab{4}&.305169742604165D0*Z(5))+0.8600427128450191D0*Z(4)+(-0.32415033802\br +++\tab{4}&68184D0*Z(3))+(-0.09033531980693314D0*Z(2))+0.09089205517109111D0*\br +++\tab{4}&Z(1)\br +++\tab{5}W(5)=0.04556369767776375D0*Z(16)+(-0.001822737697581869D0*Z(15))+(\br +++\tab{4}&-0.002512226501941856D0*Z(14))+0.02947046460707379D0*Z(13)+(-0.014\br +++\tab{4}&45079632086177D0*Z(12))+(-0.05034242196614937D0*Z(11))+(-0.0376966\br +++\tab{4}&3291725935D0*Z(10))+0.2171103102175198D0*Z(9)+(-0.0824949256021352\br +++\tab{4}&4D0*Z(8))+(-0.1473995209288945D0*Z(7))+(-0.315042193418466D0*Z(6))\br +++\tab{4}&+0.9591623347824002D0*Z(5)+(-0.3852396953763045D0*Z(4))+(-0.141718\br +++\tab{4}&5427288274D0*Z(3))+(-0.03423495461011043D0*Z(2))+0.319820917706851\br +++\tab{4}&6D0*Z(1)\br +++\tab{5}W(6)=0.04015147277405744D0*Z(16)+0.01328585741341559D0*Z(15)+0.048\br +++\tab{4}&26082005465965D0*Z(14)+(-0.04319641116207706D0*Z(13))+(-0.04931323\br +++\tab{4}&319055762D0*Z(12))+(-0.03526886317505474D0*Z(11))+0.22295383396730\br +++\tab{4}&01D0*Z(10)+(-0.07375317649315155D0*Z(9))+(-0.1589391311991561D0*Z(\br +++\tab{4}&8))+(-0.328001910890377D0*Z(7))+0.952576555482747D0*Z(6)+(-0.31583\br +++\tab{4}&09975786731D0*Z(5))+(-0.1846882042225383D0*Z(4))+(-0.0703762046700\br +++\tab{4}&4427D0*Z(3))+0.2311852964327382D0*Z(2)+0.04254083491825025D0*Z(1)\br +++\tab{5}W(7)=0.06069778964023718D0*Z(16)+0.06681263884671322D0*Z(15)+(-0.0\br +++\tab{4}&2113506688615768D0*Z(14))+(-0.083996867458326D0*Z(13))+(-0.0329843\br +++\tab{4}&8523869648D0*Z(12))+0.2276878326327734D0*Z(11)+(-0.067356038933017\br +++\tab{4}&95D0*Z(10))+(-0.1559813965382218D0*Z(9))+(-0.3363262957694705D0*Z(\br +++\tab{4}&8))+0.9442791158560948D0*Z(7)+(-0.3199955249404657D0*Z(6))+(-0.136\br +++\tab{4}&2463839920727D0*Z(5))+(-0.1006185171570586D0*Z(4))+0.2057504515015\br +++\tab{4}&423D0*Z(3)+(-0.02065879269286707D0*Z(2))+0.03160990266745513D0*Z(1\br +++\tab{4}&)\br +++\tab{5}W(8)=0.126386868896738D0*Z(16)+0.002563370039476418D0*Z(15)+(-0.05\br +++\tab{4}&581757739455641D0*Z(14))+(-0.07777893205900685D0*Z(13))+0.23117338\br +++\tab{4}&45834199D0*Z(12)+(-0.06031581134427592D0*Z(11))+(-0.14805474755869\br +++\tab{4}&52D0*Z(10))+(-0.3364014128402243D0*Z(9))+0.9364014128402244D0*Z(8)\br +++\tab{4}&+(-0.3269452524413048D0*Z(7))+(-0.1396841886557241D0*Z(6))+(-0.056\br +++\tab{4}&1733845834199D0*Z(5))+0.1777789320590069D0*Z(4)+(-0.04418242260544\br +++\tab{4}&359D0*Z(3))+(-0.02756337003947642D0*Z(2))+0.07361313110326199D0*Z(\br +++\tab{4}&1)\br +++\tab{5}W(9)=0.07361313110326199D0*Z(16)+(-0.02756337003947642D0*Z(15))+(-\br +++\tab{4}&0.04418242260544359D0*Z(14))+0.1777789320590069D0*Z(13)+(-0.056173\br +++\tab{4}&3845834199D0*Z(12))+(-0.1396841886557241D0*Z(11))+(-0.326945252441\br +++\tab{4}&3048D0*Z(10))+0.9364014128402244D0*Z(9)+(-0.3364014128402243D0*Z(8\br +++\tab{4}&))+(-0.1480547475586952D0*Z(7))+(-0.06031581134427592D0*Z(6))+0.23\br +++\tab{4}&11733845834199D0*Z(5)+(-0.07777893205900685D0*Z(4))+(-0.0558175773\br +++\tab{4}&9455641D0*Z(3))+0.002563370039476418D0*Z(2)+0.126386868896738D0*Z(\br +++\tab{4}&1)\br +++\tab{5}W(10)=0.03160990266745513D0*Z(16)+(-0.02065879269286707D0*Z(15))+0\br +++\tab{4}&.2057504515015423D0*Z(14)+(-0.1006185171570586D0*Z(13))+(-0.136246\br +++\tab{4}&3839920727D0*Z(12))+(-0.3199955249404657D0*Z(11))+0.94427911585609\br +++\tab{4}&48D0*Z(10)+(-0.3363262957694705D0*Z(9))+(-0.1559813965382218D0*Z(8\br +++\tab{4}&))+(-0.06735603893301795D0*Z(7))+0.2276878326327734D0*Z(6)+(-0.032\br +++\tab{4}&98438523869648D0*Z(5))+(-0.083996867458326D0*Z(4))+(-0.02113506688\br +++\tab{4}&615768D0*Z(3))+0.06681263884671322D0*Z(2)+0.06069778964023718D0*Z(\br +++\tab{4}&1)\br +++\tab{5}W(11)=0.04254083491825025D0*Z(16)+0.2311852964327382D0*Z(15)+(-0.0\br +++\tab{4}&7037620467004427D0*Z(14))+(-0.1846882042225383D0*Z(13))+(-0.315830\br +++\tab{4}&9975786731D0*Z(12))+0.952576555482747D0*Z(11)+(-0.328001910890377D\br +++\tab{4}&0*Z(10))+(-0.1589391311991561D0*Z(9))+(-0.07375317649315155D0*Z(8)\br +++\tab{4}&)+0.2229538339673001D0*Z(7)+(-0.03526886317505474D0*Z(6))+(-0.0493\br +++\tab{4}&1323319055762D0*Z(5))+(-0.04319641116207706D0*Z(4))+0.048260820054\br +++\tab{4}&65965D0*Z(3)+0.01328585741341559D0*Z(2)+0.04015147277405744D0*Z(1)\br +++\tab{5}W(12)=0.3198209177068516D0*Z(16)+(-0.03423495461011043D0*Z(15))+(-\br +++\tab{4}&0.1417185427288274D0*Z(14))+(-0.3852396953763045D0*Z(13))+0.959162\br +++\tab{4}&3347824002D0*Z(12)+(-0.315042193418466D0*Z(11))+(-0.14739952092889\br +++\tab{4}&45D0*Z(10))+(-0.08249492560213524D0*Z(9))+0.2171103102175198D0*Z(8\br +++\tab{4}&)+(-0.03769663291725935D0*Z(7))+(-0.05034242196614937D0*Z(6))+(-0.\br +++\tab{4}&01445079632086177D0*Z(5))+0.02947046460707379D0*Z(4)+(-0.002512226\br +++\tab{4}&501941856D0*Z(3))+(-0.001822737697581869D0*Z(2))+0.045563697677763\br +++\tab{4}&75D0*Z(1)\br +++\tab{5}W(13)=0.09089205517109111D0*Z(16)+(-0.09033531980693314D0*Z(15))+(\br +++\tab{4}&-0.3241503380268184D0*Z(14))+0.8600427128450191D0*Z(13)+(-0.305169\br +++\tab{4}&742604165D0*Z(12))+(-0.1280829963720053D0*Z(11))+(-0.0663087451453\br +++\tab{4}&5952D0*Z(10))+0.2012230497530726D0*Z(9)+(-0.04353074206076491D0*Z(\br +++\tab{4}&8))+(-0.05051817793156355D0*Z(7))+(-0.014224695935687D0*Z(6))+0.05\br +++\tab{4}&468897337339577D0*Z(5)+(-0.01965809746040371D0*Z(4))+(-0.016234277\br +++\tab{4}&35779699D0*Z(3))+0.005239165960779299D0*Z(2)+0.05141563713660119D0\br +++\tab{4}&*Z(1)\br +++\tab{5}W(14)=(-0.02986582812574917D0*Z(16))+(-0.2995429545781457D0*Z(15))\br +++\tab{4}&+0.8892996132269974D0*Z(14)+(-0.3523683853026259D0*Z(13))+(-0.1236\br +++\tab{4}&679206156403D0*Z(12))+(-0.05760560341383113D0*Z(11))+0.20910979278\br +++\tab{4}&87612D0*Z(10)+(-0.04901428822579872D0*Z(9))+(-0.05483186562035512D\br +++\tab{4}&0*Z(8))+(-0.01632133125029967D0*Z(7))+0.05375944956767728D0*Z(6)+0\br +++\tab{4}&.002033305231024948D0*Z(5)+(-0.03032392238968179D0*Z(4))+(-0.00660\br +++\tab{4}&7305534689702D0*Z(3))+0.02021603150122265D0*Z(2)+0.033711981971903\br +++\tab{4}&02D0*Z(1)\br +++\tab{5}W(15)=(-0.2419652703415429D0*Z(16))+0.9128222941872173D0*Z(15)+(-0\br +++\tab{4}&.3244016605667343D0*Z(14))+(-0.1688977368984641D0*Z(13))+(-0.05325\br +++\tab{4}&555586632358D0*Z(12))+0.2176561076571465D0*Z(11)+(-0.0415311995556\br +++\tab{4}&9051D0*Z(10))+(-0.06095390688679697D0*Z(9))+(-0.01981532388243379D\br +++\tab{4}&0*Z(8))+0.05258889186338282D0*Z(7)+0.00157466157362272D0*Z(6)+(-0.\br +++\tab{4}&0135713672105995D0*Z(5))+(-0.01764072463999744D0*Z(4))+0.010940122\br +++\tab{4}&10519586D0*Z(3)+0.008812321197398072D0*Z(2)+0.0227345011107737D0*Z\br +++\tab{4}&(1)\br +++\tab{5}W(16)=1.019463911841327D0*Z(16)+(-0.2803531651057233D0*Z(15))+(-0.\br +++\tab{4}&1165300508238904D0*Z(14))+(-0.1385343580686922D0*Z(13))+0.22647669\br +++\tab{4}&47290192D0*Z(12)+(-0.02434652144032987D0*Z(11))+(-0.04723268012114\br +++\tab{4}&625D0*Z(10))+(-0.03586220812223305D0*Z(9))+0.04932374658377151D0*Z\br +++\tab{4}&(8)+0.00372306473653087D0*Z(7)+(-0.01219194009813166D0*Z(6))+(-0.0\br +++\tab{4}&07005540882865317D0*Z(5))+0.002957434991769087D0*Z(4)+0.0021069739\br +++\tab{4}&00813502D0*Z(3)+0.001747395874954051D0*Z(2)+0.01707454969713436D0*\br +++\tab{4}&Z(1)\br +++\tab{5}RETURN\br +++\tab{5}END\br Asp28(name): Exports == Implementation where name : Symbol @@ -4037,15 +4027,14 @@ Asp28(name): Exports == Implementation where ++ Related Constructors: FortranScalarFunctionCategory, FortranProgramCategory ++ Description: ++\spadtype{Asp29} produces Fortran for Type 29 ASPs, needed for NAG routine -++\axiomOpFrom{f02fjf}{f02Package}, for example: -++\begin{verbatim} -++ SUBROUTINE MONIT(ISTATE,NEXTIT,NEVALS,NEVECS,K,F,D) -++ DOUBLE PRECISION D(K),F(K) -++ INTEGER K,NEXTIT,NEVALS,NVECS,ISTATE -++ CALL F02FJZ(ISTATE,NEXTIT,NEVALS,NEVECS,K,F,D) -++ RETURN -++ END -++\end{verbatim} +++f02fjf, for example: +++ +++\tab{5}SUBROUTINE MONIT(ISTATE,NEXTIT,NEVALS,NEVECS,K,F,D)\br +++\tab{5}DOUBLE PRECISION D(K),F(K)\br +++\tab{5}INTEGER K,NEXTIT,NEVALS,NVECS,ISTATE\br +++\tab{5}CALL F02FJZ(ISTATE,NEXTIT,NEVALS,NEVECS,K,F,D)\br +++\tab{5}RETURN\br +++\tab{5}END\br Asp29(name): Exports == Implementation where name : Symbol @@ -4125,46 +4114,45 @@ Asp29(name): Exports == Implementation where ++ Related Constructors: FortranScalarFunctionCategory, FortranProgramCategory ++ Description: ++\spadtype{Asp30} produces Fortran for Type 30 ASPs, needed for NAG routine -++\axiomOpFrom{f04qaf}{f04Package}, for example: -++\begin{verbatim} -++ SUBROUTINE APROD(MODE,M,N,X,Y,RWORK,LRWORK,IWORK,LIWORK) -++ DOUBLE PRECISION X(N),Y(M),RWORK(LRWORK) -++ INTEGER M,N,LIWORK,IFAIL,LRWORK,IWORK(LIWORK),MODE -++ DOUBLE PRECISION A(5,5) -++ EXTERNAL F06PAF -++ A(1,1)=1.0D0 -++ A(1,2)=0.0D0 -++ A(1,3)=0.0D0 -++ A(1,4)=-1.0D0 -++ A(1,5)=0.0D0 -++ A(2,1)=0.0D0 -++ A(2,2)=1.0D0 -++ A(2,3)=0.0D0 -++ A(2,4)=0.0D0 -++ A(2,5)=-1.0D0 -++ A(3,1)=0.0D0 -++ A(3,2)=0.0D0 -++ A(3,3)=1.0D0 -++ A(3,4)=-1.0D0 -++ A(3,5)=0.0D0 -++ A(4,1)=-1.0D0 -++ A(4,2)=0.0D0 -++ A(4,3)=-1.0D0 -++ A(4,4)=4.0D0 -++ A(4,5)=-1.0D0 -++ A(5,1)=0.0D0 -++ A(5,2)=-1.0D0 -++ A(5,3)=0.0D0 -++ A(5,4)=-1.0D0 -++ A(5,5)=4.0D0 -++ IF(MODE.EQ.1)THEN -++ CALL F06PAF('N',M,N,1.0D0,A,M,X,1,1.0D0,Y,1) -++ ELSEIF(MODE.EQ.2)THEN -++ CALL F06PAF('T',M,N,1.0D0,A,M,Y,1,1.0D0,X,1) -++ ENDIF -++ RETURN -++ END -++\end{verbatim} +++f04qaf, for example: +++ +++\tab{5}SUBROUTINE APROD(MODE,M,N,X,Y,RWORK,LRWORK,IWORK,LIWORK)\br +++\tab{5}DOUBLE PRECISION X(N),Y(M),RWORK(LRWORK)\br +++\tab{5}INTEGER M,N,LIWORK,IFAIL,LRWORK,IWORK(LIWORK),MODE\br +++\tab{5}DOUBLE PRECISION A(5,5)\br +++\tab{5}EXTERNAL F06PAF\br +++\tab{5}A(1,1)=1.0D0\br +++\tab{5}A(1,2)=0.0D0\br +++\tab{5}A(1,3)=0.0D0\br +++\tab{5}A(1,4)=-1.0D0\br +++\tab{5}A(1,5)=0.0D0\br +++\tab{5}A(2,1)=0.0D0\br +++\tab{5}A(2,2)=1.0D0\br +++\tab{5}A(2,3)=0.0D0\br +++\tab{5}A(2,4)=0.0D0\br +++\tab{5}A(2,5)=-1.0D0\br +++\tab{5}A(3,1)=0.0D0\br +++\tab{5}A(3,2)=0.0D0\br +++\tab{5}A(3,3)=1.0D0\br +++\tab{5}A(3,4)=-1.0D0\br +++\tab{5}A(3,5)=0.0D0\br +++\tab{5}A(4,1)=-1.0D0\br +++\tab{5}A(4,2)=0.0D0\br +++\tab{5}A(4,3)=-1.0D0\br +++\tab{5}A(4,4)=4.0D0\br +++\tab{5}A(4,5)=-1.0D0\br +++\tab{5}A(5,1)=0.0D0\br +++\tab{5}A(5,2)=-1.0D0\br +++\tab{5}A(5,3)=0.0D0\br +++\tab{5}A(5,4)=-1.0D0\br +++\tab{5}A(5,5)=4.0D0\br +++\tab{5}IF(MODE.EQ.1)THEN\br +++\tab{7}CALL F06PAF('N',M,N,1.0D0,A,M,X,1,1.0D0,Y,1)\br +++\tab{5}ELSEIF(MODE.EQ.2)THEN\br +++\tab{7}CALL F06PAF('T',M,N,1.0D0,A,M,Y,1,1.0D0,X,1)\br +++\tab{5}ENDIF\br +++\tab{5}RETURN\br +++\tab{5}END Asp30(name): Exports == Implementation where name : Symbol @@ -4270,23 +4258,22 @@ Asp30(name): Exports == Implementation where ++ Related Constructors: FortranMatrixFunctionCategory, FortranProgramCategory ++ Description: ++\spadtype{Asp31} produces Fortran for Type 31 ASPs, needed for NAG routine -++\axiomOpFrom{d02ejf}{d02Package}, for example: -++\begin{verbatim} -++ SUBROUTINE PEDERV(X,Y,PW) -++ DOUBLE PRECISION X,Y(*) -++ DOUBLE PRECISION PW(3,3) -++ PW(1,1)=-0.03999999999999999D0 -++ PW(1,2)=10000.0D0*Y(3) -++ PW(1,3)=10000.0D0*Y(2) -++ PW(2,1)=0.03999999999999999D0 -++ PW(2,2)=(-10000.0D0*Y(3))+(-60000000.0D0*Y(2)) -++ PW(2,3)=-10000.0D0*Y(2) -++ PW(3,1)=0.0D0 -++ PW(3,2)=60000000.0D0*Y(2) -++ PW(3,3)=0.0D0 -++ RETURN -++ END -++\end{verbatim} +++d02ejf, for example: +++ +++\tab{5}SUBROUTINE PEDERV(X,Y,PW)\br +++\tab{5}DOUBLE PRECISION X,Y(*)\br +++\tab{5}DOUBLE PRECISION PW(3,3)\br +++\tab{5}PW(1,1)=-0.03999999999999999D0\br +++\tab{5}PW(1,2)=10000.0D0*Y(3)\br +++\tab{5}PW(1,3)=10000.0D0*Y(2)\br +++\tab{5}PW(2,1)=0.03999999999999999D0\br +++\tab{5}PW(2,2)=(-10000.0D0*Y(3))+(-60000000.0D0*Y(2))\br +++\tab{5}PW(2,3)=-10000.0D0*Y(2)\br +++\tab{5}PW(3,1)=0.0D0\br +++\tab{5}PW(3,2)=60000000.0D0*Y(2)\br +++\tab{5}PW(3,3)=0.0D0\br +++\tab{5}RETURN\br +++\tab{5}END Asp31(name): Exports == Implementation where name : Symbol @@ -4446,14 +4433,13 @@ Asp31(name): Exports == Implementation where ++ Related Constructors: FortranScalarFunctionCategory, FortranProgramCategory. ++ Description: ++\spadtype{Asp33} produces Fortran for Type 33 ASPs, needed for NAG routine -++\axiomOpFrom{d02kef}{d02Package}. The code is a dummy ASP: -++\begin{verbatim} -++ SUBROUTINE REPORT(X,V,JINT) -++ DOUBLE PRECISION V(3),X -++ INTEGER JINT -++ RETURN -++ END -++\end{verbatim} +++d02kef. The code is a dummy ASP: +++ +++\tab{5}SUBROUTINE REPORT(X,V,JINT)\br +++\tab{5}DOUBLE PRECISION V(3),X\br +++\tab{5}INTEGER JINT\br +++\tab{5}RETURN\br +++\tab{5}END Asp33(name): Exports == Implementation where name : Symbol @@ -4514,27 +4500,26 @@ Asp33(name): Exports == Implementation where ++ Related Constructors: FortranScalarFunctionCategory, FortranProgramCategory ++ Description: ++\spadtype{Asp34} produces Fortran for Type 34 ASPs, needed for NAG routine -++\axiomOpFrom{f04mbf}{f04Package}, for example: -++\begin{verbatim} -++ SUBROUTINE MSOLVE(IFLAG,N,X,Y,RWORK,LRWORK,IWORK,LIWORK) -++ DOUBLE PRECISION RWORK(LRWORK),X(N),Y(N) -++ INTEGER I,J,N,LIWORK,IFLAG,LRWORK,IWORK(LIWORK) -++ DOUBLE PRECISION W1(3),W2(3),MS(3,3) -++ IFLAG=-1 -++ MS(1,1)=2.0D0 -++ MS(1,2)=1.0D0 -++ MS(1,3)=0.0D0 -++ MS(2,1)=1.0D0 -++ MS(2,2)=2.0D0 -++ MS(2,3)=1.0D0 -++ MS(3,1)=0.0D0 -++ MS(3,2)=1.0D0 -++ MS(3,3)=2.0D0 -++ CALL F04ASF(MS,N,X,N,Y,W1,W2,IFLAG) -++ IFLAG=-IFLAG -++ RETURN -++ END -++\end{verbatim} +++f04mbf, for example: +++ +++\tab{5}SUBROUTINE MSOLVE(IFLAG,N,X,Y,RWORK,LRWORK,IWORK,LIWORK)\br +++\tab{5}DOUBLE PRECISION RWORK(LRWORK),X(N),Y(N)\br +++\tab{5}INTEGER I,J,N,LIWORK,IFLAG,LRWORK,IWORK(LIWORK)\br +++\tab{5}DOUBLE PRECISION W1(3),W2(3),MS(3,3)\br +++\tab{5}IFLAG=-1\br +++\tab{5}MS(1,1)=2.0D0\br +++\tab{5}MS(1,2)=1.0D0\br +++\tab{5}MS(1,3)=0.0D0\br +++\tab{5}MS(2,1)=1.0D0\br +++\tab{5}MS(2,2)=2.0D0\br +++\tab{5}MS(2,3)=1.0D0\br +++\tab{5}MS(3,1)=0.0D0\br +++\tab{5}MS(3,2)=1.0D0\br +++\tab{5}MS(3,3)=2.0D0\br +++\tab{5}CALL F04ASF(MS,N,X,N,Y,W1,W2,IFLAG)\br +++\tab{5}IFLAG=-IFLAG\br +++\tab{5}RETURN\br +++\tab{5}END Asp34(name): Exports == Implementation where name : Symbol @@ -4631,28 +4616,27 @@ Asp34(name): Exports == Implementation where ++ Related Constructors: FortranVectorFunctionCategory, FortranProgramCategory ++ Description: ++\spadtype{Asp35} produces Fortran for Type 35 ASPs, needed for NAG routines -++\axiomOpFrom{c05pbf}{c05Package}, \axiomOpFrom{c05pcf}{c05Package}, for example: -++\begin{verbatim} -++ SUBROUTINE FCN(N,X,FVEC,FJAC,LDFJAC,IFLAG) -++ DOUBLE PRECISION X(N),FVEC(N),FJAC(LDFJAC,N) -++ INTEGER LDFJAC,N,IFLAG -++ IF(IFLAG.EQ.1)THEN -++ FVEC(1)=(-1.0D0*X(2))+X(1) -++ FVEC(2)=(-1.0D0*X(3))+2.0D0*X(2) -++ FVEC(3)=3.0D0*X(3) -++ ELSEIF(IFLAG.EQ.2)THEN -++ FJAC(1,1)=1.0D0 -++ FJAC(1,2)=-1.0D0 -++ FJAC(1,3)=0.0D0 -++ FJAC(2,1)=0.0D0 -++ FJAC(2,2)=2.0D0 -++ FJAC(2,3)=-1.0D0 -++ FJAC(3,1)=0.0D0 -++ FJAC(3,2)=0.0D0 -++ FJAC(3,3)=3.0D0 -++ ENDIF -++ END -++\end{verbatim} +++c05pbf, c05pcf, for example: +++ +++\tab{5}SUBROUTINE FCN(N,X,FVEC,FJAC,LDFJAC,IFLAG)\br +++\tab{5}DOUBLE PRECISION X(N),FVEC(N),FJAC(LDFJAC,N)\br +++\tab{5}INTEGER LDFJAC,N,IFLAG\br +++\tab{5}IF(IFLAG.EQ.1)THEN\br +++\tab{7}FVEC(1)=(-1.0D0*X(2))+X(1)\br +++\tab{7}FVEC(2)=(-1.0D0*X(3))+2.0D0*X(2)\br +++\tab{7}FVEC(3)=3.0D0*X(3)\br +++\tab{5}ELSEIF(IFLAG.EQ.2)THEN\br +++\tab{7}FJAC(1,1)=1.0D0\br +++\tab{7}FJAC(1,2)=-1.0D0\br +++\tab{7}FJAC(1,3)=0.0D0\br +++\tab{7}FJAC(2,1)=0.0D0\br +++\tab{7}FJAC(2,2)=2.0D0\br +++\tab{7}FJAC(2,3)=-1.0D0\br +++\tab{7}FJAC(3,1)=0.0D0\br +++\tab{7}FJAC(3,2)=0.0D0\br +++\tab{7}FJAC(3,3)=3.0D0\br +++\tab{5}ENDIF\br +++\tab{5}END Asp35(name): Exports == Implementation where name : Symbol @@ -4821,15 +4805,14 @@ Asp35(name): Exports == Implementation where ++ Description: ++\spadtype{Asp4} produces Fortran for Type 4 ASPs, which take an expression ++in X(1) .. X(NDIM) and produce a real function of the form: -++\begin{verbatim} -++ DOUBLE PRECISION FUNCTION FUNCTN(NDIM,X) -++ DOUBLE PRECISION X(NDIM) -++ INTEGER NDIM -++ FUNCTN=(4.0D0*X(1)*X(3)**2*DEXP(2.0D0*X(1)*X(3)))/(X(4)**2+(2.0D0* -++ &X(2)+2.0D0)*X(4)+X(2)**2+2.0D0*X(2)+1.0D0) -++ RETURN -++ END -++\end{verbatim} +++ +++\tab{5}DOUBLE PRECISION FUNCTION FUNCTN(NDIM,X)\br +++\tab{5}DOUBLE PRECISION X(NDIM)\br +++\tab{5}INTEGER NDIM\br +++\tab{5}FUNCTN=(4.0D0*X(1)*X(3)**2*DEXP(2.0D0*X(1)*X(3)))/(X(4)**2+(2.0D0*\br +++\tab{4}&X(2)+2.0D0)*X(4)+X(2)**2+2.0D0*X(2)+1.0D0)\br +++\tab{5}RETURN\br +++\tab{5}END Asp4(name): Exports == Implementation where name : Symbol @@ -4947,43 +4930,40 @@ Asp4(name): Exports == Implementation where ++ Related Constructors: FortranFunctionCategory, FortranProgramCategory. ++ Description: ++\spadtype{Asp41} produces Fortran for Type 41 ASPs, needed for NAG -++routines \axiomOpFrom{d02raf}{d02Package} and -++\axiomOpFrom{d02saf}{d02Package} -++in particular. These ASPs are in fact +++routines d02raf and d02saf in particular. These ASPs are in fact ++three Fortran routines which return a vector of functions, and their ++derivatives wrt Y(i) and also a continuation parameter EPS, for example: -++\begin{verbatim} -++ SUBROUTINE FCN(X,EPS,Y,F,N) -++ DOUBLE PRECISION EPS,F(N),X,Y(N) -++ INTEGER N -++ F(1)=Y(2) -++ F(2)=Y(3) -++ F(3)=(-1.0D0*Y(1)*Y(3))+2.0D0*EPS*Y(2)**2+(-2.0D0*EPS) -++ RETURN -++ END -++ SUBROUTINE JACOBF(X,EPS,Y,F,N) -++ DOUBLE PRECISION EPS,F(N,N),X,Y(N) -++ INTEGER N -++ F(1,1)=0.0D0 -++ F(1,2)=1.0D0 -++ F(1,3)=0.0D0 -++ F(2,1)=0.0D0 -++ F(2,2)=0.0D0 -++ F(2,3)=1.0D0 -++ F(3,1)=-1.0D0*Y(3) -++ F(3,2)=4.0D0*EPS*Y(2) -++ F(3,3)=-1.0D0*Y(1) -++ RETURN -++ END -++ SUBROUTINE JACEPS(X,EPS,Y,F,N) -++ DOUBLE PRECISION EPS,F(N),X,Y(N) -++ INTEGER N -++ F(1)=0.0D0 -++ F(2)=0.0D0 -++ F(3)=2.0D0*Y(2)**2-2.0D0 -++ RETURN -++ END -++\end{verbatim} +++ +++\tab{5}SUBROUTINE FCN(X,EPS,Y,F,N)\br +++\tab{5}DOUBLE PRECISION EPS,F(N),X,Y(N)\br +++\tab{5}INTEGER N\br +++\tab{5}F(1)=Y(2)\br +++\tab{5}F(2)=Y(3)\br +++\tab{5}F(3)=(-1.0D0*Y(1)*Y(3))+2.0D0*EPS*Y(2)**2+(-2.0D0*EPS)\br +++\tab{5}RETURN\br +++\tab{5}END\br +++\tab{5}SUBROUTINE JACOBF(X,EPS,Y,F,N)\br +++\tab{5}DOUBLE PRECISION EPS,F(N,N),X,Y(N)\br +++\tab{5}INTEGER N\br +++\tab{5}F(1,1)=0.0D0\br +++\tab{5}F(1,2)=1.0D0\br +++\tab{5}F(1,3)=0.0D0\br +++\tab{5}F(2,1)=0.0D0\br +++\tab{5}F(2,2)=0.0D0\br +++\tab{5}F(2,3)=1.0D0\br +++\tab{5}F(3,1)=-1.0D0*Y(3)\br +++\tab{5}F(3,2)=4.0D0*EPS*Y(2)\br +++\tab{5}F(3,3)=-1.0D0*Y(1)\br +++\tab{5}RETURN\br +++\tab{5}END\br +++\tab{5}SUBROUTINE JACEPS(X,EPS,Y,F,N)\br +++\tab{5}DOUBLE PRECISION EPS,F(N),X,Y(N)\br +++\tab{5}INTEGER N\br +++\tab{5}F(1)=0.0D0\br +++\tab{5}F(2)=0.0D0\br +++\tab{5}F(3)=2.0D0*Y(2)**2-2.0D0\br +++\tab{5}RETURN\br +++\tab{5}END Asp41(nameOne,nameTwo,nameThree): Exports == Implementation where nameOne : Symbol @@ -5184,51 +5164,50 @@ Asp41(nameOne,nameTwo,nameThree): Exports == Implementation where ++ Related Constructors: FortranFunctionCategory, FortranProgramCategory. ++ Description: ++\spadtype{Asp42} produces Fortran for Type 42 ASPs, needed for NAG -++routines \axiomOpFrom{d02raf}{d02Package} and \axiomOpFrom{d02saf}{d02Package} +++routines d02raf and d02saf ++in particular. These ASPs are in fact ++three Fortran routines which return a vector of functions, and their ++derivatives wrt Y(i) and also a continuation parameter EPS, for example: -++\begin{verbatim} -++ SUBROUTINE G(EPS,YA,YB,BC,N) -++ DOUBLE PRECISION EPS,YA(N),YB(N),BC(N) -++ INTEGER N -++ BC(1)=YA(1) -++ BC(2)=YA(2) -++ BC(3)=YB(2)-1.0D0 -++ RETURN -++ END -++ SUBROUTINE JACOBG(EPS,YA,YB,AJ,BJ,N) -++ DOUBLE PRECISION EPS,YA(N),AJ(N,N),BJ(N,N),YB(N) -++ INTEGER N -++ AJ(1,1)=1.0D0 -++ AJ(1,2)=0.0D0 -++ AJ(1,3)=0.0D0 -++ AJ(2,1)=0.0D0 -++ AJ(2,2)=1.0D0 -++ AJ(2,3)=0.0D0 -++ AJ(3,1)=0.0D0 -++ AJ(3,2)=0.0D0 -++ AJ(3,3)=0.0D0 -++ BJ(1,1)=0.0D0 -++ BJ(1,2)=0.0D0 -++ BJ(1,3)=0.0D0 -++ BJ(2,1)=0.0D0 -++ BJ(2,2)=0.0D0 -++ BJ(2,3)=0.0D0 -++ BJ(3,1)=0.0D0 -++ BJ(3,2)=1.0D0 -++ BJ(3,3)=0.0D0 -++ RETURN -++ END -++ SUBROUTINE JACGEP(EPS,YA,YB,BCEP,N) -++ DOUBLE PRECISION EPS,YA(N),YB(N),BCEP(N) -++ INTEGER N -++ BCEP(1)=0.0D0 -++ BCEP(2)=0.0D0 -++ BCEP(3)=0.0D0 -++ RETURN -++ END -++\end{verbatim} +++ +++\tab{5}SUBROUTINE G(EPS,YA,YB,BC,N)\br +++\tab{5}DOUBLE PRECISION EPS,YA(N),YB(N),BC(N)\br +++\tab{5}INTEGER N\br +++\tab{5}BC(1)=YA(1)\br +++\tab{5}BC(2)=YA(2)\br +++\tab{5}BC(3)=YB(2)-1.0D0\br +++\tab{5}RETURN\br +++\tab{5}END\br +++\tab{5}SUBROUTINE JACOBG(EPS,YA,YB,AJ,BJ,N)\br +++\tab{5}DOUBLE PRECISION EPS,YA(N),AJ(N,N),BJ(N,N),YB(N)\br +++\tab{5}INTEGER N\br +++\tab{5}AJ(1,1)=1.0D0\br +++\tab{5}AJ(1,2)=0.0D0\br +++\tab{5}AJ(1,3)=0.0D0\br +++\tab{5}AJ(2,1)=0.0D0\br +++\tab{5}AJ(2,2)=1.0D0\br +++\tab{5}AJ(2,3)=0.0D0\br +++\tab{5}AJ(3,1)=0.0D0\br +++\tab{5}AJ(3,2)=0.0D0\br +++\tab{5}AJ(3,3)=0.0D0\br +++\tab{5}BJ(1,1)=0.0D0\br +++\tab{5}BJ(1,2)=0.0D0\br +++\tab{5}BJ(1,3)=0.0D0\br +++\tab{5}BJ(2,1)=0.0D0\br +++\tab{5}BJ(2,2)=0.0D0\br +++\tab{5}BJ(2,3)=0.0D0\br +++\tab{5}BJ(3,1)=0.0D0\br +++\tab{5}BJ(3,2)=1.0D0\br +++\tab{5}BJ(3,3)=0.0D0\br +++\tab{5}RETURN\br +++\tab{5}END\br +++\tab{5}SUBROUTINE JACGEP(EPS,YA,YB,BCEP,N)\br +++\tab{5}DOUBLE PRECISION EPS,YA(N),YB(N),BCEP(N)\br +++\tab{5}INTEGER N\br +++\tab{5}BCEP(1)=0.0D0\br +++\tab{5}BCEP(2)=0.0D0\br +++\tab{5}BCEP(3)=0.0D0\br +++\tab{5}RETURN\br +++\tab{5}END Asp42(nameOne,nameTwo,nameThree): Exports == Implementation where nameOne : Symbol @@ -5441,25 +5420,24 @@ Asp42(nameOne,nameTwo,nameThree): Exports == Implementation where ++ Related Constructors: FortranScalarFunctionCategory, FortranProgramCategory ++ Description: ++\spadtype{Asp49} produces Fortran for Type 49 ASPs, needed for NAG routines -++\axiomOpFrom{e04dgf}{e04Package}, \axiomOpFrom{e04ucf}{e04Package}, for example: -++\begin{verbatim} -++ SUBROUTINE OBJFUN(MODE,N,X,OBJF,OBJGRD,NSTATE,IUSER,USER) -++ DOUBLE PRECISION X(N),OBJF,OBJGRD(N),USER(*) -++ INTEGER N,IUSER(*),MODE,NSTATE -++ OBJF=X(4)*X(9)+((-1.0D0*X(5))+X(3))*X(8)+((-1.0D0*X(3))+X(1))*X(7) -++ &+(-1.0D0*X(2)*X(6)) -++ OBJGRD(1)=X(7) -++ OBJGRD(2)=-1.0D0*X(6) -++ OBJGRD(3)=X(8)+(-1.0D0*X(7)) -++ OBJGRD(4)=X(9) -++ OBJGRD(5)=-1.0D0*X(8) -++ OBJGRD(6)=-1.0D0*X(2) -++ OBJGRD(7)=(-1.0D0*X(3))+X(1) -++ OBJGRD(8)=(-1.0D0*X(5))+X(3) -++ OBJGRD(9)=X(4) -++ RETURN -++ END -++\end{verbatim} +++e04dgf, e04ucf, for example: +++ +++\tab{5}SUBROUTINE OBJFUN(MODE,N,X,OBJF,OBJGRD,NSTATE,IUSER,USER)\br +++\tab{5}DOUBLE PRECISION X(N),OBJF,OBJGRD(N),USER(*)\br +++\tab{5}INTEGER N,IUSER(*),MODE,NSTATE\br +++\tab{5}OBJF=X(4)*X(9)+((-1.0D0*X(5))+X(3))*X(8)+((-1.0D0*X(3))+X(1))*X(7)\br +++\tab{4}&+(-1.0D0*X(2)*X(6))\br +++\tab{5}OBJGRD(1)=X(7)\br +++\tab{5}OBJGRD(2)=-1.0D0*X(6)\br +++\tab{5}OBJGRD(3)=X(8)+(-1.0D0*X(7))\br +++\tab{5}OBJGRD(4)=X(9)\br +++\tab{5}OBJGRD(5)=-1.0D0*X(8)\br +++\tab{5}OBJGRD(6)=-1.0D0*X(2)\br +++\tab{5}OBJGRD(7)=(-1.0D0*X(3))+X(1)\br +++\tab{5}OBJGRD(8)=(-1.0D0*X(5))+X(3)\br +++\tab{5}OBJGRD(9)=X(4)\br +++\tab{5}RETURN\br +++\tab{5}END Asp49(name): Exports == Implementation where name : Symbol @@ -5604,43 +5582,42 @@ Asp49(name): Exports == Implementation where ++ Related Constructors: FortranVectorFunctionCategory, FortranProgramCategory ++ Description: ++\spadtype{Asp50} produces Fortran for Type 50 ASPs, needed for NAG routine -++\axiomOpFrom{e04fdf}{e04Package}, for example: -++\begin{verbatim} -++ SUBROUTINE LSFUN1(M,N,XC,FVECC) -++ DOUBLE PRECISION FVECC(M),XC(N) -++ INTEGER I,M,N -++ FVECC(1)=((XC(1)-2.4D0)*XC(3)+(15.0D0*XC(1)-36.0D0)*XC(2)+1.0D0)/( -++ &XC(3)+15.0D0*XC(2)) -++ FVECC(2)=((XC(1)-2.8D0)*XC(3)+(7.0D0*XC(1)-19.6D0)*XC(2)+1.0D0)/(X -++ &C(3)+7.0D0*XC(2)) -++ FVECC(3)=((XC(1)-3.2D0)*XC(3)+(4.333333333333333D0*XC(1)-13.866666 -++ &66666667D0)*XC(2)+1.0D0)/(XC(3)+4.333333333333333D0*XC(2)) -++ FVECC(4)=((XC(1)-3.5D0)*XC(3)+(3.0D0*XC(1)-10.5D0)*XC(2)+1.0D0)/(X -++ &C(3)+3.0D0*XC(2)) -++ FVECC(5)=((XC(1)-3.9D0)*XC(3)+(2.2D0*XC(1)-8.579999999999998D0)*XC -++ &(2)+1.0D0)/(XC(3)+2.2D0*XC(2)) -++ FVECC(6)=((XC(1)-4.199999999999999D0)*XC(3)+(1.666666666666667D0*X -++ &C(1)-7.0D0)*XC(2)+1.0D0)/(XC(3)+1.666666666666667D0*XC(2)) -++ FVECC(7)=((XC(1)-4.5D0)*XC(3)+(1.285714285714286D0*XC(1)-5.7857142 -++ &85714286D0)*XC(2)+1.0D0)/(XC(3)+1.285714285714286D0*XC(2)) -++ FVECC(8)=((XC(1)-4.899999999999999D0)*XC(3)+(XC(1)-4.8999999999999 -++ &99D0)*XC(2)+1.0D0)/(XC(3)+XC(2)) -++ FVECC(9)=((XC(1)-4.699999999999999D0)*XC(3)+(XC(1)-4.6999999999999 -++ &99D0)*XC(2)+1.285714285714286D0)/(XC(3)+XC(2)) -++ FVECC(10)=((XC(1)-6.8D0)*XC(3)+(XC(1)-6.8D0)*XC(2)+1.6666666666666 -++ &67D0)/(XC(3)+XC(2)) -++ FVECC(11)=((XC(1)-8.299999999999999D0)*XC(3)+(XC(1)-8.299999999999 -++ &999D0)*XC(2)+2.2D0)/(XC(3)+XC(2)) -++ FVECC(12)=((XC(1)-10.6D0)*XC(3)+(XC(1)-10.6D0)*XC(2)+3.0D0)/(XC(3) -++ &+XC(2)) -++ FVECC(13)=((XC(1)-1.34D0)*XC(3)+(XC(1)-1.34D0)*XC(2)+4.33333333333 -++ &3333D0)/(XC(3)+XC(2)) -++ FVECC(14)=((XC(1)-2.1D0)*XC(3)+(XC(1)-2.1D0)*XC(2)+7.0D0)/(XC(3)+X -++ &C(2)) -++ FVECC(15)=((XC(1)-4.39D0)*XC(3)+(XC(1)-4.39D0)*XC(2)+15.0D0)/(XC(3 -++ &)+XC(2)) -++ END -++\end{verbatim} +++e04fdf, for example: +++ +++\tab{5}SUBROUTINE LSFUN1(M,N,XC,FVECC)\br +++\tab{5}DOUBLE PRECISION FVECC(M),XC(N)\br +++\tab{5}INTEGER I,M,N\br +++\tab{5}FVECC(1)=((XC(1)-2.4D0)*XC(3)+(15.0D0*XC(1)-36.0D0)*XC(2)+1.0D0)/(\br +++\tab{4}&XC(3)+15.0D0*XC(2))\br +++\tab{5}FVECC(2)=((XC(1)-2.8D0)*XC(3)+(7.0D0*XC(1)-19.6D0)*XC(2)+1.0D0)/(X\br +++\tab{4}&C(3)+7.0D0*XC(2))\br +++\tab{5}FVECC(3)=((XC(1)-3.2D0)*XC(3)+(4.333333333333333D0*XC(1)-13.866666\br +++\tab{4}&66666667D0)*XC(2)+1.0D0)/(XC(3)+4.333333333333333D0*XC(2))\br +++\tab{5}FVECC(4)=((XC(1)-3.5D0)*XC(3)+(3.0D0*XC(1)-10.5D0)*XC(2)+1.0D0)/(X\br +++\tab{4}&C(3)+3.0D0*XC(2))\br +++\tab{5}FVECC(5)=((XC(1)-3.9D0)*XC(3)+(2.2D0*XC(1)-8.579999999999998D0)*XC\br +++\tab{4}&(2)+1.0D0)/(XC(3)+2.2D0*XC(2))\br +++\tab{5}FVECC(6)=((XC(1)-4.199999999999999D0)*XC(3)+(1.666666666666667D0*X\br +++\tab{4}&C(1)-7.0D0)*XC(2)+1.0D0)/(XC(3)+1.666666666666667D0*XC(2))\br +++\tab{5}FVECC(7)=((XC(1)-4.5D0)*XC(3)+(1.285714285714286D0*XC(1)-5.7857142\br +++\tab{4}&85714286D0)*XC(2)+1.0D0)/(XC(3)+1.285714285714286D0*XC(2))\br +++\tab{5}FVECC(8)=((XC(1)-4.899999999999999D0)*XC(3)+(XC(1)-4.8999999999999\br +++\tab{4}&99D0)*XC(2)+1.0D0)/(XC(3)+XC(2))\br +++\tab{5}FVECC(9)=((XC(1)-4.699999999999999D0)*XC(3)+(XC(1)-4.6999999999999\br +++\tab{4}&99D0)*XC(2)+1.285714285714286D0)/(XC(3)+XC(2))\br +++\tab{5}FVECC(10)=((XC(1)-6.8D0)*XC(3)+(XC(1)-6.8D0)*XC(2)+1.6666666666666\br +++\tab{4}&67D0)/(XC(3)+XC(2))\br +++\tab{5}FVECC(11)=((XC(1)-8.299999999999999D0)*XC(3)+(XC(1)-8.299999999999\br +++\tab{4}&999D0)*XC(2)+2.2D0)/(XC(3)+XC(2))\br +++\tab{5}FVECC(12)=((XC(1)-10.6D0)*XC(3)+(XC(1)-10.6D0)*XC(2)+3.0D0)/(XC(3)\br +++\tab{4}&+XC(2))\br +++\tab{5}FVECC(13)=((XC(1)-1.34D0)*XC(3)+(XC(1)-1.34D0)*XC(2)+4.33333333333\br +++\tab{4}&3333D0)/(XC(3)+XC(2))\br +++\tab{5}FVECC(14)=((XC(1)-2.1D0)*XC(3)+(XC(1)-2.1D0)*XC(2)+7.0D0)/(XC(3)+X\br +++\tab{4}&C(2))\br +++\tab{5}FVECC(15)=((XC(1)-4.39D0)*XC(3)+(XC(1)-4.39D0)*XC(2)+15.0D0)/(XC(3\br +++\tab{4}&)+XC(2))\br +++\tab{5}END Asp50(name): Exports == Implementation where name : Symbol @@ -5783,42 +5760,41 @@ Asp50(name): Exports == Implementation where ++ Related Constructors: FortranScalarFunctionCategory, FortranProgramCategory ++ Description: ++\spadtype{Asp55} produces Fortran for Type 55 ASPs, needed for NAG routines -++\axiomOpFrom{e04dgf}{e04Package} and \axiomOpFrom{e04ucf}{e04Package}, for example: -++\begin{verbatim} -++ SUBROUTINE CONFUN(MODE,NCNLN,N,NROWJ,NEEDC,X,C,CJAC,NSTATE,IUSER -++ &,USER) -++ DOUBLE PRECISION C(NCNLN),X(N),CJAC(NROWJ,N),USER(*) -++ INTEGER N,IUSER(*),NEEDC(NCNLN),NROWJ,MODE,NCNLN,NSTATE -++ IF(NEEDC(1).GT.0)THEN -++ C(1)=X(6)**2+X(1)**2 -++ CJAC(1,1)=2.0D0*X(1) -++ CJAC(1,2)=0.0D0 -++ CJAC(1,3)=0.0D0 -++ CJAC(1,4)=0.0D0 -++ CJAC(1,5)=0.0D0 -++ CJAC(1,6)=2.0D0*X(6) -++ ENDIF -++ IF(NEEDC(2).GT.0)THEN -++ C(2)=X(2)**2+(-2.0D0*X(1)*X(2))+X(1)**2 -++ CJAC(2,1)=(-2.0D0*X(2))+2.0D0*X(1) -++ CJAC(2,2)=2.0D0*X(2)+(-2.0D0*X(1)) -++ CJAC(2,3)=0.0D0 -++ CJAC(2,4)=0.0D0 -++ CJAC(2,5)=0.0D0 -++ CJAC(2,6)=0.0D0 -++ ENDIF -++ IF(NEEDC(3).GT.0)THEN -++ C(3)=X(3)**2+(-2.0D0*X(1)*X(3))+X(2)**2+X(1)**2 -++ CJAC(3,1)=(-2.0D0*X(3))+2.0D0*X(1) -++ CJAC(3,2)=2.0D0*X(2) -++ CJAC(3,3)=2.0D0*X(3)+(-2.0D0*X(1)) -++ CJAC(3,4)=0.0D0 -++ CJAC(3,5)=0.0D0 -++ CJAC(3,6)=0.0D0 -++ ENDIF -++ RETURN -++ END -++\end{verbatim} +++e04dgf and e04ucf, for example: +++ +++\tab{5}SUBROUTINE CONFUN(MODE,NCNLN,N,NROWJ,NEEDC,X,C,CJAC,NSTATE,IUSER\br +++\tab{4}&,USER)\br +++\tab{5}DOUBLE PRECISION C(NCNLN),X(N),CJAC(NROWJ,N),USER(*)\br +++\tab{5}INTEGER N,IUSER(*),NEEDC(NCNLN),NROWJ,MODE,NCNLN,NSTATE\br +++\tab{5}IF(NEEDC(1).GT.0)THEN\br +++\tab{7}C(1)=X(6)**2+X(1)**2\br +++\tab{7}CJAC(1,1)=2.0D0*X(1)\br +++\tab{7}CJAC(1,2)=0.0D0\br +++\tab{7}CJAC(1,3)=0.0D0\br +++\tab{7}CJAC(1,4)=0.0D0\br +++\tab{7}CJAC(1,5)=0.0D0\br +++\tab{7}CJAC(1,6)=2.0D0*X(6)\br +++\tab{5}ENDIF\br +++\tab{5}IF(NEEDC(2).GT.0)THEN\br +++\tab{7}C(2)=X(2)**2+(-2.0D0*X(1)*X(2))+X(1)**2\br +++\tab{7}CJAC(2,1)=(-2.0D0*X(2))+2.0D0*X(1)\br +++\tab{7}CJAC(2,2)=2.0D0*X(2)+(-2.0D0*X(1))\br +++\tab{7}CJAC(2,3)=0.0D0\br +++\tab{7}CJAC(2,4)=0.0D0\br +++\tab{7}CJAC(2,5)=0.0D0\br +++\tab{7}CJAC(2,6)=0.0D0\br +++\tab{5}ENDIF\br +++\tab{5}IF(NEEDC(3).GT.0)THEN\br +++\tab{7}C(3)=X(3)**2+(-2.0D0*X(1)*X(3))+X(2)**2+X(1)**2\br +++\tab{7}CJAC(3,1)=(-2.0D0*X(3))+2.0D0*X(1)\br +++\tab{7}CJAC(3,2)=2.0D0*X(2)\br +++\tab{7}CJAC(3,3)=2.0D0*X(3)+(-2.0D0*X(1))\br +++\tab{7}CJAC(3,4)=0.0D0\br +++\tab{7}CJAC(3,5)=0.0D0\br +++\tab{7}CJAC(3,6)=0.0D0\br +++\tab{5}ENDIF\br +++\tab{5}RETURN\br +++\tab{5}END Asp55(name): Exports == Implementation where name : Symbol @@ -6005,31 +5981,29 @@ Asp55(name): Exports == Implementation where ++ Related Constructors: FortranVectorFunctionCategory, FortranProgramCategory ++ Description: ++ \spadtype{Asp6} produces Fortran for Type 6 ASPs, needed for NAG routines -++ \axiomOpFrom{c05nbf}{c05Package}, \axiomOpFrom{c05ncf}{c05Package}. -++ These represent vectors of functions of X(i) and look like: -++ \begin{verbatim} -++ SUBROUTINE FCN(N,X,FVEC,IFLAG) -++ DOUBLE PRECISION X(N),FVEC(N) -++ INTEGER N,IFLAG -++ FVEC(1)=(-2.0D0*X(2))+(-2.0D0*X(1)**2)+3.0D0*X(1)+1.0D0 -++ FVEC(2)=(-2.0D0*X(3))+(-2.0D0*X(2)**2)+3.0D0*X(2)+(-1.0D0*X(1))+1. -++ &0D0 -++ FVEC(3)=(-2.0D0*X(4))+(-2.0D0*X(3)**2)+3.0D0*X(3)+(-1.0D0*X(2))+1. -++ &0D0 -++ FVEC(4)=(-2.0D0*X(5))+(-2.0D0*X(4)**2)+3.0D0*X(4)+(-1.0D0*X(3))+1. -++ &0D0 -++ FVEC(5)=(-2.0D0*X(6))+(-2.0D0*X(5)**2)+3.0D0*X(5)+(-1.0D0*X(4))+1. -++ &0D0 -++ FVEC(6)=(-2.0D0*X(7))+(-2.0D0*X(6)**2)+3.0D0*X(6)+(-1.0D0*X(5))+1. -++ &0D0 -++ FVEC(7)=(-2.0D0*X(8))+(-2.0D0*X(7)**2)+3.0D0*X(7)+(-1.0D0*X(6))+1. -++ &0D0 -++ FVEC(8)=(-2.0D0*X(9))+(-2.0D0*X(8)**2)+3.0D0*X(8)+(-1.0D0*X(7))+1. -++ &0D0 -++ FVEC(9)=(-2.0D0*X(9)**2)+3.0D0*X(9)+(-1.0D0*X(8))+1.0D0 -++ RETURN -++ END -++ \end{verbatim} +++ c05nbf, c05ncf. These represent vectors of functions of X(i) and look like: +++ +++ \tab{5}SUBROUTINE FCN(N,X,FVEC,IFLAG) +++ \tab{5}DOUBLE PRECISION X(N),FVEC(N) +++ \tab{5}INTEGER N,IFLAG +++ \tab{5}FVEC(1)=(-2.0D0*X(2))+(-2.0D0*X(1)**2)+3.0D0*X(1)+1.0D0 +++ \tab{5}FVEC(2)=(-2.0D0*X(3))+(-2.0D0*X(2)**2)+3.0D0*X(2)+(-1.0D0*X(1))+1. +++ \tab{4}&0D0 +++ \tab{5}FVEC(3)=(-2.0D0*X(4))+(-2.0D0*X(3)**2)+3.0D0*X(3)+(-1.0D0*X(2))+1. +++ \tab{4}&0D0 +++ \tab{5}FVEC(4)=(-2.0D0*X(5))+(-2.0D0*X(4)**2)+3.0D0*X(4)+(-1.0D0*X(3))+1. +++ \tab{4}&0D0 +++ \tab{5}FVEC(5)=(-2.0D0*X(6))+(-2.0D0*X(5)**2)+3.0D0*X(5)+(-1.0D0*X(4))+1. +++ \tab{4}&0D0 +++ \tab{5}FVEC(6)=(-2.0D0*X(7))+(-2.0D0*X(6)**2)+3.0D0*X(6)+(-1.0D0*X(5))+1. +++ \tab{4}&0D0 +++ \tab{5}FVEC(7)=(-2.0D0*X(8))+(-2.0D0*X(7)**2)+3.0D0*X(7)+(-1.0D0*X(6))+1. +++ \tab{4}&0D0 +++ \tab{5}FVEC(8)=(-2.0D0*X(9))+(-2.0D0*X(8)**2)+3.0D0*X(8)+(-1.0D0*X(7))+1. +++ \tab{4}&0D0 +++ \tab{5}FVEC(9)=(-2.0D0*X(9)**2)+3.0D0*X(9)+(-1.0D0*X(8))+1.0D0 +++ \tab{5}RETURN +++ \tab{5}END Asp6(name): Exports == Implementation where name : Symbol @@ -6080,7 +6054,8 @@ Asp6(name): Exports == Implementation where v::$ retractIfCan(u:VEC FRAC POLY FLOAT):Union($,"failed") == - v:Union(VEC FEXPR,"failed"):=map(retractIfCan,u)$VF2(FRAC POLY FLOAT,FEXPR) + v:Union(VEC FEXPR,"failed"):=_ + map(retractIfCan,u)$VF2(FRAC POLY FLOAT,FEXPR) v case "failed" => "failed" (v::VEC FEXPR)::$ @@ -6170,19 +6145,17 @@ Asp6(name): Exports == Implementation where ++ Related Constructors: FortranVectorFunctionCategory, FortranProgramCategory ++ Description: ++ \spadtype{Asp7} produces Fortran for Type 7 ASPs, needed for NAG routines -++ \axiomOpFrom{d02bbf}{d02Package}, \axiomOpFrom{d02gaf}{d02Package}. -++ These represent a vector of functions of the scalar X and +++ d02bbf, d02gaf. These represent a vector of functions of the scalar X and ++ the array Z, and look like: -++ \begin{verbatim} -++ SUBROUTINE FCN(X,Z,F) -++ DOUBLE PRECISION F(*),X,Z(*) -++ F(1)=DTAN(Z(3)) -++ F(2)=((-0.03199999999999999D0*DCOS(Z(3))*DTAN(Z(3)))+(-0.02D0*Z(2) -++ &**2))/(Z(2)*DCOS(Z(3))) -++ F(3)=-0.03199999999999999D0/(X*Z(2)**2) -++ RETURN -++ END -++ \end{verbatim} +++ +++ \tab{5}SUBROUTINE FCN(X,Z,F)\br +++ \tab{5}DOUBLE PRECISION F(*),X,Z(*)\br +++ \tab{5}F(1)=DTAN(Z(3))\br +++ \tab{5}F(2)=((-0.03199999999999999D0*DCOS(Z(3))*DTAN(Z(3)))+(-0.02D0*Z(2)\br +++ \tab{4}&**2))/(Z(2)*DCOS(Z(3)))\br +++ \tab{5}F(3)=-0.03199999999999999D0/(X*Z(2)**2)\br +++ \tab{5}RETURN\br +++ \tab{5}END Asp7(name): Exports == Implementation where name : Symbol @@ -6316,25 +6289,23 @@ Asp7(name): Exports == Implementation where )abbrev domain ASP73 Asp73 ++ Author: Mike Dewar, Grant Keady and Godfrey Nolan ++ Date Created: Mar 1993 -++ Date Last Updated: 30 March 1994 -++ 6 October 1994 +++ Date Last Updated: 30 March 1994, 6 October 1994 ++ Related Constructors: FortranVectorFunctionCategory, FortranProgramCategory ++ Description: -++\spadtype{Asp73} produces Fortran for Type 73 ASPs, needed for NAG routine -++\axiomOpFrom{d03eef}{d03Package}, for example: -++\begin{verbatim} -++ SUBROUTINE PDEF(X,Y,ALPHA,BETA,GAMMA,DELTA,EPSOLN,PHI,PSI) -++ DOUBLE PRECISION ALPHA,EPSOLN,PHI,X,Y,BETA,DELTA,GAMMA,PSI -++ ALPHA=DSIN(X) -++ BETA=Y -++ GAMMA=X*Y -++ DELTA=DCOS(X)*DSIN(Y) -++ EPSOLN=Y+X -++ PHI=X -++ PSI=Y -++ RETURN -++ END -++\end{verbatim} +++ \spadtype{Asp73} produces Fortran for Type 73 ASPs, needed for NAG routine +++ d03eef, for example: +++ +++ \tab{5}SUBROUTINE PDEF(X,Y,ALPHA,BETA,GAMMA,DELTA,EPSOLN,PHI,PSI)\br +++ \tab{5}DOUBLE PRECISION ALPHA,EPSOLN,PHI,X,Y,BETA,DELTA,GAMMA,PSI\br +++ \tab{5}ALPHA=DSIN(X)\br +++ \tab{5}BETA=Y\br +++ \tab{5}GAMMA=X*Y\br +++ \tab{5}DELTA=DCOS(X)*DSIN(Y)\br +++ \tab{5}EPSOLN=Y+X\br +++ \tab{5}PHI=X\br +++ \tab{5}PSI=Y\br +++ \tab{5}RETURN\br +++ \tab{5}END Asp73(name): Exports == Implementation where name : Symbol @@ -6483,31 +6454,30 @@ Asp73(name): Exports == Implementation where ++ 6 October 1994 ++ Related Constructors: FortranScalarFunctionCategory, FortranProgramCategory. ++ Description: -++\spadtype{Asp74} produces Fortran for Type 74 ASPs, needed for NAG routine -++\axiomOpFrom{d03eef}{d03Package}, for example: -++\begin{verbatim} -++ SUBROUTINE BNDY(X,Y,A,B,C,IBND) -++ DOUBLE PRECISION A,B,C,X,Y -++ INTEGER IBND -++ IF(IBND.EQ.0)THEN -++ A=0.0D0 -++ B=1.0D0 -++ C=-1.0D0*DSIN(X) -++ ELSEIF(IBND.EQ.1)THEN -++ A=1.0D0 -++ B=0.0D0 -++ C=DSIN(X)*DSIN(Y) -++ ELSEIF(IBND.EQ.2)THEN -++ A=1.0D0 -++ B=0.0D0 -++ C=DSIN(X)*DSIN(Y) -++ ELSEIF(IBND.EQ.3)THEN -++ A=0.0D0 -++ B=1.0D0 -++ C=-1.0D0*DSIN(Y) -++ ENDIF -++ END -++\end{verbatim} +++ \spadtype{Asp74} produces Fortran for Type 74 ASPs, needed for NAG routine +++ d03eef, for example: +++ +++ \tab{5} SUBROUTINE BNDY(X,Y,A,B,C,IBND)\br +++ \tab{5} DOUBLE PRECISION A,B,C,X,Y\br +++ \tab{5} INTEGER IBND\br +++ \tab{5} IF(IBND.EQ.0)THEN\br +++ \tab{7} A=0.0D0\br +++ \tab{7} B=1.0D0\br +++ \tab{7} C=-1.0D0*DSIN(X)\br +++ \tab{5} ELSEIF(IBND.EQ.1)THEN\br +++ \tab{7} A=1.0D0\br +++ \tab{7} B=0.0D0\br +++ \tab{7} C=DSIN(X)*DSIN(Y)\br +++ \tab{5} ELSEIF(IBND.EQ.2)THEN\br +++ \tab{7} A=1.0D0\br +++ \tab{7} B=0.0D0\br +++ \tab{7} C=DSIN(X)*DSIN(Y)\br +++ \tab{5} ELSEIF(IBND.EQ.3)THEN\br +++ \tab{7} A=0.0D0\br +++ \tab{7} B=1.0D0\br +++ \tab{7} C=-1.0D0*DSIN(Y)\br +++ \tab{5} ENDIF\br +++ \tab{5} END Asp74(name): Exports == Implementation where name : Symbol @@ -6687,19 +6657,18 @@ Asp74(name): Exports == Implementation where ++ 6 October 1994 ++ Related Constructors: FortranMatrixFunctionCategory, FortranProgramCategory ++ Description: -++\spadtype{Asp77} produces Fortran for Type 77 ASPs, needed for NAG routine -++\axiomOpFrom{d02gbf}{d02Package}, for example: -++\begin{verbatim} -++ SUBROUTINE FCNF(X,F) -++ DOUBLE PRECISION X -++ DOUBLE PRECISION F(2,2) -++ F(1,1)=0.0D0 -++ F(1,2)=1.0D0 -++ F(2,1)=0.0D0 -++ F(2,2)=-10.0D0 -++ RETURN -++ END -++\end{verbatim} +++ \spadtype{Asp77} produces Fortran for Type 77 ASPs, needed for NAG routine +++ d02gbf, for example: +++ +++ \tab{5}SUBROUTINE FCNF(X,F)\br +++ \tab{5}DOUBLE PRECISION X\br +++ \tab{5}DOUBLE PRECISION F(2,2)\br +++ \tab{5}F(1,1)=0.0D0\br +++ \tab{5}F(1,2)=1.0D0\br +++ \tab{5}F(2,1)=0.0D0\br +++ \tab{5}F(2,2)=-10.0D0\br +++ \tab{5}RETURN\br +++ \tab{5}END Asp77(name): Exports == Implementation where name : Symbol @@ -6856,15 +6825,14 @@ Asp77(name): Exports == Implementation where ++ 6 October 1994 ++ Related Constructors: FortranVectorFunctionCategory, FortranProgramCategory ++ Description: -++\spadtype{Asp78} produces Fortran for Type 78 ASPs, needed for NAG routine -++\axiomOpFrom{d02gbf}{d02Package}, for example: -++\begin{verbatim} -++ SUBROUTINE FCNG(X,G) -++ DOUBLE PRECISION G(*),X -++ G(1)=0.0D0 -++ G(2)=0.0D0 -++ END -++\end{verbatim} +++ \spadtype{Asp78} produces Fortran for Type 78 ASPs, needed for NAG routine +++ d02gbf, for example: +++ +++ \tab{5}SUBROUTINE FCNG(X,G)\br +++ \tab{5}DOUBLE PRECISION G(*),X\br +++ \tab{5}G(1)=0.0D0\br +++ \tab{5}G(2)=0.0D0\br +++ \tab{5}END Asp78(name): Exports == Implementation where name : Symbol @@ -7000,40 +6968,39 @@ Asp78(name): Exports == Implementation where ++ 6 October 1994 ++ Related Constructors: FortranVectorFunctionCategory, FortranProgramCategory ++ Description: -++\spadtype{Asp8} produces Fortran for Type 8 ASPs, needed for NAG routine -++\axiomOpFrom{d02bbf}{d02Package}. This ASP prints intermediate values of the computed solution of -++an ODE and might look like: -++\begin{verbatim} -++ SUBROUTINE OUTPUT(XSOL,Y,COUNT,M,N,RESULT,FORWRD) -++ DOUBLE PRECISION Y(N),RESULT(M,N),XSOL -++ INTEGER M,N,COUNT -++ LOGICAL FORWRD -++ DOUBLE PRECISION X02ALF,POINTS(8) -++ EXTERNAL X02ALF -++ INTEGER I -++ POINTS(1)=1.0D0 -++ POINTS(2)=2.0D0 -++ POINTS(3)=3.0D0 -++ POINTS(4)=4.0D0 -++ POINTS(5)=5.0D0 -++ POINTS(6)=6.0D0 -++ POINTS(7)=7.0D0 -++ POINTS(8)=8.0D0 -++ COUNT=COUNT+1 -++ DO 25001 I=1,N -++ RESULT(COUNT,I)=Y(I) -++25001 CONTINUE -++ IF(COUNT.EQ.M)THEN -++ IF(FORWRD)THEN -++ XSOL=X02ALF() -++ ELSE -++ XSOL=-X02ALF() -++ ENDIF -++ ELSE -++ XSOL=POINTS(COUNT) -++ ENDIF -++ END -++\end{verbatim} +++ \spadtype{Asp8} produces Fortran for Type 8 ASPs, needed for NAG routine +++ d02bbf. This ASP prints intermediate values of the computed solution of +++ an ODE and might look like: +++ +++ \tab{5}SUBROUTINE OUTPUT(XSOL,Y,COUNT,M,N,RESULT,FORWRD)\br +++ \tab{5}DOUBLE PRECISION Y(N),RESULT(M,N),XSOL\br +++ \tab{5}INTEGER M,N,COUNT\br +++ \tab{5}LOGICAL FORWRD\br +++ \tab{5}DOUBLE PRECISION X02ALF,POINTS(8)\br +++ \tab{5}EXTERNAL X02ALF\br +++ \tab{5}INTEGER I\br +++ \tab{5}POINTS(1)=1.0D0\br +++ \tab{5}POINTS(2)=2.0D0\br +++ \tab{5}POINTS(3)=3.0D0\br +++ \tab{5}POINTS(4)=4.0D0\br +++ \tab{5}POINTS(5)=5.0D0\br +++ \tab{5}POINTS(6)=6.0D0\br +++ \tab{5}POINTS(7)=7.0D0\br +++ \tab{5}POINTS(8)=8.0D0\br +++ \tab{5}COUNT=COUNT+1\br +++ \tab{5}DO 25001 I=1,N\br +++ \tab{7} RESULT(COUNT,I)=Y(I)\br +++ 25001 CONTINUE\br +++ \tab{5}IF(COUNT.EQ.M)THEN\br +++ \tab{7}IF(FORWRD)THEN\br +++ \tab{9}XSOL=X02ALF()\br +++ \tab{7}ELSE\br +++ \tab{9}XSOL=-X02ALF()\br +++ \tab{7}ENDIF\br +++ \tab{5}ELSE\br +++ \tab{7} XSOL=POINTS(COUNT)\br +++ \tab{5}ENDIF\br +++ \tab{5}END Asp8(name): Exports == Implementation where name : Symbol @@ -7065,7 +7032,8 @@ Asp8(name): Exports == Implementation where declare!(Y,yType,syms)$SYMTAB declare!(FORWRD,fortranLogical(),syms)$SYMTAB declare!(RESULT,construct(real,[M,N],false)$FT,syms)$SYMTAB - Rep := FortranProgram(name,["void"]$UFST,[XSOL,Y,COUNT,M,N,RESULT,FORWRD],syms) + Rep := _ + FortranProgram(name,["void"]$UFST,[XSOL,Y,COUNT,M,N,RESULT,FORWRD],syms) coerce(c:List FC):% == coerce(c)$Rep @@ -7143,18 +7111,17 @@ Asp8(name): Exports == Implementation where ++ 6 October 1994 ++ Related Constructors: FortranMatrixFunctionCategory, FortranProgramCategory ++ Description: -++\spadtype{Asp80} produces Fortran for Type 80 ASPs, needed for NAG routine -++\axiomOpFrom{d02kef}{d02Package}, for example: -++\begin{verbatim} -++ SUBROUTINE BDYVAL(XL,XR,ELAM,YL,YR) -++ DOUBLE PRECISION ELAM,XL,YL(3),XR,YR(3) -++ YL(1)=XL -++ YL(2)=2.0D0 -++ YR(1)=1.0D0 -++ YR(2)=-1.0D0*DSQRT(XR+(-1.0D0*ELAM)) -++ RETURN -++ END -++\end{verbatim} +++ \spadtype{Asp80} produces Fortran for Type 80 ASPs, needed for NAG routine +++ d02kef, for example: +++ +++ \tab{5}SUBROUTINE BDYVAL(XL,XR,ELAM,YL,YR)\br +++ \tab{5}DOUBLE PRECISION ELAM,XL,YL(3),XR,YR(3)\br +++ \tab{5}YL(1)=XL\br +++ \tab{5}YL(2)=2.0D0\br +++ \tab{5}YR(1)=1.0D0\br +++ \tab{5}YR(2)=-1.0D0*DSQRT(XR+(-1.0D0*ELAM))\br +++ \tab{5}RETURN\br +++ \tab{5}END Asp80(name): Exports == Implementation where name : Symbol @@ -7312,17 +7279,15 @@ Asp80(name): Exports == Implementation where ++ Related Constructors: FortranVectorFunctionCategory, FortranProgramCategory ++ Description: ++ \spadtype{Asp9} produces Fortran for Type 9 ASPs, needed for NAG routines -++ \axiomOpFrom{d02bhf}{d02Package}, -++ \axiomOpFrom{d02cjf}{d02Package}, -++ \axiomOpFrom{d02ejf}{d02Package}. +++ d02bhf, d02cjf, d02ejf. ++ These ASPs represent a function of a scalar X and a vector Y, for example: -++ \begin{verbatim} -++ DOUBLE PRECISION FUNCTION G(X,Y) -++ DOUBLE PRECISION X,Y(*) -++ G=X+Y(1) -++ RETURN -++ END -++ \end{verbatim} +++ +++ \tab{5}DOUBLE PRECISION FUNCTION G(X,Y)\br +++ \tab{5}DOUBLE PRECISION X,Y(*)\br +++ \tab{5}G=X+Y(1)\br +++ \tab{5}RETURN\br +++ \tab{5}END +++ ++ If the user provides a constant value for G, then extra information is added ++ via COMMON blocks used by certain routines. This specifies that the value ++ returned by G in this case is to be ignored. @@ -7529,16 +7494,16 @@ Asp9(name): Exports == Implementation where ++ Keywords: associated Jordan algebra ++ References: ++ Description: -++ AssociatedJordanAlgebra takes an algebra \spad{A} and uses \spadfun{*$A} -++ to define the new multiplications \spad{a*b := (a *$A b + b *$A a)/2} -++ (anticommutator). -++ The usual notation \spad{{a,b}_+} cannot be used due to -++ restrictions in the current language. -++ This domain only gives a Jordan algebra if the -++ Jordan-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 -++ \spadfun{jordanAdmissible?()$A}. +++ AssociatedJordanAlgebra takes an algebra \spad{A} and uses \spadfun{*$A} +++ to define the new multiplications \spad{a*b := (a *$A b + b *$A a)/2} +++ (anticommutator). +++ The usual notation \spad{{a,b}_+} cannot be used due to +++ restrictions in the current language. +++ This domain only gives a Jordan algebra if the +++ Jordan-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 +++ \spadfun{jordanAdmissible?()$A}. ++ ++ If the underlying algebra is of type ++ \spadtype{FramedNonAssociativeAlgebra(R)} (i.e. a non @@ -7678,26 +7643,26 @@ AssociatedJordanAlgebra(R:CommutativeRing,A:NonAssociativeAlgebra R): ++ Keywords: associated Liealgebra ++ References: ++ Description: -++ 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}. +++ 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}. ++ -++ If the underlying algebra is of type -++ \spadtype{FramedNonAssociativeAlgebra(R)} (i.e. a non -++ associative algebra over R which is a free \spad{R}-module of finite -++ rank, together with a fixed \spad{R}-module basis), then the same -++ is true for the associated Lie algebra. -++ Also, if the underlying algebra is of type -++ \spadtype{FiniteRankNonAssociativeAlgebra(R)} (i.e. a non -++ associative algebra over R which is a free R-module of finite -++ rank), then the same is true for the associated Lie algebra. +++ If the underlying algebra is of type +++ \spadtype{FramedNonAssociativeAlgebra(R)} (i.e. a non +++ associative algebra over R which is a free \spad{R}-module of finite +++ rank, together with a fixed \spad{R}-module basis), then the same +++ is true for the associated Lie algebra. +++ Also, if the underlying algebra is of type +++ \spadtype{FiniteRankNonAssociativeAlgebra(R)} (i.e. a non +++ associative algebra over R which is a free R-module of finite +++ rank), then the same is true for the associated Lie algebra. AssociatedLieAlgebra(R:CommutativeRing,A:NonAssociativeAlgebra R): public == private where @@ -8038,7 +8003,7 @@ o )show AssociationList <>= )abbrev domain ALIST AssociationList -++ Author: +++ Author: Mark Botch ++ Date Created: ++ Change History: ++ Basic Operations: empty, empty?, keys, \#, concat, first, rest, @@ -8048,11 +8013,11 @@ o )show AssociationList ++ AMS Classification: ++ Keywords: list, association list ++ Description: -++ \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. +++ \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. AssociationList(Key:SetCategory, Entry:SetCategory): AssociationListAggregate(Key, Entry) == add @@ -8170,15 +8135,15 @@ AssociationList(Key:SetCategory, Entry:SetCategory): ++ by ANNA when a method fails due to insufficient workspace or where the ++ limit of function evaluations has been reached before the required ++ accuracy is achieved. -++ + AttributeButtons(): E == I where - F ==> Float - ST ==> String - LST ==> List String - Rec ==> Record(key:Symbol,entry:Any) - RList ==> List(Record(key:Symbol,entry:Any)) - IFL ==> List(Record(ifail:Integer,instruction:ST)) - Entry ==> Record(chapter:ST, type:ST, domainName: ST, + F ==> Float + ST ==> String + LST ==> List String + Rec ==> Record(key:Symbol,entry:Any) + RList ==> List(Record(key:Symbol,entry:Any)) + IFL ==> List(Record(ifail:Integer,instruction:ST)) + Entry ==> Record(chapter:ST, type:ST, domainName: ST, defaultMin:F, measure:F, failList:IFL, explList:LST) @@ -8399,10 +8364,11 @@ AttributeButtons(): E == I where ++ Date Last Updated: 31 January 1994 ++ References: ++ Description: -++ Automorphism R is the multiplicative group of automorphisms of R. +++ Automorphism R is the multiplicative group of automorphisms of R. -- In fact, non-invertible endomorphism are allowed as partial functions. -- This domain is noncanonical in that f*f^{-1} will be the identity -- function but won't be equal to 1. + Automorphism(R:Ring): Join(Group, Eltable(R, R)) with morphism: (R -> R) -> % ++ morphism(f) returns the non-invertible morphism given by f. @@ -8662,12 +8628,14 @@ o )show BalancedBinaryTree <>= )abbrev domain BBTREE BalancedBinaryTree -++ Description: \spadtype{BalancedBinaryTree(S)} is the domain of balanced +++ Description: +++ \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 leaf node. + BalancedBinaryTree(S: SetCategory): Exports == Implementation where Exports == BinaryTreeCategory(S) with finiteAggregate @@ -8893,8 +8861,9 @@ BalancedBinaryTree(S: SetCategory): Exports == Implementation where ++ Examples: ++ References: ++ Description: -++ Stream-based implementation of Zp: p-adic numbers are represented as -++ sum(i = 0.., a[i] * p^i), where the a[i] lie in -(p - 1)/2,...,(p - 1)/2. +++ Stream-based implementation of Zp: p-adic numbers are represented as +++ sum(i = 0.., a[i] * p^i), where the a[i] lie in -(p - 1)/2,...,(p - 1)/2. + BalancedPAdicInteger(p:Integer) == InnerPAdicInteger(p,false$Boolean) @ @@ -9015,8 +8984,9 @@ BalancedPAdicInteger(p:Integer) == InnerPAdicInteger(p,false$Boolean) ++ Examples: ++ References: ++ Description: -++ Stream-based implementation of Qp: numbers are represented as -++ sum(i = k.., a[i] * p^i), where the a[i] lie in -(p - 1)/2,...,(p - 1)/2. +++ Stream-based implementation of Qp: numbers are represented as +++ sum(i = k.., a[i] * p^i), where the a[i] lie in -(p - 1)/2,...,(p - 1)/2. + BalancedPAdicRational(p:Integer) == PAdicRationalConstructor(p,BalancedPAdicInteger p) @@ -9049,13 +9019,15 @@ BalancedPAdicRational(p:Integer) == ++ Date Created: August 1994 ++ Date Last Updated: April 1996 ++ Basic Operations: bfKeys, bfEntry -++ Description: A Domain which implements a table containing details of +++ Description: +++ A Domain which implements a table containing details of ++ points at which particular functions have evaluation problems. -DF ==> DoubleFloat -SDF ==> Stream DoubleFloat -RS ==> Record(zeros: SDF, ones: SDF, singularities: SDF) BasicFunctions(): E == I where + DF ==> DoubleFloat + SDF ==> Stream DoubleFloat + RS ==> Record(zeros: SDF, ones: SDF, singularities: SDF) + E ==> SetCategory with bfKeys:() -> List Symbol ++ bfKeys() returns the names of each function in the @@ -9465,14 +9437,15 @@ o )show BasicOperator <>= )abbrev domain BOP BasicOperator -++ Basic system operators ++ Author: Manuel Bronstein ++ Date Created: 22 March 1988 ++ Date Last Updated: 11 October 1993 -++ Description: -++ 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. ++ Keywords: operator, kernel. +++ Description: +++ Basic system operators. +++ 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. + BasicOperator(): Exports == Implementation where O ==> OutputForm P ==> AssociationList(String, None) @@ -9917,8 +9890,8 @@ o )show BinaryExpansion ++ Examples: ++ References: ++ Description: -++ This domain allows rational numbers to be presented as repeating -++ binary expansions. +++ This domain allows rational numbers to be presented as repeating +++ binary expansions. BinaryExpansion(): Exports == Implementation where Exports ==> QuotientFieldCategory(Integer) with @@ -9985,8 +9958,8 @@ BinaryExpansion(): Exports == Implementation where ++ Keywords: ++ References: ++ Description: -++ This domain provides an implementation of binary files. Data is -++ accessed one byte at a time as a small integer. +++ This domain provides an implementation of binary files. Data is +++ accessed one byte at a time as a small integer. BinaryFile: Cat == Def where @@ -10358,18 +10331,21 @@ o )show BinarySearchTree <>= )abbrev domain BSTREE BinarySearchTree -++ Description: BinarySearchTree(S) is the domain of +++ Author: Mark Botch +++ Description: +++ BinarySearchTree(S) is the domain of ++ a binary trees where elements are ordered across the tree. ++ A binary search tree is either empty or has ++ a value which is an S, and a ++ right and left which are both BinaryTree(S) ++ Elements are ordered across the tree. + BinarySearchTree(S: OrderedSet): Exports == Implementation where Exports == BinaryTreeCategory(S) with shallowlyMutable finiteAggregate binarySearchTree: List S -> % - ++ binarySearchTree(l) \undocumented + ++ binarySearchTree(l) is not documented ++ ++X binarySearchTree [1,2,3,4] @@ -10490,6 +10466,11 @@ both BinaryTree(S) <>= )abbrev domain BTOURN BinaryTournament +++ Author: Mark Botch +++ Description: +++ BinaryTournament creates a binary tournament with the +++ elements of ls as values at the nodes. + BinaryTournament(S: OrderedSet): Exports == Implementation where Exports == BinaryTreeCategory(S) with shallowlyMutable @@ -10590,10 +10571,13 @@ BinaryTournament(S: OrderedSet): Exports == Implementation where <>= )abbrev domain BTREE BinaryTree -++ Description: \spadtype{BinaryTree(S)} is the domain of all +++ Author: Mark Botch +++ Description: +++ \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 S and a \spadfun{right} ++ and \spadfun{left} which are both binary trees. + BinaryTree(S: SetCategory): Exports == Implementation where Exports == BinaryTreeCategory(S) with binaryTree: S -> % @@ -10742,12 +10726,13 @@ BinaryTree(S: SetCategory): Exports == Implementation where ++ Basic Operations: And, Not, Or ++ Related Constructors: ++ Keywords: bits -++ Description: \spadtype{Bits} provides logical functions for Indexed Bits. +++ Description: +++ \spadtype{Bits} provides logical functions for Indexed Bits. Bits(): Exports == Implementation where Exports == BitAggregate() with bits: (NonNegativeInteger, Boolean) -> % - ++ bits(n,b) creates bits with n values of b + ++ bits(n,b) creates bits with n values of b Implementation == IndexedBits(1) add bits(n,b) == new(n,b) @@ -10809,7 +10794,8 @@ Bits(): Exports == Implementation where ++ Basic Operations: true, false, not, and, or, xor, nand, nor, implies, ^ ++ Related Constructors: ++ Keywords: boolean -++ Description: \spadtype{Boolean} is the elementary logic with 2 values: +++ Description: +++ \spadtype{Boolean} is the elementary logic with 2 values: ++ true and false Boolean(): Join(OrderedSet, Finite, Logic, ConvertibleTo InputForm) with @@ -10822,12 +10808,12 @@ Boolean(): Join(OrderedSet, Finite, Logic, ConvertibleTo InputForm) with _not : % -> % ++ not n returns the negation of n. _and : (%, %) -> % - ++ a and b returns the logical {\em and} of Boolean \spad{a} and b. + ++ a and b returns the logical and of Boolean \spad{a} and b. _or : (%, %) -> % - ++ a or b returns the logical inclusive {\em or} + ++ a or b returns the logical inclusive or ++ of Boolean \spad{a} and b. xor : (%, %) -> % - ++ xor(a,b) returns the logical exclusive {\em or} + ++ xor(a,b) returns the logical exclusive or ++ of Boolean \spad{a} and b. nand : (%, %) -> % ++ nand(a,b) returns the logical negation of \spad{a} and b. @@ -11262,34 +11248,35 @@ o )show CardinalNumber ++ Goedel, "The consistency of the continuum hypothesis", ++ Ann. Math. Studies, Princeton Univ. Press, 1940 ++ Description: -++ 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. +++ 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. ++ -++ If \spad{x = #X} and \spad{y = #Y} then -++ \spad{x+y = #(X+Y)} \tab{30}disjoint union -++ \spad{x-y = #(X-Y)} \tab{30}relative complement -++ \spad{x*y = #(X*Y)} \tab{30}cartesian product -++ \spad{x**y = #(X**Y)} \tab{30}\spad{X**Y = \{g| g:Y->X\}} +++ If \spad{x = #X} and \spad{y = #Y} then\br +++ \tab{5}\spad{x+y = #(X+Y)} \tab{5}disjoint union\br +++ \tab{5}\spad{x-y = #(X-Y)} \tab{5}relative complement\br +++ \tab{5}\spad{x*y = #(X*Y)} \tab{5}cartesian product\br +++ \tab{5}\spad{x**y = #(X**Y)} \tab{4}\spad{X**Y = g| g:Y->X} ++ -++ The non-negative integers have a natural construction as cardinals -++ \spad{0 = #\{\}}, \spad{1 = \{0\}}, \spad{2 = \{0, 1\}}, ..., \spad{n = \{i| 0 <= i < n\}}. +++ The non-negative integers have a natural construction as cardinals\br +++ \spad{0 = #\{\}}, \spad{1 = \{0\}}, +++ \spad{2 = \{0, 1\}}, ..., \spad{n = \{i| 0 <= i < n\}}. ++ -++ That \spad{0} acts as a zero for the multiplication of cardinals is -++ equivalent to the axiom of choice. +++ That \spad{0} acts as a zero for the multiplication of cardinals is +++ equivalent to the axiom of choice. ++ -++ The generalized continuum hypothesis asserts -++ \center{\spad{2**Aleph i = Aleph(i+1)}} -++ and is independent of the axioms of set theory [Goedel 1940]. +++ The generalized continuum hypothesis asserts \br +++ \spad{2**Aleph i = Aleph(i+1)} +++ and is independent of the axioms of set theory [Goedel 1940]. ++ -++ Three commonly encountered cardinal numbers are -++ \spad{a = #Z} \tab{30}countable infinity -++ \spad{c = #R} \tab{30}the continuum -++ \spad{f = #\{g| g:[0,1]->R\}} -++ -++ In this domain, these values are obtained using -++ \spad{a := Aleph 0}, \spad{c := 2**a}, \spad{f := 2**c}. +++ Three commonly encountered cardinal numbers are\br +++ \tab{5}\spad{a = #Z} \tab{5}countable infinity\br +++ \tab{5}\spad{c = #R} \tab{5}the continuum\br +++ \tab{5}\spad{f = # g | g:[0,1]->R\} ++ +++ In this domain, these values are obtained using\br +++ \tab{5}\spad{a := Aleph 0}, \spad{c := 2**a}, \spad{f := 2**c}. + CardinalNumber: Join(OrderedSet, AbelianMonoid, Monoid, RetractableTo NonNegativeInteger) with commutative "*" @@ -12434,10 +12421,10 @@ o )show CartesianTensor ++ Examples: ++ References: ++ Description: -++ CartesianTensor(minix,dim,R) provides Cartesian tensors with -++ components belonging to a commutative ring R. These tensors -++ can have any number of indices. Each index takes values from -++ \spad{minix} to \spad{minix + dim - 1}. +++ CartesianTensor(minix,dim,R) provides Cartesian tensors with +++ components belonging to a commutative ring R. These tensors +++ can have any number of indices. Each index takes values from +++ \spad{minix} to \spad{minix + dim - 1}. CartesianTensor(minix, dim, R): Exports == Implementation where NNI ==> NonNegativeInteger @@ -12688,7 +12675,7 @@ CartesianTensor(minix, dim, R): Exports == Implementation where dim3: NNI := dim**3 dim4: NNI := dim**4 - sample()==kroneckerDelta()$% + sample()==kroneckerDelta()$% int2index(n: Integer, indv: INDEX): INDEX == n < 0 => error "Index error (too small)" rnk := #indv @@ -13289,7 +13276,7 @@ o )show Character ++ Examples: ++ References: ++ Description: -++ This domain provides the basic character data type. +++ This domain provides the basic character data type. Character: OrderedFinite() with ord: % -> Integer @@ -13317,7 +13304,7 @@ Character: OrderedFinite() with ++X quote() escape: () -> % ++ escape() provides the escape character, \spad{_}, which - ++ is used to allow quotes and other characters {\em within} + ++ is used to allow quotes and other characters within ++ strings. ++ ++X escape() @@ -13385,7 +13372,7 @@ Character: OrderedFinite() with minChar := minIndex OutChars a = b == a =$Rep b - a < b == a <$Rep b + a < b == a <$Rep b size() == 256 index n == char((n - 1)::Integer) lookup c == (1 + ord c)::PositiveInteger @@ -13747,106 +13734,105 @@ o )show CharacterClass ++ Examples: ++ References: ++ Description: -++ This domain allows classes of characters to be defined and manipulated -++ efficiently. - +++ This domain allows classes of characters to be defined and manipulated +++ efficiently. CharacterClass: Join(SetCategory, ConvertibleTo String, FiniteSetAggregate Character, ConvertibleTo List Character) with - charClass: String -> % - ++ charClass(s) creates a character class which contains - ++ exactly the characters given in the string s. - charClass: List Character -> % - ++ charClass(l) creates a character class which contains - ++ exactly the characters given in the list l. - digit: constant -> % - ++ digit() returns the class of all characters - ++ for which \spadfunFrom{digit?}{Character} is true. - hexDigit: constant -> % - ++ hexDigit() returns the class of all characters for which - ++ \spadfunFrom{hexDigit?}{Character} is true. - upperCase: constant -> % - ++ upperCase() returns the class of all characters for which - ++ \spadfunFrom{upperCase?}{Character} is true. - lowerCase: constant -> % - ++ lowerCase() returns the class of all characters for which - ++ \spadfunFrom{lowerCase?}{Character} is true. - alphabetic : constant -> % - ++ alphabetic() returns the class of all characters for which - ++ \spadfunFrom{alphabetic?}{Character} is true. - alphanumeric: constant -> % - ++ alphanumeric() returns the class of all characters for which - ++ \spadfunFrom{alphanumeric?}{Character} is true. + charClass: String -> % + ++ charClass(s) creates a character class which contains + ++ exactly the characters given in the string s. + charClass: List Character -> % + ++ charClass(l) creates a character class which contains + ++ exactly the characters given in the list l. + digit: constant -> % + ++ digit() returns the class of all characters + ++ for which digit? is true. + hexDigit: constant -> % + ++ hexDigit() returns the class of all characters for which + ++ hexDigit? is true. + upperCase: constant -> % + ++ upperCase() returns the class of all characters for which + ++ upperCase? is true. + lowerCase: constant -> % + ++ lowerCase() returns the class of all characters for which + ++ lowerCase? is true. + alphabetic : constant -> % + ++ alphabetic() returns the class of all characters for which + ++ alphabetic? is true. + alphanumeric: constant -> % + ++ alphanumeric() returns the class of all characters for which + ++ alphanumeric? is true. == add - Rep := IndexedBits(0) - N := size()$Character - - a, b: % - - digit() == charClass "0123456789" - hexDigit() == charClass "0123456789abcdefABCDEF" - upperCase() == charClass "ABCDEFGHIJKLMNOPQRSTUVWXYZ" - lowerCase() == charClass "abcdefghijklmnopqrstuvwxyz" - alphabetic() == union(upperCase(), lowerCase()) - alphanumeric() == union(alphabetic(), digit()) - - a = b == a =$Rep b - - member?(c, a) == a(ord c) - union(a,b) == Or(a, b) - intersect (a,b) == And(a, b) - difference(a,b) == And(a, Not b) - complement a == Not a - - convert(cl):String == - construct(convert(cl)@List(Character)) - convert(cl:%):List(Character) == - [char(i) for i in 0..N-1 | cl.i] - - charClass(s: String) == - cl := new(N, false) - for i in minIndex(s)..maxIndex(s) repeat cl(ord s.i) := true - cl - - charClass(l: List Character) == - cl := new(N, false) - for c in l repeat cl(ord c) := true - cl - - coerce(cl):OutputForm == (convert(cl)@String)::OutputForm - - -- Stuff to make a legal SetAggregate view - # a == (n := 0; for i in 0..N-1 | a.i repeat n := n+1; n) - empty():% == charClass [] - brace():% == charClass [] - - insert_!(c, a) == (a(ord c) := true; a) - remove_!(c, a) == (a(ord c) := false; a) - - inspect(a) == - for i in 0..N-1 | a.i repeat - return char i - error "Cannot take a character from an empty class." - extract_!(a) == - for i in 0..N-1 | a.i repeat - a.i := false - return char i - error "Cannot take a character from an empty class." - - map(f, a) == - b := new(N, false) - for i in 0..N-1 | a.i repeat b(ord f char i) := true - b - - temp: % := new(N, false)$Rep - map_!(f, a) == - fill_!(temp, false) - for i in 0..N-1 | a.i repeat temp(ord f char i) := true - copyInto_!(a, temp, 0) - - parts a == - [char i for i in 0..N-1 | a.i] + Rep := IndexedBits(0) + N := size()$Character + + a, b: % + + digit() == charClass "0123456789" + hexDigit() == charClass "0123456789abcdefABCDEF" + upperCase() == charClass "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + lowerCase() == charClass "abcdefghijklmnopqrstuvwxyz" + alphabetic() == union(upperCase(), lowerCase()) + alphanumeric() == union(alphabetic(), digit()) + + a = b == a =$Rep b + + member?(c, a) == a(ord c) + union(a,b) == Or(a, b) + intersect (a,b) == And(a, b) + difference(a,b) == And(a, Not b) + complement a == Not a + + convert(cl):String == + construct(convert(cl)@List(Character)) + convert(cl:%):List(Character) == + [char(i) for i in 0..N-1 | cl.i] + + charClass(s: String) == + cl := new(N, false) + for i in minIndex(s)..maxIndex(s) repeat cl(ord s.i) := true + cl + + charClass(l: List Character) == + cl := new(N, false) + for c in l repeat cl(ord c) := true + cl + + coerce(cl):OutputForm == (convert(cl)@String)::OutputForm + + -- Stuff to make a legal SetAggregate view + # a == (n := 0; for i in 0..N-1 | a.i repeat n := n+1; n) + empty():% == charClass [] + brace():% == charClass [] + + insert_!(c, a) == (a(ord c) := true; a) + remove_!(c, a) == (a(ord c) := false; a) + + inspect(a) == + for i in 0..N-1 | a.i repeat + return char i + error "Cannot take a character from an empty class." + extract_!(a) == + for i in 0..N-1 | a.i repeat + a.i := false + return char i + error "Cannot take a character from an empty class." + + map(f, a) == + b := new(N, false) + for i in 0..N-1 | a.i repeat b(ord f char i) := true + b + + temp: % := new(N, false)$Rep + map_!(f, a) == + fill_!(temp, false) + for i in 0..N-1 | a.i repeat temp(ord f char i) := true + copyInto_!(a, temp, 0) + + parts a == + [char i for i in 0..N-1 | a.i] @ <>= @@ -14705,20 +14691,20 @@ o $AXIOM/doc/src/algebra/clifford.spad ++ References: ++ ++ Description: -++ CliffordAlgebra(n, K, Q) defines a vector space of dimension \spad{2**n} -++ over K, given a quadratic form Q on \spad{K**n}. +++ CliffordAlgebra(n, K, Q) defines a vector space of dimension \spad{2**n} +++ over K, given a quadratic form Q on \spad{K**n}. ++ -++ If \spad{e[i]}, \spad{1<=i<=n} is a basis for \spad{K**n} then -++ 1, \spad{e[i]} (\spad{1<=i<=n}), \spad{e[i1]*e[i2]} -++ (\spad{1<=i1 be c::Ex * be + coerce(x): Ex == tl := [coerceMonom(x.i,i) for i in 0..dim-1 | x.i^=0] null tl => "0"::Ex reduce("+", tl) - - localPowerSets(j:NNI): List(List(PI)) == - l: List List PI := list [] - j = 0 => l - Sm := localPowerSets((j-1)::NNI) + localPowerSets(j:NNI): List(List(PI)) == + l: List List PI := list [] + j = 0 => l + Sm := localPowerSets((j-1)::NNI) Sn: List List PI := [] - for x in Sm repeat Sn := cons(cons(j pretend PI, x),Sn) - append(Sn, Sm) - - powerSets(j:NNI):List List PI == map(reverse, localPowerSets j) - - Pn:List List PI := powerSets(n) - - recip(x: %): Union(%, "failed") == - one:% := 1 - -- tmp:c := x*yC - 1$C - rhsEqs : List K := [] - lhsEqs: List List K := [] - lhsEqi: List K - for pi in Pn repeat - rhsEqs := cons(coefficient(one, pi), rhsEqs) - - lhsEqi := [] - for pj in Pn repeat - lhsEqi := cons(coefficient(x*monomial(1,pj),pi),lhsEqi) - lhsEqs := cons(reverse(lhsEqi),lhsEqs) - ans := particularSolution(matrix(lhsEqs), - vector(rhsEqs))$LinearSystemMatrixPackage(K, Vector K, Vector K, Matrix K) + for x in Sm repeat Sn := cons(cons(j pretend PI, x),Sn) + append(Sn, Sm) + + powerSets(j:NNI):List List PI == map(reverse, localPowerSets j) + + Pn:List List PI := powerSets(n) + + recip(x: %): Union(%, "failed") == + one:% := 1 + -- tmp:c := x*yC - 1$C + rhsEqs : List K := [] + lhsEqs: List List K := [] + lhsEqi: List K + for pi in Pn repeat + rhsEqs := cons(coefficient(one, pi), rhsEqs) + + lhsEqi := [] + for pj in Pn repeat + lhsEqi := cons(coefficient(x*monomial(1,pj),pi),lhsEqi) + lhsEqs := cons(reverse(lhsEqi),lhsEqs) + ans := particularSolution(matrix(lhsEqs),vector(rhsEqs)_ + )$LinearSystemMatrixPackage(K, Vector K, Vector K, Matrix K) ans case "failed" => "failed" - ansP := parts(ans) - ansC:% := 0 - for pj in Pn repeat - cj:= first ansP - ansP := rest ansP - ansC := ansC + cj*monomial(1,pj) - ansC + ansP := parts(ans) + ansC:% := 0 + for pj in Pn repeat + cj:= first ansP + ansP := rest ansP + ansC := ansC + cj*monomial(1,pj) + ansC @ <>= @@ -14937,9 +14923,9 @@ CliffordAlgebra(n, K, Q): T == Impl where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: Color() specifies a domain of 27 colors provided in the +++ Description: +++ Color() specifies a domain of 27 colors provided in the ++ \Language{} system (the colors mix additively). - Color(): Exports == Implementation where I ==> Integer @@ -15049,7 +15035,9 @@ Color(): Exports == Implementation where ++ Author : Larry Lambe ++ Date created: 30 June 1988. ++ Updated : 10 March 1991 -++ Description: A type for basic commutators +++ Description: +++ A type for basic commutators + Commutator: Export == Implement where I ==> Integer OSI ==> OrdSetInts @@ -15057,9 +15045,9 @@ Commutator: Export == Implement where Export == SetCategory with mkcomm : I -> % - ++ mkcomm(i) \undocumented{} + ++ mkcomm(i) is not documented mkcomm : (%,%) -> % - ++ mkcomm(i,j) \undocumented{} + ++ mkcomm(i,j) is not documented Implement == add P := Record(left:%,right:%) @@ -15519,7 +15507,7 @@ o )show Complex <>= )abbrev domain COMPLEX Complex -++ Author: +++ Author: Mark Botch ++ Date Created: ++ Date Last Updated: ++ Basic Functions: @@ -15529,9 +15517,10 @@ o )show Complex ++ Keywords: ++ References: ++ Description: -++ \spadtype {Complex(R)} creates the domain of elements of the form +++ \spadtype{Complex(R)} creates the domain of elements of the form ++ \spad{a + b * i} where \spad{a} and b come from the ring R, ++ and i is a new element such that \spad{i**2 = -1}. + Complex(R:CommutativeRing): ComplexCategory(R) with if R has OpenMath then OpenMath == add @@ -16234,14 +16223,16 @@ o )show ContinuedFraction ++ AMS Classifications: 11A55 11J70 11K50 11Y65 30B70 40A15 ++ Keywords: continued fraction, convergent ++ References: -++ Description: \spadtype{ContinuedFraction} implements general -++ continued fractions. This version is not restricted to simple, -++ finite fractions and uses the \spadtype{Stream} as a -++ representation. The arithmetic functions assume that the -++ approximants alternate below/above the convergence point. -++ This is enforced by ensuring the partial numerators and partial -++ denominators are greater than 0 in the Euclidean domain view of \spad{R} -++ (i.e. \spad{sizeLess?(0, x)}). +++ Description: +++ \spadtype{ContinuedFraction} implements general +++ continued fractions. This version is not restricted to simple, +++ finite fractions and uses the \spadtype{Stream} as a +++ representation. The arithmetic functions assume that the +++ approximants alternate below/above the convergence point. +++ This is enforced by ensuring the partial numerators and partial +++ denominators are greater than 0 in the Euclidean domain view of \spad{R} +++ (i.e. \spad{sizeLess?(0, x)}). + ContinuedFraction(R): Exports == Implementation where R : EuclideanDomain Q ==> Fraction R @@ -16517,7 +16508,7 @@ ContinuedFraction(R): Exports == Implementation where n * d == genFromSequence map(x +-> n * x, apx d) c / d == genFromSequence map((x,y) +-> x / y, apx c, rest apx d) recip c ==(c = 0 => "failed"; - genFromSequence map(x +-> 1/x, rest apx c)) + genFromSequence map(x +-> 1/x, rest apx c)) showAll?: () -> Boolean showAll?() == @@ -16579,16 +16570,19 @@ ContinuedFraction(R): Exports == Implementation where <>= )abbrev domain DBASE Database +++ Author: Mark Botch +++ Description: ++ This domain implements a simple view of a database whose fields are ++ indexed by symbols + Database(S): Exports == Implementation where S: OrderedSet with elt: (%,Symbol) -> String - ++ elt(x,s) returns an element of x indexed by s + ++ elt(x,s) returns an element of x indexed by s display: % -> Void - ++ display(x) displays x in some form + ++ display(x) displays x in some form fullDisplay: % -> Void - ++ fullDisplay(x) displays x in detail + ++ fullDisplay(x) displays x in detail Exports == SetCategory with elt: (%,QueryEquation) -> % ++ elt(db,q) returns all elements of \axiom{db} which satisfy \axiom{q}. @@ -16751,11 +16745,14 @@ Database(S): Exports == Implementation where <>= )abbrev domain DLIST DataList +++ Author: Mark Botch +++ Description: ++ This domain provides some nice functions on lists + DataList(S:OrderedSet) : Exports == Implementation where Exports == ListAggregate(S) with coerce: List S -> % - ++ coerce(l) creates a datalist from l + ++ coerce(l) creates a datalist from l coerce: % -> List S ++ coerce(x) returns the list of elements in x datalist: List S -> % @@ -17041,8 +17038,9 @@ o )show DecimalExpansion ++ Examples: ++ References: ++ Description: -++ This domain allows rational numbers to be presented as repeating -++ decimal expansions. +++ This domain allows rational numbers to be presented as repeating +++ decimal expansions. + DecimalExpansion(): Exports == Implementation where Exports ==> QuotientFieldCategory(Integer) with coerce: % -> Fraction Integer @@ -18740,28 +18738,27 @@ description is in terms of a vector and angle of rotation. <>= -++ 4x4 Matrices for coordinate transformations + +)abbrev domain DHMATRIX DenavitHartenbergMatrix + ++ Author: Timothy Daly ++ Date Created: June 26, 1991 ++ Date Last Updated: 26 June 1991 ++ Description: -++ This package contains functions to create 4x4 matrices -++ useful for rotating and transforming coordinate systems. -++ These matrices are useful for graphics and robotics. -++ (Reference: Robot Manipulators Richard Paul MIT Press 1981) - - -)abbrev domain DHMATRIX DenavitHartenbergMatrix - ---% DHMatrix +++ 4x4 Matrices for coordinate transformations\br +++ This package contains functions to create 4x4 matrices +++ useful for rotating and transforming coordinate systems. +++ These matrices are useful for graphics and robotics. +++ (Reference: Robot Manipulators Richard Paul MIT Press 1981) +++ +++ A Denavit-Hartenberg Matrix is a 4x4 Matrix of the form:\br +++ \tab{5}\spad{nx ox ax px}\br +++ \tab{5}\spad{ny oy ay py}\br +++ \tab{5}\spad{nz oz az pz}\br +++ \tab{5}\spad{0 0 0 1}\br +++ (n, o, and a are the direction cosines) DenavitHartenbergMatrix(R): Exports == Implementation where - ++ A Denavit-Hartenberg Matrix is a 4x4 Matrix of the form: - ++ \spad{nx ox ax px} - ++ \spad{ny oy ay py} - ++ \spad{nz oz az pz} - ++ \spad{0 0 0 1} - ++ (n, o, and a are the direction cosines) R : Join(Field, TranscendentalFunctionCategory) -- for the implementation of dhmatrix @@ -19788,9 +19785,7 @@ o )show BagAggregate ++ Examples: ++ References: ++ Description: - ++ Linked list implementation of a Dequeue ---% Dequeue and Heap data types Dequeue(S:SetCategory): DequeueAggregate S with dequeue: List S -> % @@ -20678,7 +20673,8 @@ o )show DeRhamComplex ++ ++ Needs: LeftAlgebra, ExtAlgBasis, FreeMod(Ring,OrderedSet) ++ -++ Description: The deRham complex of Euclidean space, that is, the +++ Description: +++ The deRham complex of Euclidean space, that is, the ++ class of differential forms of arbitary degree over a coefficient ring. ++ See Flanders, Harley, Differential Forms, With Applications to the Physical ++ Sciences, New York, Academic Press, 1963. @@ -20698,40 +20694,40 @@ DeRhamComplex(CoefRing,listIndVar:List Symbol): Export == Implement where Export == Join(LALG(R), RetractableTo(R)) with leadingCoefficient : % -> R - ++ leadingCoefficient(df) returns the leading - ++ coefficient of differential form df. + ++ leadingCoefficient(df) returns the leading + ++ coefficient of differential form df. leadingBasisTerm : % -> % - ++ leadingBasisTerm(df) returns the leading - ++ basis term of differential form df. + ++ leadingBasisTerm(df) returns the leading + ++ basis term of differential form df. reductum : % -> % - ++ reductum(df), where df is a differential form, + ++ reductum(df), where df is a differential form, ++ returns df minus the leading - ++ term of df if df has two or more terms, and - ++ 0 otherwise. + ++ term of df if df has two or more terms, and + ++ 0 otherwise. coefficient : (%,%) -> R - ++ coefficient(df,u), where df is a differential form, + ++ coefficient(df,u), where df is a differential form, ++ returns the coefficient of df containing the basis term u ++ if such a term exists, and 0 otherwise. generator : NNI -> % - ++ generator(n) returns the nth basis term for a differential form. + ++ generator(n) returns the nth basis term for a differential form. homogeneous? : % -> Boolean - ++ homogeneous?(df) tests if all of the terms of - ++ differential form df have the same degree. + ++ homogeneous?(df) tests if all of the terms of + ++ differential form df have the same degree. retractable? : % -> Boolean - ++ retractable?(df) tests if differential form df is a 0-form, - ++ i.e., if degree(df) = 0. + ++ retractable?(df) tests if differential form df is a 0-form, + ++ i.e., if degree(df) = 0. degree : % -> I - ++ degree(df) returns the homogeneous degree of differential form df. + ++ degree(df) returns the homogeneous degree of differential form df. map : (R -> R, %) -> % - ++ map(f,df) replaces each coefficient x of differential + ++ map(f,df) replaces each coefficient x of differential ++ form df by \spad{f(x)}. totalDifferential : R -> % - ++ totalDifferential(x) returns the total differential - ++ (gradient) form for element x. + ++ totalDifferential(x) returns the total differential + ++ (gradient) form for element x. exteriorDifferential : % -> % - ++ exteriorDifferential(df) returns the exterior - ++ derivative (gradient, curl, divergence, ...) of - ++ the differential form df. + ++ exteriorDifferential(df) returns the exterior + ++ derivative (gradient, curl, divergence, ...) of + ++ the differential form df. Implement == ASY add Rep := ASY @@ -20906,11 +20902,10 @@ DeRhamComplex(CoefRing,listIndVar:List Symbol): Export == Implement where ++ References:Kolchin, E.R. "Differential Algebra and Algebraic Groups" ++ (Academic Press, 1973). ++ Description: -++ \spadtype{DifferentialSparseMultivariatePolynomial} implements -++ an ordinary differential polynomial ring by combining a -++ domain belonging to the category \spadtype{DifferentialVariableCategory} -++ with the domain \spadtype{SparseMultivariatePolynomial}. -++ +++ \spadtype{DifferentialSparseMultivariatePolynomial} implements +++ an ordinary differential polynomial ring by combining a +++ domain belonging to the category \spadtype{DifferentialVariableCategory} +++ with the domain \spadtype{SparseMultivariatePolynomial}. DifferentialSparseMultivariatePolynomial(R, S, V): Exports == Implementation where @@ -21030,7 +21025,7 @@ DifferentialSparseMultivariatePolynomial(R, S, V): <>= )abbrev domain DIRPROD DirectProduct -++ Author: +++ Author: Mark Botch ++ Date Created: ++ Date Last Updated: ++ Basic Functions: @@ -21040,7 +21035,7 @@ DifferentialSparseMultivariatePolynomial(R, S, V): ++ Keywords: ++ References: ++ Description: -++ This type represents the finite direct or cartesian product of an +++ 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. @@ -21237,8 +21232,8 @@ DirectProduct(dim:NonNegativeInteger, R:Type): ++ Examples: ++ References: ++ Description: -++ This constructor provides a direct product type with a -++ left matrix-module view. +++ This constructor provides a direct product type with a +++ left matrix-module view. DirectProductMatrixModule(n, R, M, S): DPcategory == DPcapsule where n: PositiveInteger @@ -21362,8 +21357,8 @@ DirectProductMatrixModule(n, R, M, S): DPcategory == DPcapsule where ++ Examples: ++ References: ++ Description: -++ This constructor provides a direct product of R-modules -++ with an R-module view. +++ This constructor provides a direct product of R-modules +++ with an R-module view. DirectProductModule(n, R, S): DPcategory == DPcapsule where n: NonNegativeInteger @@ -21705,12 +21700,13 @@ o )show DistributedMultivariatePolynomial ++ Keywords: polynomial, multivariate, distributed ++ References: ++ Description: -++ This type supports distributed multivariate polynomials +++ 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. + DistributedMultivariatePolynomial(vl,R): public == private where vl : List Symbol R : Ring @@ -22190,43 +22186,29 @@ o )show DoubleFloat ++ Basic Operations: exp1, hash, log2, log10, rationalApproximation, / , ** ++ Related Constructors: ++ Keywords: small float -++ Description: \spadtype{DoubleFloat} is intended to make accessible -++ hardware floating point arithmetic in \Language{}, either native double +++ Description: +++ \spadtype{DoubleFloat} is intended to make accessible +++ hardware floating point arithmetic in Axiom, 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 +++ the arithmetic operations: ++ +, *, / and possibly also the +++ sqrt operation. +++ The operations exp, log, sin, cos, atan are normally coded in ++ software based on minimax polynomial/rational approximations. -++ Note that under Lisp/VM, \spadfunFrom{atan}{DoubleFloat} -++ is not available at this time. +++ ++ 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} +++ the operations +, *, / and sqrt are expected to be fully accurate. +++ The operations exp, log, sin, cos and atan are not expected to be +++ fully accurate. In particular, sin and cos ++ will lose all precision for large arguments. ++ -++ The \spadtype{Float} domain provides an alternative to the -++ \spad{DoubleFloat} domain. +++ The Float domain provides an alternative to the 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}{DoubleFloat}, -++ 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. --- I've put some timing comparisons in the notes for the Float --- domain about the difference in speed between the two domains. +++ provides some special functions such as erf, the error function +++ in addition to the elementary functions. The disadvantage of Float is that +++ it is much more expensive than small floats when the latter can be used. + DoubleFloat(): Join(FloatingPointSystem, DifferentialRing, OpenMath, TranscendentalFunctionCategory, SpecialFunctionCategory, _ ConvertibleTo InputForm) with @@ -22248,7 +22230,7 @@ DoubleFloat(): Join(FloatingPointSystem, DifferentialRing, OpenMath, ++ Gamma(x) is the Euler Gamma function. Beta : (%,%) -> % ++ Beta(x,y) is \spad{Gamma(x) * Gamma(y)/Gamma(x+y)}. - doubleFloatFormat : String -> String + doubleFloatFormat : String -> String ++ change the output format for doublefloats using lisp format strings rationalApproximation: (%, NonNegativeInteger) -> Fraction Integer ++ rationalApproximation(f, n) computes a rational approximation @@ -22557,7 +22539,8 @@ DoubleFloat(): Join(FloatingPointSystem, DifferentialRing, OpenMath, ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: DrawOption allows the user to specify defaults for the +++ Description: +++ DrawOption allows the user to specify defaults for the ++ creation and rendering of plots. DrawOption(): Exports == Implementation where @@ -22795,22 +22778,22 @@ DrawOption(): Exports == Implementation where ++ performs the integration by using \axiomType{NagIntegrationPackage}. d01ajfAnnaType(): NumericalIntegrationCategory == Result add - EF2 ==> ExpressionFunctions2 - EDF ==> Expression DoubleFloat - LDF ==> List DoubleFloat - SDF ==> Stream DoubleFloat - DF ==> DoubleFloat - FI ==> Fraction Integer - EFI ==> Expression Fraction Integer - SOCDF ==> Segment OrderedCompletion DoubleFloat - NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) - MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) - INT ==> Integer - BOP ==> BasicOperator - S ==> Symbol - ST ==> String - LST ==> List String - RT ==> RoutinesTable + EF2 ==> ExpressionFunctions2 + EDF ==> Expression DoubleFloat + LDF ==> List DoubleFloat + SDF ==> Stream DoubleFloat + DF ==> DoubleFloat + FI ==> Fraction Integer + EFI ==> Expression Fraction Integer + SOCDF ==> Segment OrderedCompletion DoubleFloat + NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) + MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) + INT ==> Integer + BOP ==> BasicOperator + S ==> Symbol + ST ==> String + LST ==> List String + RT ==> RoutinesTable Rep:=Result import Rep, NagIntegrationPackage, d01AgentsPackage @@ -22872,22 +22855,22 @@ d01ajfAnnaType(): NumericalIntegrationCategory == Result add ++ performs the integration by using \axiomType{NagIntegrationPackage}. d01akfAnnaType(): NumericalIntegrationCategory == Result add - EF2 ==> ExpressionFunctions2 - EDF ==> Expression DoubleFloat - LDF ==> List DoubleFloat - SDF ==> Stream DoubleFloat - DF ==> DoubleFloat - FI ==> Fraction Integer - EFI ==> Expression Fraction Integer - SOCDF ==> Segment OrderedCompletion DoubleFloat - NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) - MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) - INT ==> Integer - BOP ==> BasicOperator - S ==> Symbol - ST ==> String - LST ==> List String - RT ==> RoutinesTable + EF2 ==> ExpressionFunctions2 + EDF ==> Expression DoubleFloat + LDF ==> List DoubleFloat + SDF ==> Stream DoubleFloat + DF ==> DoubleFloat + FI ==> Fraction Integer + EFI ==> Expression Fraction Integer + SOCDF ==> Segment OrderedCompletion DoubleFloat + NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) + MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) + INT ==> Integer + BOP ==> BasicOperator + S ==> Symbol + ST ==> String + LST ==> List String + RT ==> RoutinesTable Rep:=Result import Rep, d01AgentsPackage, NagIntegrationPackage @@ -22954,22 +22937,22 @@ d01akfAnnaType(): NumericalIntegrationCategory == Result add ++ performs the integration by using \axiomType{NagIntegrationPackage}. d01alfAnnaType(): NumericalIntegrationCategory == Result add - EF2 ==> ExpressionFunctions2 - EDF ==> Expression DoubleFloat - LDF ==> List DoubleFloat - SDF ==> Stream DoubleFloat - DF ==> DoubleFloat - FI ==> Fraction Integer - EFI ==> Expression Fraction Integer - SOCDF ==> Segment OrderedCompletion DoubleFloat - NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) - MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) - INT ==> Integer - BOP ==> BasicOperator - S ==> Symbol - ST ==> String - LST ==> List String - RT ==> RoutinesTable + EF2 ==> ExpressionFunctions2 + EDF ==> Expression DoubleFloat + LDF ==> List DoubleFloat + SDF ==> Stream DoubleFloat + DF ==> DoubleFloat + FI ==> Fraction Integer + EFI ==> Expression Fraction Integer + SOCDF ==> Segment OrderedCompletion DoubleFloat + NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) + MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) + INT ==> Integer + BOP ==> BasicOperator + S ==> Symbol + ST ==> String + LST ==> List String + RT ==> RoutinesTable Rep:=Result import Rep, d01AgentsPackage, NagIntegrationPackage @@ -23048,22 +23031,22 @@ d01alfAnnaType(): NumericalIntegrationCategory == Result add ++ performs the integration by using \axiomType{NagIntegrationPackage}. d01amfAnnaType(): NumericalIntegrationCategory == Result add - EF2 ==> ExpressionFunctions2 - EDF ==> Expression DoubleFloat - LDF ==> List DoubleFloat - SDF ==> Stream DoubleFloat - DF ==> DoubleFloat - FI ==> Fraction Integer - EFI ==> Expression Fraction Integer - SOCDF ==> Segment OrderedCompletion DoubleFloat - NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) - MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) - INT ==> Integer - BOP ==> BasicOperator - S ==> Symbol - ST ==> String - LST ==> List String - RT ==> RoutinesTable + EF2 ==> ExpressionFunctions2 + EDF ==> Expression DoubleFloat + LDF ==> List DoubleFloat + SDF ==> Stream DoubleFloat + DF ==> DoubleFloat + FI ==> Fraction Integer + EFI ==> Expression Fraction Integer + SOCDF ==> Segment OrderedCompletion DoubleFloat + NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) + MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) + INT ==> Integer + BOP ==> BasicOperator + S ==> Symbol + ST ==> String + LST ==> List String + RT ==> RoutinesTable Rep:=Result import Rep, d01AgentsPackage, NagIntegrationPackage @@ -23138,22 +23121,22 @@ d01amfAnnaType(): NumericalIntegrationCategory == Result add ++ performs the integration by using \axiomType{NagIntegrationPackage}. d01anfAnnaType(): NumericalIntegrationCategory == Result add - EF2 ==> ExpressionFunctions2 - EDF ==> Expression DoubleFloat - LDF ==> List DoubleFloat - SDF ==> Stream DoubleFloat - DF ==> DoubleFloat - FI ==> Fraction Integer - EFI ==> Expression Fraction Integer - SOCDF ==> Segment OrderedCompletion DoubleFloat - NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) - MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) - INT ==> Integer - BOP ==> BasicOperator - S ==> Symbol - ST ==> String - LST ==> List String - RT ==> RoutinesTable + EF2 ==> ExpressionFunctions2 + EDF ==> Expression DoubleFloat + LDF ==> List DoubleFloat + SDF ==> Stream DoubleFloat + DF ==> DoubleFloat + FI ==> Fraction Integer + EFI ==> Expression Fraction Integer + SOCDF ==> Segment OrderedCompletion DoubleFloat + NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) + MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) + INT ==> Integer + BOP ==> BasicOperator + S ==> Symbol + ST ==> String + LST ==> List String + RT ==> RoutinesTable Rep:=Result import Rep, d01WeightsPackage, d01AgentsPackage, NagIntegrationPackage @@ -23231,22 +23214,22 @@ d01anfAnnaType(): NumericalIntegrationCategory == Result add ++ performs the integration by using \axiomType{NagIntegrationPackage}. d01apfAnnaType(): NumericalIntegrationCategory == Result add - EF2 ==> ExpressionFunctions2 - EDF ==> Expression DoubleFloat - LDF ==> List DoubleFloat - SDF ==> Stream DoubleFloat - DF ==> DoubleFloat - FI ==> Fraction Integer - EFI ==> Expression Fraction Integer - SOCDF ==> Segment OrderedCompletion DoubleFloat - NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) - MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) - INT ==> Integer - BOP ==> BasicOperator - S ==> Symbol - ST ==> String - LST ==> List String - RT ==> RoutinesTable + EF2 ==> ExpressionFunctions2 + EDF ==> Expression DoubleFloat + LDF ==> List DoubleFloat + SDF ==> Stream DoubleFloat + DF ==> DoubleFloat + FI ==> Fraction Integer + EFI ==> Expression Fraction Integer + SOCDF ==> Segment OrderedCompletion DoubleFloat + NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) + MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) + INT ==> Integer + BOP ==> BasicOperator + S ==> Symbol + ST ==> String + LST ==> List String + RT ==> RoutinesTable Rep:=Result import Rep, NagIntegrationPackage, d01AgentsPackage, d01WeightsPackage @@ -23329,29 +23312,29 @@ d01apfAnnaType(): NumericalIntegrationCategory == Result add ++ \axiomType{d01aqfAnnaType} is a domain of ++ \axiomType{NumericalIntegrationCategory} ++ for the NAG routine D01AQF, a general numerical integration routine which -++ can solve an integral of the form \newline -++ \centerline{\inputbitmap{/home/bjd/Axiom/anna/hypertex/bitmaps/d01aqf.xbm}} +++ can solve an integral of the form +++ /home/bjd/Axiom/anna/hypertex/bitmaps/d01aqf.xbm ++ The function \axiomFun{measure} measures the usefulness of the routine ++ D01AQF for the given problem. The function \axiomFun{numericalIntegration} ++ performs the integration by using \axiomType{NagIntegrationPackage}. d01aqfAnnaType(): NumericalIntegrationCategory == Result add - EF2 ==> ExpressionFunctions2 - EDF ==> Expression DoubleFloat - LDF ==> List DoubleFloat - SDF ==> Stream DoubleFloat - DF ==> DoubleFloat - FI ==> Fraction Integer - EFI ==> Expression Fraction Integer - SOCDF ==> Segment OrderedCompletion DoubleFloat - NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) - MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) - INT ==> Integer - BOP ==> BasicOperator - S ==> Symbol - ST ==> String - LST ==> List String - RT ==> RoutinesTable + EF2 ==> ExpressionFunctions2 + EDF ==> Expression DoubleFloat + LDF ==> List DoubleFloat + SDF ==> Stream DoubleFloat + DF ==> DoubleFloat + FI ==> Fraction Integer + EFI ==> Expression Fraction Integer + SOCDF ==> Segment OrderedCompletion DoubleFloat + NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) + MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) + INT ==> Integer + BOP ==> BasicOperator + S ==> Symbol + ST ==> String + LST ==> List String + RT ==> RoutinesTable Rep:=Result import Rep, d01AgentsPackage, NagIntegrationPackage @@ -23437,22 +23420,22 @@ d01aqfAnnaType(): NumericalIntegrationCategory == Result add ++ performs the integration by using \axiomType{NagIntegrationPackage}. d01asfAnnaType(): NumericalIntegrationCategory == Result add - EF2 ==> ExpressionFunctions2 - EDF ==> Expression DoubleFloat - LDF ==> List DoubleFloat - SDF ==> Stream DoubleFloat - DF ==> DoubleFloat - FI ==> Fraction Integer - EFI ==> Expression Fraction Integer - SOCDF ==> Segment OrderedCompletion DoubleFloat - NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) - MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) - INT ==> Integer - BOP ==> BasicOperator - S ==> Symbol - ST ==> String - LST ==> List String - RT ==> RoutinesTable + EF2 ==> ExpressionFunctions2 + EDF ==> Expression DoubleFloat + LDF ==> List DoubleFloat + SDF ==> Stream DoubleFloat + DF ==> DoubleFloat + FI ==> Fraction Integer + EFI ==> Expression Fraction Integer + SOCDF ==> Segment OrderedCompletion DoubleFloat + NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) + MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) + INT ==> Integer + BOP ==> BasicOperator + S ==> Symbol + ST ==> String + LST ==> List String + RT ==> RoutinesTable Rep:=Result import Rep, d01WeightsPackage, d01AgentsPackage, NagIntegrationPackage @@ -23534,22 +23517,22 @@ d01asfAnnaType(): NumericalIntegrationCategory == Result add ++ performs the integration by using \axiomType{NagIntegrationPackage}. d01fcfAnnaType(): NumericalIntegrationCategory == Result add - EF2 ==> ExpressionFunctions2 - EDF ==> Expression DoubleFloat - LDF ==> List DoubleFloat - SDF ==> Stream DoubleFloat - DF ==> DoubleFloat - FI ==> Fraction Integer - EFI ==> Expression Fraction Integer - SOCDF ==> Segment OrderedCompletion DoubleFloat - NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) - MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) - INT ==> Integer - BOP ==> BasicOperator - S ==> Symbol - ST ==> String - LST ==> List String - RT ==> RoutinesTable + EF2 ==> ExpressionFunctions2 + EDF ==> Expression DoubleFloat + LDF ==> List DoubleFloat + SDF ==> Stream DoubleFloat + DF ==> DoubleFloat + FI ==> Fraction Integer + EFI ==> Expression Fraction Integer + SOCDF ==> Segment OrderedCompletion DoubleFloat + NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) + MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) + INT ==> Integer + BOP ==> BasicOperator + S ==> Symbol + ST ==> String + LST ==> List String + RT ==> RoutinesTable Rep:=Result import Rep, d01AgentsPackage, NagIntegrationPackage @@ -23622,22 +23605,22 @@ d01fcfAnnaType(): NumericalIntegrationCategory == Result add ++ performs the integration by using \axiomType{NagIntegrationPackage}. d01gbfAnnaType(): NumericalIntegrationCategory == Result add - EF2 ==> ExpressionFunctions2 - EDF ==> Expression DoubleFloat - LDF ==> List DoubleFloat - SDF ==> Stream DoubleFloat - DF ==> DoubleFloat - FI ==> Fraction Integer - EFI ==> Expression Fraction Integer - SOCDF ==> Segment OrderedCompletion DoubleFloat - NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) - MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) - INT ==> Integer - BOP ==> BasicOperator - S ==> Symbol - ST ==> String - LST ==> List String - RT ==> RoutinesTable + EF2 ==> ExpressionFunctions2 + EDF ==> Expression DoubleFloat + LDF ==> List DoubleFloat + SDF ==> Stream DoubleFloat + DF ==> DoubleFloat + FI ==> Fraction Integer + EFI ==> Expression Fraction Integer + SOCDF ==> Segment OrderedCompletion DoubleFloat + NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) + MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) + INT ==> Integer + BOP ==> BasicOperator + S ==> Symbol + ST ==> String + LST ==> List String + RT ==> RoutinesTable Rep:=Result import Rep, d01AgentsPackage, NagIntegrationPackage @@ -23712,25 +23695,26 @@ d01gbfAnnaType(): NumericalIntegrationCategory == Result add ++ \axiomType{d01TransformFunctionType} uses the mapping \spad{x -> 1/x} ++ and contains the functions \axiomFun{measure} and ++ \axiomFun{numericalIntegration}. -EDF ==> Expression DoubleFloat -EEDF ==> Equation Expression DoubleFloat -FI ==> Fraction Integer -EFI ==> Expression Fraction Integer -EEFI ==> Equation Expression Fraction Integer -EF2 ==> ExpressionFunctions2 -DF ==> DoubleFloat -F ==> Float -SOCDF ==> Segment OrderedCompletion DoubleFloat -OCDF ==> OrderedCompletion DoubleFloat -NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) + +EDF ==> Expression DoubleFloat +EEDF ==> Equation Expression DoubleFloat +FI ==> Fraction Integer +EFI ==> Expression Fraction Integer +EEFI ==> Equation Expression Fraction Integer +EF2 ==> ExpressionFunctions2 +DF ==> DoubleFloat +F ==> Float +SOCDF ==> Segment OrderedCompletion DoubleFloat +OCDF ==> OrderedCompletion DoubleFloat +NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) INT ==> Integer -PI ==> PositiveInteger -HINT ==> Record(str:String,fn:EDF,range:SOCDF,ext:Result) -S ==> Symbol -ST ==> String -LST ==> List String -Measure ==> Record(measure:F,explanations:ST,extra:Result) -MS ==> Record(measure:F,name:ST,explanations:LST,extra:Result) +PI ==> PositiveInteger +HINT ==> Record(str:String,fn:EDF,range:SOCDF,ext:Result) +S ==> Symbol +ST ==> String +LST ==> List String +Measure ==> Record(measure:F,explanations:ST,extra:Result) +MS ==> Record(measure:F,name:ST,explanations:LST,extra:Result) d01TransformFunctionType():NumericalIntegrationCategory == Result add Rep:=Result @@ -23854,7 +23838,7 @@ d01TransformFunctionType():NumericalIntegrationCategory == Result add recResult:Record(key:S,entry:Any):=[result@S,anyResult] recAbserr:Record(key:S,entry:Any):=[abserr pretend S,anyAbserr] insert!(recAbserr,insert!(recResult,ans))$Result - + @ <>= "D01TRNS" [color="#88FF44",href="bookvol10.3.pdf#nameddest=D01TRNS"] @@ -23894,29 +23878,28 @@ d01TransformFunctionType():NumericalIntegrationCategory == Result add ++ function \axiomFun{ODESolve} performs the integration by using ++ \axiomType{NagOrdinaryDifferentialEquationsPackage}. - d02bbfAnnaType():OrdinaryDifferentialEquationsSolverCategory == Result add -- Runge Kutta - EDF ==> Expression DoubleFloat - LDF ==> List DoubleFloat - MDF ==> Matrix DoubleFloat - DF ==> DoubleFloat - F ==> Float - FI ==> Fraction Integer - EFI ==> Expression Fraction Integer - SOCDF ==> Segment OrderedCompletion DoubleFloat - VEDF ==> Vector Expression DoubleFloat - VEF ==> Vector Expression Float - EF ==> Expression Float - VDF ==> Vector DoubleFloat - VMF ==> Vector MachineFloat - MF ==> MachineFloat - ODEA ==> Record(xinit:DF,xend:DF,fn:VEDF,yinit:LDF,intvals:LDF,_ + EDF ==> Expression DoubleFloat + LDF ==> List DoubleFloat + MDF ==> Matrix DoubleFloat + DF ==> DoubleFloat + F ==> Float + FI ==> Fraction Integer + EFI ==> Expression Fraction Integer + SOCDF ==> Segment OrderedCompletion DoubleFloat + VEDF ==> Vector Expression DoubleFloat + VEF ==> Vector Expression Float + EF ==> Expression Float + VDF ==> Vector DoubleFloat + VMF ==> Vector MachineFloat + MF ==> MachineFloat + ODEA ==> Record(xinit:DF,xend:DF,fn:VEDF,yinit:LDF,intvals:LDF,_ g:EDF,abserr:DF,relerr:DF) - RSS ==> Record(stiffnessFactor:F,stabilityFactor:F) - INT ==> Integer - EF2 ==> ExpressionFunctions2 + RSS ==> Record(stiffnessFactor:F,stabilityFactor:F) + INT ==> Integer + EF2 ==> ExpressionFunctions2 import d02AgentsPackage, NagOrdinaryDifferentialEquationsPackage import AttributeButtons @@ -24010,25 +23993,25 @@ d02bbfAnnaType():OrdinaryDifferentialEquationsSolverCategory == Result add d02bhfAnnaType():OrdinaryDifferentialEquationsSolverCategory == Result add -- Runge Kutta - EDF ==> Expression DoubleFloat - LDF ==> List DoubleFloat - MDF ==> Matrix DoubleFloat - DF ==> DoubleFloat - F ==> Float - FI ==> Fraction Integer - EFI ==> Expression Fraction Integer - SOCDF ==> Segment OrderedCompletion DoubleFloat - VEDF ==> Vector Expression DoubleFloat - VEF ==> Vector Expression Float - EF ==> Expression Float - VDF ==> Vector DoubleFloat - VMF ==> Vector MachineFloat - MF ==> MachineFloat - ODEA ==> Record(xinit:DF,xend:DF,fn:VEDF,yinit:LDF,intvals:LDF,_ + EDF ==> Expression DoubleFloat + LDF ==> List DoubleFloat + MDF ==> Matrix DoubleFloat + DF ==> DoubleFloat + F ==> Float + FI ==> Fraction Integer + EFI ==> Expression Fraction Integer + SOCDF ==> Segment OrderedCompletion DoubleFloat + VEDF ==> Vector Expression DoubleFloat + VEF ==> Vector Expression Float + EF ==> Expression Float + VDF ==> Vector DoubleFloat + VMF ==> Vector MachineFloat + MF ==> MachineFloat + ODEA ==> Record(xinit:DF,xend:DF,fn:VEDF,yinit:LDF,intvals:LDF,_ g:EDF,abserr:DF,relerr:DF) - RSS ==> Record(stiffnessFactor:F,stabilityFactor:F) - INT ==> Integer - EF2 ==> ExpressionFunctions2 + RSS ==> Record(stiffnessFactor:F,stabilityFactor:F) + INT ==> Integer + EF2 ==> ExpressionFunctions2 import d02AgentsPackage, NagOrdinaryDifferentialEquationsPackage import AttributeButtons @@ -24120,25 +24103,25 @@ d02bhfAnnaType():OrdinaryDifferentialEquationsSolverCategory == Result add d02cjfAnnaType():OrdinaryDifferentialEquationsSolverCategory == Result add -- Adams - EDF ==> Expression DoubleFloat - LDF ==> List DoubleFloat - MDF ==> Matrix DoubleFloat - DF ==> DoubleFloat - F ==> Float - FI ==> Fraction Integer - EFI ==> Expression Fraction Integer - SOCDF ==> Segment OrderedCompletion DoubleFloat - VEDF ==> Vector Expression DoubleFloat - VEF ==> Vector Expression Float - EF ==> Expression Float - VDF ==> Vector DoubleFloat - VMF ==> Vector MachineFloat - MF ==> MachineFloat - ODEA ==> Record(xinit:DF,xend:DF,fn:VEDF,yinit:LDF,intvals:LDF,_ + EDF ==> Expression DoubleFloat + LDF ==> List DoubleFloat + MDF ==> Matrix DoubleFloat + DF ==> DoubleFloat + F ==> Float + FI ==> Fraction Integer + EFI ==> Expression Fraction Integer + SOCDF ==> Segment OrderedCompletion DoubleFloat + VEDF ==> Vector Expression DoubleFloat + VEF ==> Vector Expression Float + EF ==> Expression Float + VDF ==> Vector DoubleFloat + VMF ==> Vector MachineFloat + MF ==> MachineFloat + ODEA ==> Record(xinit:DF,xend:DF,fn:VEDF,yinit:LDF,intvals:LDF,_ g:EDF,abserr:DF,relerr:DF) - RSS ==> Record(stiffnessFactor:F,stabilityFactor:F) - INT ==> Integer - EF2 ==> ExpressionFunctions2 + RSS ==> Record(stiffnessFactor:F,stabilityFactor:F) + INT ==> Integer + EF2 ==> ExpressionFunctions2 import d02AgentsPackage, NagOrdinaryDifferentialEquationsPackage @@ -24223,25 +24206,25 @@ d02cjfAnnaType():OrdinaryDifferentialEquationsSolverCategory == Result add d02ejfAnnaType():OrdinaryDifferentialEquationsSolverCategory == Result add -- BDF "Stiff" - EDF ==> Expression DoubleFloat - LDF ==> List DoubleFloat - MDF ==> Matrix DoubleFloat - DF ==> DoubleFloat - F ==> Float - FI ==> Fraction Integer - EFI ==> Expression Fraction Integer - SOCDF ==> Segment OrderedCompletion DoubleFloat - VEDF ==> Vector Expression DoubleFloat - VEF ==> Vector Expression Float - EF ==> Expression Float - VDF ==> Vector DoubleFloat - VMF ==> Vector MachineFloat - MF ==> MachineFloat - ODEA ==> Record(xinit:DF,xend:DF,fn:VEDF,yinit:LDF,intvals:LDF,_ + EDF ==> Expression DoubleFloat + LDF ==> List DoubleFloat + MDF ==> Matrix DoubleFloat + DF ==> DoubleFloat + F ==> Float + FI ==> Fraction Integer + EFI ==> Expression Fraction Integer + SOCDF ==> Segment OrderedCompletion DoubleFloat + VEDF ==> Vector Expression DoubleFloat + VEF ==> Vector Expression Float + EF ==> Expression Float + VDF ==> Vector DoubleFloat + VMF ==> Vector MachineFloat + MF ==> MachineFloat + ODEA ==> Record(xinit:DF,xend:DF,fn:VEDF,yinit:LDF,intvals:LDF,_ g:EDF,abserr:DF,relerr:DF) - RSS ==> Record(stiffnessFactor:F,stabilityFactor:F) - INT ==> Integer - EF2 ==> ExpressionFunctions2 + RSS ==> Record(stiffnessFactor:F,stabilityFactor:F) + INT ==> Integer + EF2 ==> ExpressionFunctions2 import d02AgentsPackage, NagOrdinaryDifferentialEquationsPackage @@ -24349,23 +24332,24 @@ d02ejfAnnaType():OrdinaryDifferentialEquationsSolverCategory == Result add ++ \axiomType{d03eefAnnaType} is a domain of ++ \axiomType{PartialDifferentialEquationsSolverCategory} ++ for the NAG routines D03EEF/D03EDF. + d03eefAnnaType():PartialDifferentialEquationsSolverCategory == Result add -- 2D Elliptic PDE - LEDF ==> List Expression DoubleFloat - EDF ==> Expression DoubleFloat - LDF ==> List DoubleFloat - MDF ==> Matrix DoubleFloat - DF ==> DoubleFloat - F ==> Float - FI ==> Fraction Integer - VEF ==> Vector Expression Float - EF ==> Expression Float - MEF ==> Matrix Expression Float - NNI ==> NonNegativeInteger - INT ==> Integer - PDEC ==> Record(start:DF, finish:DF, grid:NNI, boundaryType:INT, + LEDF ==> List Expression DoubleFloat + EDF ==> Expression DoubleFloat + LDF ==> List DoubleFloat + MDF ==> Matrix DoubleFloat + DF ==> DoubleFloat + F ==> Float + FI ==> Fraction Integer + VEF ==> Vector Expression Float + EF ==> Expression Float + MEF ==> Matrix Expression Float + NNI ==> NonNegativeInteger + INT ==> Integer + PDEC ==> Record(start:DF, finish:DF, grid:NNI, boundaryType:INT, dStart:MDF, dFinish:MDF) - PDEB ==> Record(pde:LEDF, constraints:List PDEC, + PDEB ==> Record(pde:LEDF, constraints:List PDEC, f:List LEDF, st:String, tol:DF) import d03AgentsPackage, NagPartialDifferentialEquationsPackage @@ -24442,23 +24426,24 @@ d03eefAnnaType():PartialDifferentialEquationsSolverCategory == Result add ++ \axiomType{d03fafAnnaType} is a domain of ++ \axiomType{PartialDifferentialEquationsSolverCategory} ++ for the NAG routine D03FAF. + d03fafAnnaType():PartialDifferentialEquationsSolverCategory == Result add -- 3D Helmholtz PDE - LEDF ==> List Expression DoubleFloat - EDF ==> Expression DoubleFloat - LDF ==> List DoubleFloat - MDF ==> Matrix DoubleFloat - DF ==> DoubleFloat - F ==> Float - FI ==> Fraction Integer - VEF ==> Vector Expression Float - EF ==> Expression Float - MEF ==> Matrix Expression Float - NNI ==> NonNegativeInteger - INT ==> Integer - PDEC ==> Record(start:DF, finish:DF, grid:NNI, boundaryType:INT, + LEDF ==> List Expression DoubleFloat + EDF ==> Expression DoubleFloat + LDF ==> List DoubleFloat + MDF ==> Matrix DoubleFloat + DF ==> DoubleFloat + F ==> Float + FI ==> Fraction Integer + VEF ==> Vector Expression Float + EF ==> Expression Float + MEF ==> Matrix Expression Float + NNI ==> NonNegativeInteger + INT ==> Integer + PDEC ==> Record(start:DF, finish:DF, grid:NNI, boundaryType:INT, dStart:MDF, dFinish:MDF) - PDEB ==> Record(pde:LEDF, constraints:List PDEC, + PDEB ==> Record(pde:LEDF, constraints:List PDEC, f:List LEDF, st:String, tol:DF) import d03AgentsPackage, NagPartialDifferentialEquationsPackage @@ -24730,10 +24715,10 @@ o )show Equation ++ Examples: ++ References: ++ Description: -++ Equations as mathematical objects. All properties of the basis domain, -++ 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. +++ Equations as mathematical objects. All properties of the basis domain, +++ 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. -- The interpreter translates "=" to "equation". Otherwise, it will -- find a modemap for "=" in the domain of the arguments. @@ -25123,9 +25108,10 @@ o )show EqTable ++ Examples: ++ References: ++ Description: -++ 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. +++ 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. + EqTable(Key: SetCategory, Entry: SetCategory) == HashTable(Key, Entry, "EQ") @@ -25191,11 +25177,13 @@ EqTable(Key: SetCategory, Entry: SetCategory) == <>= )abbrev domain EMR EuclideanModularRing +++ Author: Mark Botch ++ Description: ++ 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} + EuclideanModularRing(S,R,Mod,reduction:(R,Mod) -> R, merge:(Mod,Mod) -> Union(Mod,"failed"), exactQuo : (R,R,Mod) -> Union(R,"failed")) : C == T @@ -25205,20 +25193,20 @@ EuclideanModularRing(S,R,Mod,reduction:(R,Mod) -> R, Mod : AbelianMonoid C == EuclideanDomain with - modulus : % -> Mod - ++ modulus(x) \undocumented - coerce : % -> R - ++ coerce(x) \undocumented - reduce : (R,Mod) -> % - ++ reduce(r,m) \undocumented - exQuo : (%,%) -> Union(%,"failed") - ++ exQuo(x,y) \undocumented - recip : % -> Union(%,"failed") - ++ recip(x) \undocumented - inv : % -> % - ++ inv(x) \undocumented - elt : (%, R) -> R - ++ elt(x,r) or x.r \undocumented + modulus : % -> Mod + ++ modulus(x) is not documented + coerce : % -> R + ++ coerce(x) is not documented + reduce : (R,Mod) -> % + ++ reduce(r,m) is not documented + exQuo : (%,%) -> Union(%,"failed") + ++ exQuo(x,y) is not documented + recip : % -> Union(%,"failed") + ++ recip(x) is not documented + inv : % -> % + ++ inv(x) is not documented + elt : (%, R) -> R + ++ elt(x,r) or x.r is not documented T == ModularRing(R,Mod,reduction,merge,exactQuo) add @@ -25427,12 +25415,13 @@ o )show Exit ++ Examples: ++ References: ++ Description: -++ A function which does not return directly to its caller should -++ have Exit as its return type. +++ A function which does not return directly to its caller should +++ have Exit as its return type. ++ -++ 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}. +++ Note that 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}. + Exit: SetCategory == add coerce(n:%) == error "Cannot use an Exit value." n1 = n2 == error "Cannot use an Exit value." @@ -25552,10 +25541,11 @@ Exit: SetCategory == add ++ Examples: ++ References: ++ Description: -++ 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. +++ 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. + ExponentialExpansion(R,FE,var,cen): Exports == Implementation where R : Join(OrderedSet,RetractableTo Integer,_ LinearlyExplicitRingOver Integer,GcdDomain) @@ -26235,12 +26225,13 @@ o )show Expression <>= )abbrev domain EXPR Expression -++ Top-level mathematical expressions ++ Author: Manuel Bronstein ++ Date Created: 19 July 1988 ++ Date Last Updated: October 1993 (P.Gianni), February 1995 (MB) -++ Description: Expressions involving symbolic functions. ++ Keywords: operator, kernel, function. +++ Description: +++ Top-level mathematical expressions involving symbolic functions. + Expression(R:OrderedSet): Exports == Implementation where Q ==> Fraction Integer K ==> Kernel % @@ -26270,14 +26261,14 @@ Expression(R:OrderedSet): Exports == Implementation where ++ reduce(f) simplifies all the unreduced algebraic quantities ++ present in f by applying their defining relations. number?: % -> Boolean - ++ number?(f) tests if f is rational + ++ number?(f) tests if f is rational simplifyPower: (%,Integer) -> % - ++ simplifyPower?(f,n) \undocumented{} + ++ simplifyPower?(f,n) is not documented if R has GcdDomain then factorPolynomial : SUP % -> Factored SUP % - ++ factorPolynomial(p) \undocumented{} + ++ factorPolynomial(p) is not documented squareFreePolynomial : SUP % -> Factored SUP % - ++ squareFreePolynomial(p) \undocumented{} + ++ squareFreePolynomial(p) is not documented if R has RetractableTo Integer then RetractableTo AN Implementation ==> add @@ -26567,7 +26558,7 @@ Expression(R:OrderedSet): Exports == Implementation where eval(f:%, op: BasicOperator, g:%, x:Symbol):% == eval(f,[op],[g],x) eval(f:%, ls:List BasicOperator, lg:List %, x:Symbol) == - -- handle subsrcipted symbols by renaming -> eval -> renaming back + -- handle subsrcipted symbols by renaming -> eval -> renaming back llsym:List List Symbol:=[variables g for g in lg] lsym:List Symbol:= removeDuplicates concat llsym lsd:List Symbol:=select (scripted?,lsym) @@ -26899,17 +26890,18 @@ Expression(R:OrderedSet): Exports == Implementation where ++ Examples: ++ References: ++ Description: -++ 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))}, 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. +++ 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))}, 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. + ExponentialOfUnivariatePuiseuxSeries(FE,var,cen):_ Exports == Implementation where FE : Join(Field,OrderedSet) @@ -26991,24 +26983,23 @@ ExponentialOfUnivariatePuiseuxSeries(FE,var,cen):_ <>= )abbrev domain EAB ExtAlgBasis ---% ExtAlgBasis -++ Author: Larry Lambe -++ Date created: 03/14/89 -++ Description: -++ A domain used in the construction of the exterior algebra on a set -++ X over a ring R. This domain represents the set of all ordered -++ subsets of the set X, assumed to be in correspondance with -++ {1,2,3, ...}. The ordered subsets are themselves ordered -++ lexicographically and are in bijective correspondance 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. --- Thus we really have L({0,1}). +++ Author: Larry Lambe +++ Date created: 03/14/89 +++ Description: +++ A domain used in the construction of the exterior algebra on a set +++ X over a ring R. This domain represents the set of all ordered +++ subsets of the set X, assumed to be in correspondance with +++ {1,2,3, ...}. The ordered subsets are themselves ordered +++ lexicographically and are in bijective correspondance 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. +-- Thus we really have L({0,1}). ++ -++ The multiplicative identity element of the exterior algebra corresponds -++ to the empty subset of 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. +++ The multiplicative identity element of the exterior algebra corresponds +++ to the empty subset of 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. ExtAlgBasis(): Export == Implement where I ==> Integer @@ -27017,24 +27008,24 @@ ExtAlgBasis(): Export == Implement where Export == OrderedSet with coerce : L I -> % - ++ coerce(l) converts a list of 0's and 1's into a basis - ++ element, where 1 (respectively 0) designates that the + ++ coerce(l) converts a list of 0's and 1's into a basis + ++ element, where 1 (respectively 0) designates that the ++ variable of the corresponding index of l is (respectively, is not) ++ present. ++ Error: if an element of l is not 0 or 1. degree : % -> NNI - ++ degree(x) gives the numbers of 1's in x, i.e., the number - ++ of non-zero exponents in the basis element that x represents. + ++ degree(x) gives the numbers of 1's in x, i.e., the number + ++ of non-zero exponents in the basis element that x represents. exponents : % -> L I - ++ exponents(x) converts a domain element into a list of zeros - ++ and ones corresponding to the exponents in the basis element - ++ that x represents. + ++ exponents(x) converts a domain element into a list of zeros + ++ and ones corresponding to the exponents in the basis element + ++ that x represents. -- subscripts : % -> L I - -- subscripts(x) looks at the exponents in x and converts - -- them to the proper subscripts + -- subscripts(x) looks at the exponents in x and converts + -- them to the proper subscripts Nul : NNI -> % - ++ Nul() gives the basis element 1 for the algebra generated - ++ by n generators. + ++ Nul() gives the basis element 1 for the algebra generated + ++ by n generators. Implement == add Rep := L I @@ -27117,34 +27108,34 @@ ExtAlgBasis(): Export == Implement where ++ performs the optimization by using \axiomType{NagOptimisationPackage}. e04dgfAnnaType(): NumericalOptimizationCategory == Result add - DF ==> DoubleFloat - EF ==> Expression Float - EDF ==> Expression DoubleFloat - PDF ==> Polynomial DoubleFloat - VPDF ==> Vector Polynomial DoubleFloat - LDF ==> List DoubleFloat - LOCDF ==> List OrderedCompletion DoubleFloat - MDF ==> Matrix DoubleFloat - MPDF ==> Matrix Polynomial DoubleFloat - MF ==> Matrix Float - MEF ==> Matrix Expression Float - LEDF ==> List Expression DoubleFloat - VEF ==> Vector Expression Float - NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) - LSA ==> Record(lfn:LEDF, init:LDF) - EF2 ==> ExpressionFunctions2 - MI ==> Matrix Integer - INT ==> Integer - F ==> Float - NNI ==> NonNegativeInteger - S ==> Symbol - LS ==> List Symbol - MVCF ==> MultiVariableCalculusFunctions + DF ==> DoubleFloat + EF ==> Expression Float + EDF ==> Expression DoubleFloat + PDF ==> Polynomial DoubleFloat + VPDF ==> Vector Polynomial DoubleFloat + LDF ==> List DoubleFloat + LOCDF ==> List OrderedCompletion DoubleFloat + MDF ==> Matrix DoubleFloat + MPDF ==> Matrix Polynomial DoubleFloat + MF ==> Matrix Float + MEF ==> Matrix Expression Float + LEDF ==> List Expression DoubleFloat + VEF ==> Vector Expression Float + NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) + LSA ==> Record(lfn:LEDF, init:LDF) + EF2 ==> ExpressionFunctions2 + MI ==> Matrix Integer + INT ==> Integer + F ==> Float + NNI ==> NonNegativeInteger + S ==> Symbol + LS ==> List Symbol + MVCF ==> MultiVariableCalculusFunctions ESTOOLS2 ==> ExpertSystemToolsPackage2 - SDF ==> Stream DoubleFloat - LSDF ==> List Stream DoubleFloat - SOCDF ==> Segment OrderedCompletion DoubleFloat - OCDF ==> OrderedCompletion DoubleFloat + SDF ==> Stream DoubleFloat + LSDF ==> List Stream DoubleFloat + SOCDF ==> Segment OrderedCompletion DoubleFloat + OCDF ==> OrderedCompletion DoubleFloat Rep:=Result import Rep, NagOptimisationPackage, ExpertSystemToolsPackage @@ -27214,35 +27205,36 @@ e04dgfAnnaType(): NumericalOptimizationCategory == Result add ++ \axiomFun{measure} measures the usefulness of the routine E04FDF ++ for the given problem. The function \axiomFun{numericalOptimization} ++ performs the optimization by using \axiomType{NagOptimisationPackage}. + e04fdfAnnaType(): NumericalOptimizationCategory == Result add - DF ==> DoubleFloat - EF ==> Expression Float - EDF ==> Expression DoubleFloat - PDF ==> Polynomial DoubleFloat - VPDF ==> Vector Polynomial DoubleFloat - LDF ==> List DoubleFloat - LOCDF ==> List OrderedCompletion DoubleFloat - MDF ==> Matrix DoubleFloat - MPDF ==> Matrix Polynomial DoubleFloat - MF ==> Matrix Float - MEF ==> Matrix Expression Float - LEDF ==> List Expression DoubleFloat - VEF ==> Vector Expression Float - NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) - LSA ==> Record(lfn:LEDF, init:LDF) - EF2 ==> ExpressionFunctions2 - MI ==> Matrix Integer - INT ==> Integer - F ==> Float - NNI ==> NonNegativeInteger - S ==> Symbol - LS ==> List Symbol - MVCF ==> MultiVariableCalculusFunctions + DF ==> DoubleFloat + EF ==> Expression Float + EDF ==> Expression DoubleFloat + PDF ==> Polynomial DoubleFloat + VPDF ==> Vector Polynomial DoubleFloat + LDF ==> List DoubleFloat + LOCDF ==> List OrderedCompletion DoubleFloat + MDF ==> Matrix DoubleFloat + MPDF ==> Matrix Polynomial DoubleFloat + MF ==> Matrix Float + MEF ==> Matrix Expression Float + LEDF ==> List Expression DoubleFloat + VEF ==> Vector Expression Float + NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) + LSA ==> Record(lfn:LEDF, init:LDF) + EF2 ==> ExpressionFunctions2 + MI ==> Matrix Integer + INT ==> Integer + F ==> Float + NNI ==> NonNegativeInteger + S ==> Symbol + LS ==> List Symbol + MVCF ==> MultiVariableCalculusFunctions ESTOOLS2 ==> ExpertSystemToolsPackage2 - SDF ==> Stream DoubleFloat - LSDF ==> List Stream DoubleFloat - SOCDF ==> Segment OrderedCompletion DoubleFloat - OCDF ==> OrderedCompletion DoubleFloat + SDF ==> Stream DoubleFloat + LSDF ==> List Stream DoubleFloat + SOCDF ==> Segment OrderedCompletion DoubleFloat + OCDF ==> OrderedCompletion DoubleFloat Rep:=Result import Rep, NagOptimisationPackage @@ -27338,35 +27330,36 @@ e04fdfAnnaType(): NumericalOptimizationCategory == Result add ++ \axiomFun{measure} measures the usefulness of the routine E04GCF ++ for the given problem. The function \axiomFun{numericalOptimization} ++ performs the optimization by using \axiomType{NagOptimisationPackage}. + e04gcfAnnaType(): NumericalOptimizationCategory == Result add - DF ==> DoubleFloat - EF ==> Expression Float - EDF ==> Expression DoubleFloat - PDF ==> Polynomial DoubleFloat - VPDF ==> Vector Polynomial DoubleFloat - LDF ==> List DoubleFloat - LOCDF ==> List OrderedCompletion DoubleFloat - MDF ==> Matrix DoubleFloat - MPDF ==> Matrix Polynomial DoubleFloat - MF ==> Matrix Float - MEF ==> Matrix Expression Float - LEDF ==> List Expression DoubleFloat - VEF ==> Vector Expression Float - NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) - LSA ==> Record(lfn:LEDF, init:LDF) - EF2 ==> ExpressionFunctions2 - MI ==> Matrix Integer - INT ==> Integer - F ==> Float - NNI ==> NonNegativeInteger - S ==> Symbol - LS ==> List Symbol - MVCF ==> MultiVariableCalculusFunctions + DF ==> DoubleFloat + EF ==> Expression Float + EDF ==> Expression DoubleFloat + PDF ==> Polynomial DoubleFloat + VPDF ==> Vector Polynomial DoubleFloat + LDF ==> List DoubleFloat + LOCDF ==> List OrderedCompletion DoubleFloat + MDF ==> Matrix DoubleFloat + MPDF ==> Matrix Polynomial DoubleFloat + MF ==> Matrix Float + MEF ==> Matrix Expression Float + LEDF ==> List Expression DoubleFloat + VEF ==> Vector Expression Float + NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) + LSA ==> Record(lfn:LEDF, init:LDF) + EF2 ==> ExpressionFunctions2 + MI ==> Matrix Integer + INT ==> Integer + F ==> Float + NNI ==> NonNegativeInteger + S ==> Symbol + LS ==> List Symbol + MVCF ==> MultiVariableCalculusFunctions ESTOOLS2 ==> ExpertSystemToolsPackage2 - SDF ==> Stream DoubleFloat - LSDF ==> List Stream DoubleFloat - SOCDF ==> Segment OrderedCompletion DoubleFloat - OCDF ==> OrderedCompletion DoubleFloat + SDF ==> Stream DoubleFloat + LSDF ==> List Stream DoubleFloat + SOCDF ==> Segment OrderedCompletion DoubleFloat + OCDF ==> OrderedCompletion DoubleFloat Rep:=Result import Rep, NagOptimisationPackage,ExpertSystemContinuityPackage @@ -27478,35 +27471,36 @@ e04gcfAnnaType(): NumericalOptimizationCategory == Result add ++ \axiomFun{measure} measures the usefulness of the routine E04JAF ++ for the given problem. The function \axiomFun{numericalOptimization} ++ performs the optimization by using \axiomType{NagOptimisationPackage}. + e04jafAnnaType(): NumericalOptimizationCategory == Result add - DF ==> DoubleFloat - EF ==> Expression Float - EDF ==> Expression DoubleFloat - PDF ==> Polynomial DoubleFloat - VPDF ==> Vector Polynomial DoubleFloat - LDF ==> List DoubleFloat - LOCDF ==> List OrderedCompletion DoubleFloat - MDF ==> Matrix DoubleFloat - MPDF ==> Matrix Polynomial DoubleFloat - MF ==> Matrix Float - MEF ==> Matrix Expression Float - LEDF ==> List Expression DoubleFloat - VEF ==> Vector Expression Float - NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) - LSA ==> Record(lfn:LEDF, init:LDF) - EF2 ==> ExpressionFunctions2 - MI ==> Matrix Integer - INT ==> Integer - F ==> Float - NNI ==> NonNegativeInteger - S ==> Symbol - LS ==> List Symbol - MVCF ==> MultiVariableCalculusFunctions + DF ==> DoubleFloat + EF ==> Expression Float + EDF ==> Expression DoubleFloat + PDF ==> Polynomial DoubleFloat + VPDF ==> Vector Polynomial DoubleFloat + LDF ==> List DoubleFloat + LOCDF ==> List OrderedCompletion DoubleFloat + MDF ==> Matrix DoubleFloat + MPDF ==> Matrix Polynomial DoubleFloat + MF ==> Matrix Float + MEF ==> Matrix Expression Float + LEDF ==> List Expression DoubleFloat + VEF ==> Vector Expression Float + NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) + LSA ==> Record(lfn:LEDF, init:LDF) + EF2 ==> ExpressionFunctions2 + MI ==> Matrix Integer + INT ==> Integer + F ==> Float + NNI ==> NonNegativeInteger + S ==> Symbol + LS ==> List Symbol + MVCF ==> MultiVariableCalculusFunctions ESTOOLS2 ==> ExpertSystemToolsPackage2 - SDF ==> Stream DoubleFloat - LSDF ==> List Stream DoubleFloat - SOCDF ==> Segment OrderedCompletion DoubleFloat - OCDF ==> OrderedCompletion DoubleFloat + SDF ==> Stream DoubleFloat + LSDF ==> List Stream DoubleFloat + SOCDF ==> Segment OrderedCompletion DoubleFloat + OCDF ==> OrderedCompletion DoubleFloat Rep:=Result import Rep, NagOptimisationPackage @@ -27593,35 +27587,36 @@ e04jafAnnaType(): NumericalOptimizationCategory == Result add ++ \axiomFun{measure} measures the usefulness of the routine E04MBF ++ for the given problem. The function \axiomFun{numericalOptimization} ++ performs the optimization by using \axiomType{NagOptimisationPackage}. + e04mbfAnnaType(): NumericalOptimizationCategory == Result add - DF ==> DoubleFloat - EF ==> Expression Float - EDF ==> Expression DoubleFloat - PDF ==> Polynomial DoubleFloat - VPDF ==> Vector Polynomial DoubleFloat - LDF ==> List DoubleFloat - LOCDF ==> List OrderedCompletion DoubleFloat - MDF ==> Matrix DoubleFloat - MPDF ==> Matrix Polynomial DoubleFloat - MF ==> Matrix Float - MEF ==> Matrix Expression Float - LEDF ==> List Expression DoubleFloat - VEF ==> Vector Expression Float - NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) - LSA ==> Record(lfn:LEDF, init:LDF) - EF2 ==> ExpressionFunctions2 - MI ==> Matrix Integer - INT ==> Integer - F ==> Float - NNI ==> NonNegativeInteger - S ==> Symbol - LS ==> List Symbol - MVCF ==> MultiVariableCalculusFunctions + DF ==> DoubleFloat + EF ==> Expression Float + EDF ==> Expression DoubleFloat + PDF ==> Polynomial DoubleFloat + VPDF ==> Vector Polynomial DoubleFloat + LDF ==> List DoubleFloat + LOCDF ==> List OrderedCompletion DoubleFloat + MDF ==> Matrix DoubleFloat + MPDF ==> Matrix Polynomial DoubleFloat + MF ==> Matrix Float + MEF ==> Matrix Expression Float + LEDF ==> List Expression DoubleFloat + VEF ==> Vector Expression Float + NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) + LSA ==> Record(lfn:LEDF, init:LDF) + EF2 ==> ExpressionFunctions2 + MI ==> Matrix Integer + INT ==> Integer + F ==> Float + NNI ==> NonNegativeInteger + S ==> Symbol + LS ==> List Symbol + MVCF ==> MultiVariableCalculusFunctions ESTOOLS2 ==> ExpertSystemToolsPackage2 - SDF ==> Stream DoubleFloat - LSDF ==> List Stream DoubleFloat - SOCDF ==> Segment OrderedCompletion DoubleFloat - OCDF ==> OrderedCompletion DoubleFloat + SDF ==> Stream DoubleFloat + LSDF ==> List Stream DoubleFloat + SOCDF ==> Segment OrderedCompletion DoubleFloat + OCDF ==> OrderedCompletion DoubleFloat Rep:=Result import Rep, NagOptimisationPackage @@ -27694,35 +27689,36 @@ e04mbfAnnaType(): NumericalOptimizationCategory == Result add ++ \axiomFun{measure} measures the usefulness of the routine E04NAF ++ for the given problem. The function \axiomFun{numericalOptimization} ++ performs the optimization by using \axiomType{NagOptimisationPackage}. + e04nafAnnaType(): NumericalOptimizationCategory == Result add - DF ==> DoubleFloat - EF ==> Expression Float - EDF ==> Expression DoubleFloat - PDF ==> Polynomial DoubleFloat - VPDF ==> Vector Polynomial DoubleFloat - LDF ==> List DoubleFloat - LOCDF ==> List OrderedCompletion DoubleFloat - MDF ==> Matrix DoubleFloat - MPDF ==> Matrix Polynomial DoubleFloat - MF ==> Matrix Float - MEF ==> Matrix Expression Float - LEDF ==> List Expression DoubleFloat - VEF ==> Vector Expression Float - NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) - LSA ==> Record(lfn:LEDF, init:LDF) - EF2 ==> ExpressionFunctions2 - MI ==> Matrix Integer - INT ==> Integer - F ==> Float - NNI ==> NonNegativeInteger - S ==> Symbol - LS ==> List Symbol - MVCF ==> MultiVariableCalculusFunctions + DF ==> DoubleFloat + EF ==> Expression Float + EDF ==> Expression DoubleFloat + PDF ==> Polynomial DoubleFloat + VPDF ==> Vector Polynomial DoubleFloat + LDF ==> List DoubleFloat + LOCDF ==> List OrderedCompletion DoubleFloat + MDF ==> Matrix DoubleFloat + MPDF ==> Matrix Polynomial DoubleFloat + MF ==> Matrix Float + MEF ==> Matrix Expression Float + LEDF ==> List Expression DoubleFloat + VEF ==> Vector Expression Float + NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) + LSA ==> Record(lfn:LEDF, init:LDF) + EF2 ==> ExpressionFunctions2 + MI ==> Matrix Integer + INT ==> Integer + F ==> Float + NNI ==> NonNegativeInteger + S ==> Symbol + LS ==> List Symbol + MVCF ==> MultiVariableCalculusFunctions ESTOOLS2 ==> ExpertSystemToolsPackage2 - SDF ==> Stream DoubleFloat - LSDF ==> List Stream DoubleFloat - SOCDF ==> Segment OrderedCompletion DoubleFloat - OCDF ==> OrderedCompletion DoubleFloat + SDF ==> Stream DoubleFloat + LSDF ==> List Stream DoubleFloat + SOCDF ==> Segment OrderedCompletion DoubleFloat + OCDF ==> OrderedCompletion DoubleFloat Rep:=Result import Rep, NagOptimisationPackage @@ -27810,35 +27806,36 @@ e04nafAnnaType(): NumericalOptimizationCategory == Result add ++ \axiomFun{measure} measures the usefulness of the routine E04UCF ++ for the given problem. The function \axiomFun{numericalOptimization} ++ performs the optimization by using \axiomType{NagOptimisationPackage}. + e04ucfAnnaType(): NumericalOptimizationCategory == Result add - DF ==> DoubleFloat - EF ==> Expression Float - EDF ==> Expression DoubleFloat - PDF ==> Polynomial DoubleFloat - VPDF ==> Vector Polynomial DoubleFloat - LDF ==> List DoubleFloat - LOCDF ==> List OrderedCompletion DoubleFloat - MDF ==> Matrix DoubleFloat - MPDF ==> Matrix Polynomial DoubleFloat - MF ==> Matrix Float - MEF ==> Matrix Expression Float - LEDF ==> List Expression DoubleFloat - VEF ==> Vector Expression Float - NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) - LSA ==> Record(lfn:LEDF, init:LDF) - EF2 ==> ExpressionFunctions2 - MI ==> Matrix Integer - INT ==> Integer - F ==> Float - NNI ==> NonNegativeInteger - S ==> Symbol - LS ==> List Symbol - MVCF ==> MultiVariableCalculusFunctions + DF ==> DoubleFloat + EF ==> Expression Float + EDF ==> Expression DoubleFloat + PDF ==> Polynomial DoubleFloat + VPDF ==> Vector Polynomial DoubleFloat + LDF ==> List DoubleFloat + LOCDF ==> List OrderedCompletion DoubleFloat + MDF ==> Matrix DoubleFloat + MPDF ==> Matrix Polynomial DoubleFloat + MF ==> Matrix Float + MEF ==> Matrix Expression Float + LEDF ==> List Expression DoubleFloat + VEF ==> Vector Expression Float + NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) + LSA ==> Record(lfn:LEDF, init:LDF) + EF2 ==> ExpressionFunctions2 + MI ==> Matrix Integer + INT ==> Integer + F ==> Float + NNI ==> NonNegativeInteger + S ==> Symbol + LS ==> List Symbol + MVCF ==> MultiVariableCalculusFunctions ESTOOLS2 ==> ExpertSystemToolsPackage2 - SDF ==> Stream DoubleFloat - LSDF ==> List Stream DoubleFloat - SOCDF ==> Segment OrderedCompletion DoubleFloat - OCDF ==> OrderedCompletion DoubleFloat + SDF ==> Stream DoubleFloat + LSDF ==> List Stream DoubleFloat + SOCDF ==> Segment OrderedCompletion DoubleFloat + OCDF ==> OrderedCompletion DoubleFloat Rep:=Result import Rep,NagOptimisationPackage @@ -28609,19 +28606,19 @@ o )show Factored ++ Keywords: factorization, prime, square-free, irreducible, factor ++ References: ++ Description: -++ \spadtype{Factored} creates a domain whose objects are kept in -++ factored form as long as possible. Thus certain operations like -++ multiplication and 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 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. +++ \spadtype{Factored} creates a domain whose objects are kept in +++ factored form as long as possible. Thus certain operations like +++ multiplication and 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 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. Factored(R: IntegralDomain): Exports == Implementation where fUnion ==> Union("nil", "sqfr", "irred", "prime") @@ -29385,8 +29382,8 @@ o )show File ++ Examples: ++ References: ++ Description: -++ This domain provides a basic model of files to save arbitrary values. -++ The operations provide sequential access to the contents. +++ This domain provides a basic model of files to save arbitrary values. +++ The operations provide sequential access to the contents. File(S:SetCategory): FileCategory(FileName, S) with readIfCan_!: % -> Union(S, "failed") @@ -29774,7 +29771,7 @@ o )show FileName ++ Examples: ++ References: ++ Description: -++ This domain provides an interface to names in the file system. +++ This domain provides an interface to names in the file system. FileName(): FileNameCategory == add @@ -29839,7 +29836,6 @@ FileName(): FileNameCategory == add <>= )abbrev domain FDIV FiniteDivisor -++ Finite rational divisors on a curve ++ Author: Manuel Bronstein ++ Date Created: 1987 ++ Date Last Updated: 29 July 1993 @@ -29849,6 +29845,7 @@ FileName(): FileNameCategory == add ++ P's are finite rational points on the curve. ++ Keywords: divisor, algebraic, curve. ++ Examples: )r FDIV INPUT + FiniteDivisor(F, UP, UPUP, R): Exports == Implementation where F : Field UP : UnivariatePolynomialCategory F @@ -29861,7 +29858,7 @@ FiniteDivisor(F, UP, UPUP, R): Exports == Implementation where Exports ==> FiniteDivisorCategory(F, UP, UPUP, R) with finiteBasis: % -> Vector R - ++ finiteBasis(d) returns a basis for d as a module over {\em K[x]}. + ++ finiteBasis(d) returns a basis for d as a module over K[x]. lSpaceBasis: % -> Vector R ++ lSpaceBasis(d) returns a basis for \spad{L(d) = {f | (f) >= -d}} ++ as a module over \spad{K[x]}. @@ -30072,7 +30069,7 @@ FiniteDivisor(F, UP, UPUP, R): Exports == Implementation where <>= )abbrev domain FF FiniteField -++ Author: ??? +++ Author: Mark Botch ++ Date Created: ??? ++ Date Last Updated: 29 May 1990 ++ Basic Operations: @@ -30083,13 +30080,14 @@ FiniteDivisor(F, UP, UPUP, R): Exports == Implementation where ++ finite extension, finite field, Galois field ++ Reference: ++ R.Lidl, H.Niederreiter: Finite Field, Encyclopedia of Mathematics an -++ Its Applications, Vol. 20, Cambridge Univ. Press, 1983, ISBN 0 521 30240 4 +++ Its Applications, Vol. 20, Cambridge Univ. Press, 1983, ISBN 0 521 30240 4 ++ J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM. -++ AXIOM Technical Report Series, ATR/5 NP2522. +++ AXIOM Technical Report Series, ATR/5 NP2522. ++ Description: -++ FiniteField(p,n) implements finite fields with p**n elements. -++ This packages checks that p is prime. -++ For a non-checking version, see \spadtype{InnerFiniteField}. +++ FiniteField(p,n) implements finite fields with p**n elements. +++ This packages checks that p is prime. +++ For a non-checking version, see \spadtype{InnerFiniteField}. + FiniteField(p:PositiveInteger, n:PositiveInteger): _ FiniteAlgebraicExtensionField(PrimeField p) ==_ FiniteFieldExtensionByPolynomial(PrimeField p,_ @@ -30218,15 +30216,15 @@ FiniteField(p:PositiveInteger, n:PositiveInteger): _ ++ R.Lidl, H.Niederreiter: Finite Field, Encycoldia of Mathematics and ++ Its Applications, Vol. 20, Cambridge Univ. Press, 1983, ISBN 0 521 30240 4 ++ Description: -++ FiniteFieldCyclicGroup(p,n) implements a finite field extension of degee n -++ over the prime field with p elements. Its elements are represented by -++ powers of a primitive element, 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. +++ FiniteFieldCyclicGroup(p,n) implements a finite field extension of degee n +++ over the prime field with p elements. Its elements are represented by +++ powers of a primitive element, i.e. a generator of the multiplicative +++ (cyclic) group. As primitive element we choose the root of the extension +++ polynomial, which is created by 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. FiniteFieldCyclicGroup(p,extdeg):_ Exports == Implementation where @@ -30364,16 +30362,15 @@ FiniteFieldCyclicGroup(p,extdeg):_ ++ J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM. ++ AXIOM Technical Report Series, ATR/5 NP2522. ++ Description: -++ FiniteFieldCyclicGroupExtension(GF,n) implements a extension of degree n -++ over the ground field {\em GF}. Its elements are represented by powers of -++ a primitive element, 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. - +++ FiniteFieldCyclicGroupExtension(GF,n) implements a extension of degree n +++ over the ground field GF. Its elements are represented by powers of +++ a primitive element, i.e. a generator of the multiplicative (cyclic) group. +++ As primitive element we choose the root of the extension polynomial, which +++ is created by 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. FiniteFieldCyclicGroupExtension(GF,extdeg):_ Exports == Implementation where @@ -30511,16 +30508,15 @@ FiniteFieldCyclicGroupExtension(GF,extdeg):_ ++ J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM. ++ AXIOM Technical Report Series, ATR/5 NP2522. ++ Description: -++ FiniteFieldCyclicGroupExtensionByPolynomial(GF,defpol) implements a -++ finite extension field of the ground field {\em GF}. Its elements are -++ represented by powers of a primitive element, 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. - +++ FiniteFieldCyclicGroupExtensionByPolynomial(GF,defpol) implements a +++ finite extension field of the ground field GF. Its elements are +++ represented by powers of a primitive element, i.e. a generator of the +++ multiplicative (cyclic) group. As primitive +++ element we choose the root of the extension polynomial 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. FiniteFieldCyclicGroupExtensionByPolynomial(GF,defpol):_ Exports == Implementation where @@ -30926,11 +30922,11 @@ FiniteFieldCyclicGroupExtensionByPolynomial(GF,defpol):_ ++ J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM. ++ AXIOM Technical Report Series, ATR/5 NP2522. ++ Description: -++ FiniteFieldExtensionByPolynomial(GF, n) implements an extension -++ of the finite field {\em GF} of degree n generated by the extension -++ polynomial constructed by -++ \spadfunFrom{createIrreduciblePoly}{FiniteFieldPolynomialPackage} from -++ \spadtype{FiniteFieldPolynomialPackage}. +++ FiniteFieldExtensionByPolynomial(GF, n) implements an extension +++ of the finite field GF of degree n generated by the extension +++ polynomial constructed by createIrreduciblePoly from +++ \spadtype{FiniteFieldPolynomialPackage}. + FiniteFieldExtension(GF, n): Exports == Implementation where GF: FiniteFieldCategory n : PositiveInteger @@ -31066,11 +31062,11 @@ FiniteFieldExtension(GF, n): Exports == Implementation where ++ J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM. ++ AXIOM Technical Report Series, ATR/5 NP2522. ++ Description: -++ FiniteFieldExtensionByPolynomial(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. +++ FiniteFieldExtensionByPolynomial(GF, defpol) implements the extension +++ of the finite field GF generated by the extension polynomial +++ defpol which MUST be irreducible. +++ Note: the user has the responsibility to ensure that +++ defpol is irreducible. FiniteFieldExtensionByPolynomial(GF:FiniteFieldCategory,_ defpol:SparseUnivariatePolynomial GF): Exports == Implementation where @@ -31404,14 +31400,15 @@ FiniteFieldExtensionByPolynomial(GF:FiniteFieldCategory,_ ++ J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM. ++ AXIOM Technical Report Series, ATR/5 NP2522. ++ Description: -++ FiniteFieldNormalBasis(p,n) implements a -++ finite extension field of degree n over the prime field with p elements. -++ The elements are represented by coordinate vectors with respect to -++ a normal basis, -++ i.e. a basis consisting of the conjugates (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}. +++ FiniteFieldNormalBasis(p,n) implements a +++ finite extension field of degree n over the prime field with p elements. +++ The elements are represented by coordinate vectors with respect to +++ a normal basis, +++ i.e. a basis consisting of the conjugates (q-powers) of an element, in +++ this case called normal element. +++ This is chosen as a root of the extension polynomial +++ created by createNormalPoly + FiniteFieldNormalBasis(p,extdeg):_ Exports == Implementation where p : PositiveInteger @@ -31559,14 +31556,15 @@ FiniteFieldNormalBasis(p,extdeg):_ ++ J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM. ++ AXIOM Technical Report Series, ATR/5 NP2522. ++ Description: -++ FiniteFieldNormalBasisExtensionByPolynomial(GF,n) implements a -++ finite extension field of degree n over the ground field {\em GF}. -++ The elements are represented by coordinate vectors with respect -++ to a normal basis, -++ i.e. a basis consisting of the conjugates (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} +++ FiniteFieldNormalBasisExtensionByPolynomial(GF,n) implements a +++ finite extension field of degree n over the ground field GF. +++ The elements are represented by coordinate vectors with respect +++ to a normal basis, +++ i.e. a basis consisting of the conjugates (q-powers) of an element, in +++ this case called normal element. This is chosen as a root of the extension +++ polynomial, created by createNormalPoly from +++ \spadtype{FiniteFieldPolynomialPackage} + FiniteFieldNormalBasisExtension(GF,extdeg):_ Exports == Implementation where GF : FiniteFieldCategory -- the ground field @@ -31714,14 +31712,15 @@ FiniteFieldNormalBasisExtension(GF,extdeg):_ ++ J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM . ++ AXIOM Technical Report Series, ATR/5 NP2522. ++ Description: -++ FiniteFieldNormalBasisExtensionByPolynomial(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, -++ i.e. a basis -++ consisting of the conjugates (q-powers) of an element, in this case -++ called normal element, where 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) +++ FiniteFieldNormalBasisExtensionByPolynomial(GF,uni) implements a +++ finite extension of the ground field GF. The elements are +++ represented by coordinate vectors with respect to. a normal basis, +++ i.e. a basis +++ consisting of the conjugates (q-powers) of an element, in this case +++ called normal element, where q is the size of GF. +++ The normal element is chosen as a root of the extension +++ polynomial, which MUST be normal over GF (user responsibility) + FiniteFieldNormalBasisExtensionByPolynomial(GF,uni): Exports == _ Implementation where GF : FiniteFieldCategory -- the ground field @@ -32418,10 +32417,12 @@ o )show FlexibleArray <>= )abbrev domain FARRAY FlexibleArray +++ Author: Mark Botch +++ Description: ++ A FlexibleArray is the notion of an array intended to allow for growth ++ at the end only. Hence the following efficient operations -++ \spad{append(x,a)} meaning append item x at the end of the array \spad{a} -++ \spad{delete(a,n)} meaning delete the last item from the array \spad{a} +++ \spad{append(x,a)} meaning append item x at the end of the array \spad{a} +++ \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 @@ -33623,38 +33624,35 @@ N ==> NonNegativeInteger ++ atan, convert, exp1, log2, log10, normalize, rationalApproximation, ++ relerror, shift, / , ** ++ Keywords: float, floating point, number -++ Description: \spadtype{Float} implements arbitrary precision floating -++ point arithmetic. +++ Description: +++ \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 \spad{float(mantissa,exponent,\spadfunFrom{base}{FloatingPointSystem})} for integer +++ The operation \spad{float(mantissa,exponent,base)} for integer ++ \spad{mantissa}, \spad{exponent} specifies the number -++ \spad{mantissa * \spadfunFrom{base}{FloatingPointSystem} ** exponent} +++ \spad{mantissa * base ** exponent} ++ The underlying representation for floats is binary ++ not decimal. The implications of this are described below. ++ ++ The model adopted is that arithmetic operations are rounded to ++ to nearest unit in the last place, that is, accurate to within -++ \spad{2**(-\spadfunFrom{bits}{FloatingPointSystem})}. -++ Also, the elementary functions and constants are +++ \spad{2**(-bits)}. 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}. +++ and the exponent. The base 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 +++ with a binary base, the code will be most efficient when this is the ++ the case (this is true in most implementations of Lisp). -++ The decision to choose the \spadfunFrom{base}{FloatingPointSystem} to be -++ binary has some unfortunate +++ The decision to choose the base 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 d ++ digits of precision are specified, \spad{1 + ceiling(log2 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 +++ be incurred if we chose to use a decimal base when the underlying ++ integer base is binary. ++ ++ Algorithms used: @@ -33680,12 +33678,12 @@ N ==> NonNegativeInteger ++ package at low precisions could be improved by a factor of 2 ++ if in-place operations were available. ++ -++ Running times: in the following, n is the number of bits of precision -++ \spad{*}, \spad{/}, \spad{sqrt}, \spad{pi}, \spad{exp1}, \spad{log2}, \spad{log10}: \spad{ O( n**2 )} -++ \spad{exp}, \spad{log}, \spad{sin}, \spad{atan}: \spad{ O( sqrt(n) n**2 )} +++ Running times: in the following, n is the number of bits of precision\br +++ \spad{*}, \spad{/}, \spad{sqrt}, \spad{pi}, \spad{exp1}, \spad{log2}, +++ \spad{log10}: \spad{ O( n**2 )} \br +++ \spad{exp}, \spad{log}, \spad{sin}, \spad{atan}: \spad{O(sqrt(n) n**2)}\br ++ The other elementary functions are coded in terms of the ones above. - Float(): Join(FloatingPointSystem, DifferentialRing, ConvertibleTo String, OpenMath,_ CoercibleTo DoubleFloat, TranscendentalFunctionCategory, ConvertibleTo InputForm) with @@ -34644,8 +34642,6 @@ Float(): <>= )abbrev domain FC FortranCode --- The FortranCode domain is used to represent operations which are to be --- translated into FORTRAN. ++ Author: Mike Dewar ++ Date Created: April 1991 ++ Date Last Updated: 22 March 1994 @@ -34663,6 +34659,7 @@ Float(): ++ Description: ++ This domain builds representations of program code segments for use with ++ the FortranProgram domain. + FortranCode(): public == private where L ==> List PI ==> PositiveInteger @@ -34681,7 +34678,7 @@ FortranCode(): public == private where Repeat:"repeat", Goto:"goto", Continue:"continue", - ArrayAssignment:"arrayAssignment", + ArrayAssignment:"arrayAssignment", Save:"save", Stop:"stop", Common:"common", @@ -35340,9 +35337,11 @@ FortranCode(): public == private where ++ Keywords: ++ Examples: ++ References: -++ Description: A domain of expressions involving functions which can be +++ Description: +++ A domain of expressions involving functions which can be ++ translated into standard Fortran-77, with some extra extensions from ++ the NAG Fortran Library. + FortranExpression(basicSymbols,subscriptedSymbols,R): Exports==Implementation where basicSymbols : List Symbol @@ -35361,102 +35360,102 @@ FortranExpression(basicSymbols,subscriptedSymbols,R): PartialDifferentialRing(Symbol)) with retract : EXPR R -> $ ++ retract(e) takes e and transforms it into a - ++ FortranExpression checking that it contains no non-Fortran - ++ functions, and that it only contains the given basic symbols - ++ and subscripted symbols which correspond to scalar and array - ++ parameters respectively. + ++ FortranExpression checking that it contains no non-Fortran + ++ functions, and that it only contains the given basic symbols + ++ and subscripted symbols which correspond to scalar and array + ++ parameters respectively. retractIfCan : EXPR R -> Union($,"failed") ++ retractIfCan(e) takes e and tries to transform it into a - ++ FortranExpression checking that it contains no non-Fortran - ++ functions, and that it only contains the given basic symbols - ++ and subscripted symbols which correspond to scalar and array - ++ parameters respectively. + ++ FortranExpression checking that it contains no non-Fortran + ++ functions, and that it only contains the given basic symbols + ++ and subscripted symbols which correspond to scalar and array + ++ parameters respectively. retract : S -> $ ++ retract(e) takes e and transforms it into a FortranExpression - ++ checking that it is one of the given basic symbols - ++ or subscripted symbols which correspond to scalar and array - ++ parameters respectively. + ++ checking that it is one of the given basic symbols + ++ or subscripted symbols which correspond to scalar and array + ++ parameters respectively. retractIfCan : S -> Union($,"failed") - ++ retractIfCan(e) takes e and tries to transform it into a FortranExpression - ++ checking that it is one of the given basic symbols - ++ or subscripted symbols which correspond to scalar and array - ++ parameters respectively. + ++ retractIfCan(e) takes e and tries to transform it into a + ++ FortranExpression checking that it is one of the given basic symbols + ++ or subscripted symbols which correspond to scalar and array + ++ parameters respectively. coerce : $ -> EXPR R - ++ coerce(x) \undocumented{} + ++ coerce(x) is not documented if (R has RetractableTo(Integer)) then retract : EXPR Integer -> $ ++ retract(e) takes e and transforms it into a - ++ FortranExpression checking that it contains no non-Fortran - ++ functions, and that it only contains the given basic symbols - ++ and subscripted symbols which correspond to scalar and array - ++ parameters respectively. + ++ FortranExpression checking that it contains no non-Fortran + ++ functions, and that it only contains the given basic symbols + ++ and subscripted symbols which correspond to scalar and array + ++ parameters respectively. retractIfCan : EXPR Integer -> Union($,"failed") ++ retractIfCan(e) takes e and tries to transform it into a - ++ FortranExpression checking that it contains no non-Fortran - ++ functions, and that it only contains the given basic symbols - ++ and subscripted symbols which correspond to scalar and array - ++ parameters respectively. + ++ FortranExpression checking that it contains no non-Fortran + ++ functions, and that it only contains the given basic symbols + ++ and subscripted symbols which correspond to scalar and array + ++ parameters respectively. retract : FRAC POLY Integer -> $ ++ retract(e) takes e and transforms it into a - ++ FortranExpression checking that it contains no non-Fortran - ++ functions, and that it only contains the given basic symbols - ++ and subscripted symbols which correspond to scalar and array - ++ parameters respectively. + ++ FortranExpression checking that it contains no non-Fortran + ++ functions, and that it only contains the given basic symbols + ++ and subscripted symbols which correspond to scalar and array + ++ parameters respectively. retractIfCan : FRAC POLY Integer -> Union($,"failed") ++ retractIfCan(e) takes e and tries to transform it into a - ++ FortranExpression checking that it contains no non-Fortran - ++ functions, and that it only contains the given basic symbols - ++ and subscripted symbols which correspond to scalar and array - ++ parameters respectively. + ++ FortranExpression checking that it contains no non-Fortran + ++ functions, and that it only contains the given basic symbols + ++ and subscripted symbols which correspond to scalar and array + ++ parameters respectively. retract : POLY Integer -> $ ++ retract(e) takes e and transforms it into a - ++ FortranExpression checking that it contains no non-Fortran - ++ functions, and that it only contains the given basic symbols - ++ and subscripted symbols which correspond to scalar and array - ++ parameters respectively. + ++ FortranExpression checking that it contains no non-Fortran + ++ functions, and that it only contains the given basic symbols + ++ and subscripted symbols which correspond to scalar and array + ++ parameters respectively. retractIfCan : POLY Integer -> Union($,"failed") ++ retractIfCan(e) takes e and tries to transform it into a - ++ FortranExpression checking that it contains no non-Fortran - ++ functions, and that it only contains the given basic symbols - ++ and subscripted symbols which correspond to scalar and array - ++ parameters respectively. + ++ FortranExpression checking that it contains no non-Fortran + ++ functions, and that it only contains the given basic symbols + ++ and subscripted symbols which correspond to scalar and array + ++ parameters respectively. if (R has RetractableTo(Float)) then retract : EXPR Float -> $ ++ retract(e) takes e and transforms it into a - ++ FortranExpression checking that it contains no non-Fortran - ++ functions, and that it only contains the given basic symbols - ++ and subscripted symbols which correspond to scalar and array - ++ parameters respectively. + ++ FortranExpression checking that it contains no non-Fortran + ++ functions, and that it only contains the given basic symbols + ++ and subscripted symbols which correspond to scalar and array + ++ parameters respectively. retractIfCan : EXPR Float -> Union($,"failed") ++ retractIfCan(e) takes e and tries to transform it into a - ++ FortranExpression checking that it contains no non-Fortran - ++ functions, and that it only contains the given basic symbols - ++ and subscripted symbols which correspond to scalar and array - ++ parameters respectively. + ++ FortranExpression checking that it contains no non-Fortran + ++ functions, and that it only contains the given basic symbols + ++ and subscripted symbols which correspond to scalar and array + ++ parameters respectively. retract : FRAC POLY Float -> $ ++ retract(e) takes e and transforms it into a - ++ FortranExpression checking that it contains no non-Fortran - ++ functions, and that it only contains the given basic symbols - ++ and subscripted symbols which correspond to scalar and array - ++ parameters respectively. + ++ FortranExpression checking that it contains no non-Fortran + ++ functions, and that it only contains the given basic symbols + ++ and subscripted symbols which correspond to scalar and array + ++ parameters respectively. retractIfCan : FRAC POLY Float -> Union($,"failed") ++ retractIfCan(e) takes e and tries to transform it into a - ++ FortranExpression checking that it contains no non-Fortran - ++ functions, and that it only contains the given basic symbols - ++ and subscripted symbols which correspond to scalar and array - ++ parameters respectively. + ++ FortranExpression checking that it contains no non-Fortran + ++ functions, and that it only contains the given basic symbols + ++ and subscripted symbols which correspond to scalar and array + ++ parameters respectively. retract : POLY Float -> $ ++ retract(e) takes e and transforms it into a - ++ FortranExpression checking that it contains no non-Fortran - ++ functions, and that it only contains the given basic symbols - ++ and subscripted symbols which correspond to scalar and array - ++ parameters respectively. + ++ FortranExpression checking that it contains no non-Fortran + ++ functions, and that it only contains the given basic symbols + ++ and subscripted symbols which correspond to scalar and array + ++ parameters respectively. retractIfCan : POLY Float -> Union($,"failed") ++ retractIfCan(e) takes e and tries to transform it into a - ++ FortranExpression checking that it contains no non-Fortran - ++ functions, and that it only contains the given basic symbols - ++ and subscripted symbols which correspond to scalar and array - ++ parameters respectively. + ++ FortranExpression checking that it contains no non-Fortran + ++ functions, and that it only contains the given basic symbols + ++ and subscripted symbols which correspond to scalar and array + ++ parameters respectively. abs : $ -> $ ++ abs(x) represents the Fortran intrinsic function ABS sqrt : $ -> $ @@ -35706,9 +35705,11 @@ FortranExpression(basicSymbols,subscriptedSymbols,R): ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: \axiomType{FortranProgram} allows the user to build and manipulate simple -++ models of FORTRAN subprograms. These can then be transformed into actual FORTRAN -++ notation. +++ Description: +++ \axiomType{FortranProgram} allows the user to build and manipulate simple +++ models of FORTRAN subprograms. These can then be transformed into +++ actual FORTRAN notation. + FortranProgram(name,returnType,arguments,symbols): Exports == Implement where name : Symbol returnType : Union(fst:FortranScalarType,void:"void") @@ -35725,36 +35726,36 @@ FortranProgram(name,returnType,arguments,symbols): Exports == Implement where REP ==> Record(localSymbols : SymbolTable, code : List FortranCode) Exports ==> FortranProgramCategory with - coerce : FortranCode -> $ - ++ coerce(fc) \undocumented{} - coerce : List FortranCode -> $ - ++ coerce(lfc) \undocumented{} - coerce : REP -> $ - ++ coerce(r) \undocumented{} - coerce : EXPR MINT -> $ - ++ coerce(e) \undocumented{} - coerce : EXPR MFLOAT -> $ - ++ coerce(e) \undocumented{} - coerce : EXPR MCMPLX -> $ - ++ coerce(e) \undocumented{} - coerce : Equation EXPR MINT -> $ - ++ coerce(eq) \undocumented{} - coerce : Equation EXPR MFLOAT -> $ - ++ coerce(eq) \undocumented{} - coerce : Equation EXPR MCMPLX -> $ - ++ coerce(eq) \undocumented{} - coerce : EXPR INT -> $ - ++ coerce(e) \undocumented{} - coerce : EXPR Float -> $ - ++ coerce(e) \undocumented{} - coerce : EXPR CMPX Float -> $ - ++ coerce(e) \undocumented{} - coerce : Equation EXPR INT -> $ - ++ coerce(eq) \undocumented{} - coerce : Equation EXPR Float -> $ - ++ coerce(eq) \undocumented{} - coerce : Equation EXPR CMPX Float -> $ - ++ coerce(eq) \undocumented{} + coerce : FortranCode -> $ + ++ coerce(fc) is not documented + coerce : List FortranCode -> $ + ++ coerce(lfc) is not documented + coerce : REP -> $ + ++ coerce(r) is not documented + coerce : EXPR MINT -> $ + ++ coerce(e) is not documented + coerce : EXPR MFLOAT -> $ + ++ coerce(e) is not documented + coerce : EXPR MCMPLX -> $ + ++ coerce(e) is not documented + coerce : Equation EXPR MINT -> $ + ++ coerce(eq) is not documented + coerce : Equation EXPR MFLOAT -> $ + ++ coerce(eq) is not documented + coerce : Equation EXPR MCMPLX -> $ + ++ coerce(eq) is not documented + coerce : EXPR INT -> $ + ++ coerce(e) is not documented + coerce : EXPR Float -> $ + ++ coerce(e) is not documented + coerce : EXPR CMPX Float -> $ + ++ coerce(e) is not documented + coerce : Equation EXPR INT -> $ + ++ coerce(eq) is not documented + coerce : Equation EXPR Float -> $ + ++ coerce(eq) is not documented + coerce : Equation EXPR CMPX Float -> $ + ++ coerce(eq) is not documented Implement ==> add @@ -35958,8 +35959,10 @@ FortranProgram(name,returnType,arguments,symbols): Exports == Implement where ++ Keywords: ++ Examples: ++ References: -++ Description: Creates and manipulates objects which correspond to the +++ Description: +++ Creates and manipulates objects which correspond to the ++ basic FORTRAN data types: REAL, INTEGER, COMPLEX, LOGICAL and CHARACTER + FortranScalarType() : exports == implementation where exports == CoercibleTo OutputForm with @@ -36150,7 +36153,9 @@ FortranScalarType() : exports == implementation where ++ Keywords: ++ Examples: ++ References: -++ Description: Code to manipulate Fortran templates +++ Description: +++ Code to manipulate Fortran templates + FortranTemplate() : specification == implementation where specification == FileCategory(FileName, String) with @@ -36276,8 +36281,10 @@ FortranTemplate() : specification == implementation where ++ Keywords: ++ Examples: ++ References: -++ Description: Creates and manipulates objects which correspond to FORTRAN +++ Description: +++ Creates and manipulates objects which correspond to FORTRAN ++ data types, including array dimensions. + FortranType() : exports == implementation where FST ==> FortranScalarType @@ -36415,7 +36422,9 @@ FortranType() : exports == implementation where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: +++ Description: +++ This domain creates kernels for use in Fourier series + FourierComponent(E:OrderedSet): OrderedSet with sin: E -> $ @@ -36496,6 +36505,8 @@ FourierComponent(E:OrderedSet): ++ Keywords: ++ References: ++ Description: +++ This domain converts terms into Fourier series + FourierSeries(R:Join(CommutativeRing,Algebra(Fraction Integer)), E:Join(OrderedSet,AbelianGroup)): Algebra(R) with @@ -36913,7 +36924,7 @@ o )show Fraction <>= )abbrev domain FRAC Fraction -++ Author: +++ Author: Mark Botch ++ Date Created: ++ Date Last Updated: 12 February 1992 ++ Basic Functions: Field, numer, denom @@ -36922,15 +36933,17 @@ o )show Fraction ++ AMS Classifications: ++ Keywords: fraction, localization ++ References: -++ Description: Fraction takes an IntegralDomain S and produces +++ Description: +++ Fraction takes an IntegralDomain S and produces ++ the domain of Fractions with numerators and denominators from S. ++ If S is also a GcdDomain, then gcd's between numerator and ++ denominator will be cancelled during all operations. + Fraction(S: IntegralDomain): QuotientFieldCategory S with if S has IntegerNumberSystem and S has OpenMath then OpenMath if S has canonical and S has GcdDomain and S has canonicalUnitNormal - then canonical - ++ \spad{canonical} means that equal elements are in fact identical. + then canonical + ++ \spad{canonical} means that equal elements are in fact identical. == LocalAlgebra(S, S, S) add Rep:= Record(num:S, den:S) coerce(d:S):% == [d,1] @@ -36988,8 +37001,7 @@ Fraction(S: IntegralDomain): QuotientFieldCategory S with OMwrite(x: %): String == s: String := "" sp := OM_-STRINGTOSTRINGPTR(s)$Lisp - dev: OpenMathDevice := _ - OMopenString(sp pretend String, OMencodingXML) + dev: OpenMathDevice := OMopenString(sp pretend String, OMencodingXML) OMputObject(dev) writeOMFrac(dev, x) OMputEndObject(dev) @@ -37000,8 +37012,7 @@ Fraction(S: IntegralDomain): QuotientFieldCategory S with OMwrite(x: %, wholeObj: Boolean): String == s: String := "" sp := OM_-STRINGTOSTRINGPTR(s)$Lisp - dev: OpenMathDevice := _ - OMopenString(sp pretend String, OMencodingXML) + dev: OpenMathDevice := OMopenString(sp pretend String, OMencodingXML) if wholeObj then OMputObject(dev) writeOMFrac(dev, x) @@ -37291,7 +37302,9 @@ Fraction(S: IntegralDomain): QuotientFieldCategory S with ++ Date Last Updated: 30 July 1993 ++ Keywords: ideal, algebra, module. ++ Examples: )r FRIDEAL INPUT -++ Description: Fractional ideals in a framed algebra. +++ Description: +++ Fractional ideals in a framed algebra. + FractionalIdeal(R, F, UP, A): Exports == Implementation where R : EuclideanDomain F : QuotientFieldCategory R @@ -37493,8 +37506,9 @@ FractionalIdeal(R, F, UP, A): Exports == Implementation where ++ Date Created: 27 Jan 1989 ++ Date Last Updated: 24 Jul 1990 ++ Keywords: ideal, algebra, module. -++ Examples: )r FRIDEAL INPUT -++ Description: Module representation of fractional ideals. +++ Description: +++ Module representation of fractional ideals. + FramedModule(R, F, UP, A, ibasis): Exports == Implementation where R : EuclideanDomain F : QuotientFieldCategory R @@ -37652,6 +37666,7 @@ FramedModule(R, F, UP, A, ibasis): Exports == Implementation where ++ The free abelian group on a set S is the monoid of finite sums of ++ the form \spad{reduce(+,[ni * si])} where the si's are in S, and the ni's ++ are integers. The operation is commutative. + FreeAbelianGroup(S:SetCategory): Exports == Implementation where Exports ==> Join(AbelianGroup, Module Integer, FreeAbelianMonoidCategory(S, Integer)) with @@ -37739,6 +37754,7 @@ FreeAbelianGroup(S:SetCategory): Exports == Implementation where ++ The free abelian monoid on a set S is the monoid of finite sums of ++ the form \spad{reduce(+,[ni * si])} where the si's are in S, and the ni's ++ are non-negative integers. The operation is commutative. + FreeAbelianMonoid(S: SetCategory): FreeAbelianMonoidCategory(S, NonNegativeInteger) == InnerFreeAbelianMonoid(S, NonNegativeInteger, 1) @@ -37799,6 +37815,7 @@ FreeAbelianMonoid(S: SetCategory): ++ The free group on a set S is the group of finite products of ++ the form \spad{reduce(*,[si ** ni])} where the si's are in S, and the ni's ++ are integers. The multiplication is not commutative. + FreeGroup(S: SetCategory): Join(Group, RetractableTo S) with "*": (S, $) -> $ ++ s * x returns the product of x by s on the left. @@ -37813,9 +37830,11 @@ FreeGroup(S: SetCategory): Join(Group, RetractableTo S) with nthFactor : ($, Integer) -> S ++ nthFactor(x, n) returns the factor of the n^th monomial of x. mapExpon : (Integer -> Integer, $) -> $ - ++ mapExpon(f, a1\^e1 ... an\^en) returns \spad{a1\^f(e1) ... an\^f(en)}. + ++ mapExpon(f, a1\^e1 ... an\^en) returns + ++ \spad{a1\^f(e1) ... an\^f(en)}. mapGen : (S -> S, $) -> $ - ++ mapGen(f, a1\^e1 ... an\^en) returns \spad{f(a1)\^e1 ... f(an)\^en}. + ++ mapGen(f, a1\^e1 ... an\^en) returns + ++ \spad{f(a1)\^e1 ... f(an)\^en}. factors : $ -> List Record(gen: S, exp: Integer) ++ factors(a1\^e1,...,an\^en) returns \spad{[[a1, e1],...,[an, en]]}. == ListMonoidOps(S, Integer, 1) add @@ -38013,14 +38032,12 @@ FreeModule(R:Ring,S:OrderedSet): ++ Keywords: ++ References: ++ Description: -++ This domain implements linear combinations -++ of elements from the domain \spad{S} with coefficients -++ in the domain \spad{R} where \spad{S} is an ordered set -++ and \spad{R} is a ring (which may be non-commutative). -++ This domain is used by domains of non-commutative algebra such as: -++ \spadtype{XDistributedPolynomial}, -++ \spadtype{XRecursivePolynomial}. -++ Author: Michel Petitot (petitot@lifl.fr) +++ This domain implements linear combinations +++ of elements from the domain \spad{S} with coefficients +++ in the domain \spad{R} where \spad{S} is an ordered set +++ and \spad{R} is a ring (which may be non-commutative). +++ This domain is used by domains of non-commutative algebra such as: +++ XDistributedPolynomial, XRecursivePolynomial. FreeModule1(R:Ring,S:OrderedSet): FMcat == FMdef where EX ==> OutputForm @@ -38164,6 +38181,7 @@ FreeModule1(R:Ring,S:OrderedSet): FMcat == FMdef where ++ The free monoid on a set S is the monoid of finite products of ++ the form \spad{reduce(*,[si ** ni])} where the si's are in S, and the ni's ++ are nonnegative integers. The multiplication is not commutative. + FreeMonoid(S: SetCategory): FMcategory == FMdefinition where NNI ==> NonNegativeInteger REC ==> Record(gen: S, exp: NonNegativeInteger) @@ -38389,7 +38407,8 @@ FreeMonoid(S: SetCategory): FMcategory == FMdefinition where ++ AMS Classification: Primary 17B05, 17B30; Secondary 17A50 ++ Keywords: free Lie algebra, Hall basis, basic commutators ++ Related Constructors: HallBasis, FreeMod, Commutator, OrdSetInts -++ Description: Generate the Free Lie Algebra over a ring R with identity; +++ Description: +++ Generate the Free Lie Algebra over a ring R with identity; ++ A P. Hall basis is generated by a package call to HallBasis. FreeNilpotentLie(n:NNI,class:NNI,R: CommutativeRing): Export == Implement where @@ -38410,9 +38429,9 @@ FreeNilpotentLie(n:NNI,class:NNI,R: CommutativeRing): Export == Implement where dimension : () -> NNI ++ dimension() is the rank of this Lie algebra deepExpand : % -> O - ++ deepExpand(x) \undocumented{} + ++ deepExpand(x) is not documented shallowExpand : % -> O - ++ shallowExpand(x) \undocumented{} + ++ shallowExpand(x) is not documented generator : NNI -> % ++ generator(i) is the ith Hall Basis element @@ -39001,13 +39020,15 @@ o )show FullPartialFractionExpansion <>= )abbrev domain FPARFRAC FullPartialFractionExpansion -++ Full partial fraction expansion of rational functions ++ Author: Manuel Bronstein ++ Date Created: 9 December 1992 ++ Date Last Updated: 6 October 1993 ++ References: M.Bronstein & B.Salvy, ++ Full Partial Fraction Decomposition of Rational Functions, ++ in Proceedings of ISSAC'93, Kiev, ACM Press. +++ Description: +++ Full partial fraction expansion of rational functions + FullPartialFractionExpansion(F, UP): Exports == Implementation where F : Join(Field, CharacteristicZero) UP : UnivariatePolynomialCategory F @@ -39199,11 +39220,13 @@ FullPartialFractionExpansion(F, UP): Exports == Implementation where <>= )abbrev domain FUNCTION FunctionCalled +++ Author: Mark Botch ++ Description: ++ This domain implements named functions + FunctionCalled(f:Symbol): SetCategory with - name: % -> Symbol - ++ name(x) returns the symbol + name: % -> Symbol + ++ name(x) returns the symbol == add name r == f coerce(r:%):OutputForm == f::OutputForm @@ -39537,14 +39560,15 @@ o )show GeneralDistributedMultivariatePolynomial ++ Keywords: polynomial, multivariate, distributed ++ References: ++ Description: -++ This type supports distributed multivariate polynomials +++ 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 +++ 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. GeneralDistributedMultivariatePolynomial(vl,R,E): public == private where @@ -39815,8 +39839,10 @@ GeneralDistributedMultivariatePolynomial(vl,R,E): public == private where <>= )abbrev domain GMODPOL GeneralModulePolynomial +++ Author: Mark Botch ++ Description: -++ This package \undocumented +++ This package is undocumented + GeneralModulePolynomial(vl, R, IS, E, ff, P): public == private where vl: List(Symbol) R: CommutativeRing @@ -39831,26 +39857,26 @@ GeneralModulePolynomial(vl, R, IS, E, ff, P): public == private where public == Join(Module(P), Module(R)) with - leadingCoefficient: $ -> R - ++ leadingCoefficient(x) \undocumented - leadingMonomial: $ -> ModMonom - ++ leadingMonomial(x) \undocumented - leadingExponent: $ -> E - ++ leadingExponent(x) \undocumented - leadingIndex: $ -> IS - ++ leadingIndex(x) \undocumented - reductum: $ -> $ - ++ reductum(x) \undocumented - monomial: (R, ModMonom) -> $ - ++ monomial(r,x) \undocumented - unitVector: IS -> $ - ++ unitVector(x) \undocumented - build: (R, IS, E) -> $ - ++ build(r,i,e) \undocumented - multMonom: (R, E, $) -> $ - ++ multMonom(r,e,x) \undocumented - "*": (P,$) -> $ - ++ p*x \undocumented + leadingCoefficient: $ -> R + ++ leadingCoefficient(x) is not documented + leadingMonomial: $ -> ModMonom + ++ leadingMonomial(x) is not documented + leadingExponent: $ -> E + ++ leadingExponent(x) is not documented + leadingIndex: $ -> IS + ++ leadingIndex(x) is not documented + reductum: $ -> $ + ++ reductum(x) is not documented + monomial: (R, ModMonom) -> $ + ++ monomial(r,x) is not documented + unitVector: IS -> $ + ++ unitVector(x) is not documented + build: (R, IS, E) -> $ + ++ build(r,i,e) is not documented + multMonom: (R, E, $) -> $ + ++ multMonom(r,e,x) is not documented + "*": (P,$) -> $ + ++ p*x is not documented private == FreeModule(R, ModMonom) add @@ -40009,9 +40035,10 @@ GeneralModulePolynomial(vl, R, IS, E, ff, P): public == private where ++ Lectures Notes in Biomathematics 36, ++ Springer-Verlag, Heidelberg, 1980 ++ Description: -++ AlgebraGenericElementPackage allows you to create generic elements -++ of an algebra, i.e. the scalars are extended to include symbolic -++ coefficients +++ AlgebraGenericElementPackage allows you to create generic elements +++ of an algebra, i.e. the scalars are extended to include symbolic +++ coefficients + GenericNonAssociativeAlgebra(R : CommutativeRing, n : PositiveInteger,_ ls : List Symbol, gamma: Vector Matrix R ): public == private where @@ -40364,8 +40391,8 @@ GenericNonAssociativeAlgebra(R : CommutativeRing, n : PositiveInteger,_ ++ AMS Classifications: ++ Keywords: polynomial, multivariate, ordered variables set ++ References: -++ Description: A domain for polynomial sets. -++ Version: 1 +++ Description: +++ A domain for polynomial sets. GeneralPolynomialSet(R,E,VarSet,P) : Exports == Implementation where @@ -40607,8 +40634,9 @@ o )show GeneralSparseTable ++ Examples: ++ References: ++ Description: -++ A sparse table has a default entry, which is returned if no other -++ value has been explicitly stored for a key. +++ A sparse table has a default entry, which is returned if no other +++ value has been explicitly stored for a key. + GeneralSparseTable(Key, Entry, Tbl, dent): TableAggregate(Key, Entry) == Impl where Key, Entry: SetCategory @@ -40738,6 +40766,9 @@ GeneralSparseTable(Key, Entry, Tbl, dent): TableAggregate(Key, Entry) == Impl ++ Also See: ++ AMS Classifications: ++ Keywords: +++ References : +++ [1] P. AUBRY, D. LAZARD and M. MORENO MAZA "On the Theories +++ of Triangular Sets" Journal of Symbol. Comp. (to appear) ++ Description: ++ A domain constructor of the category \axiomType{TriangularSetCategory}. ++ The only requirement for a list of polynomials to be a member of such @@ -40745,11 +40776,7 @@ GeneralSparseTable(Key, Entry, Tbl, dent): TableAggregate(Key, Entry) == Impl ++ polynomials have distinct main variables. Such a triangular set may ++ not be auto-reduced or consistent. Triangular sets are stored ++ as sorted lists w.r.t. the main variables of their members but they -++ are displayed in reverse order.\newline -++ References : -++ [1] P. AUBRY, D. LAZARD and M. MORENO MAZA "On the Theories -++ of Triangular Sets" Journal of Symbol. Comp. (to appear) -++ Version: 1 +++ are displayed in reverse order. GeneralTriangularSet(R,E,V,P) : Exports == Implementation where @@ -40962,11 +40989,12 @@ GeneralTriangularSet(R,E,V,P) : Exports == Implementation where ++ Examples: ++ References: ++ Description: -++ 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 r is a positive rational number and -++ \spad{f(x)} is a Laurent series. This pair represents the Puiseux -++ series \spad{f(x\^r)}. +++ 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 r is a positive rational number and +++ \spad{f(x)} is a Laurent series. This pair represents the Puiseux +++ series \spad{f(x\^r)}. + GeneralUnivariatePowerSeries(Coef,var,cen): Exports == Implementation where Coef : Ring var : Symbol @@ -41101,8 +41129,10 @@ GeneralUnivariatePowerSeries(Coef,var,cen): Exports == Implementation where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: TwoDimensionalGraph creates virtual two dimensional graphs +++ Description: +++ TwoDimensionalGraph creates virtual two dimensional graphs ++ (to be displayed on TwoDimensionalViewports). + GraphImage (): Exports == Implementation where VIEW ==> VIEWPORTSERVER$Lisp @@ -41448,7 +41478,7 @@ GraphImage (): Exports == Implementation where makeGraphImage(llp) == makeGraphImage(llp, [pointColorDefault() for i in 1..(l:=#llp)], - [lineColorDefault() for i in 1..l], + [lineColorDefault() for i in 1..l], [pointSizeDefault() for i in 1..l]) makeGraphImage(llp,lpc,llc,lps) == @@ -41488,8 +41518,8 @@ GraphImage (): Exports == Implementation where coerce (llp : L L P) : $ == makeGraphImage(llp, [pointColorDefault() for i in 1..(l:=#llp)], - [lineColorDefault() for i in 1..l], - [pointSizeDefault() for i in 1..l]) + [lineColorDefault() for i in 1..l], + [pointSizeDefault() for i in 1..l]) coerce (graf : $) : E == hconcat( ["Graph with " :: E,(p := # pointLists graf) :: E, @@ -41536,8 +41566,10 @@ GraphImage (): Exports == Implementation where <>= )abbrev domain GOPT GuessOption ++ Author: Martin Rubey -++ Description: GuessOption is a domain whose elements are various options used +++ Description: +++ GuessOption is a domain whose elements are various options used ++ by \spadtype{Guess}. + GuessOption(): Exports == Implementation where Exports == SetCategory with @@ -41767,9 +41799,9 @@ GuessOption(): Exports == Implementation where ++ Examples: ++ References: ++ Description: -++ This domain provides access to the underlying Lisp hash tables. -++ By varying the hashfn parameter, tables suited for different -++ purposes can be obtained. +++ This domain provides access to the underlying Lisp hash tables. +++ By varying the hashfn parameter, tables suited for different +++ purposes can be obtained. HashTable(Key, Entry, hashfn): Exports == Implementation where Key, Entry: SetCategory @@ -42476,7 +42508,6 @@ o )show BagAggregate ++ Examples: ++ References: ++ Description: - ++ Heap implemented in a flexible array to allow for insertions ++ Complexity: O(log n) insertion, extraction and O(n) construction --% Dequeue and Heap data types @@ -42933,8 +42964,8 @@ o )show HexadecimalExpansion ++ Examples: ++ References: ++ Description: -++ This domain allows rational numbers to be presented as repeating -++ hexadecimal expansions. +++ This domain allows rational numbers to be presented as repeating +++ hexadecimal expansions. HexadecimalExpansion(): Exports == Implementation where Exports ==> QuotientFieldCategory(Integer) with @@ -43048,7 +43079,7 @@ HexadecimalExpansion(): Exports == Implementation where <>= )abbrev domain HDP HomogeneousDirectProduct -++ Author: +++ Author: Mark Botch ++ Date Created: ++ Date Last Updated: ++ Basic Functions: @@ -43058,7 +43089,7 @@ HexadecimalExpansion(): Exports == Implementation where ++ Keywords: ++ References: ++ Description: -++ This type represents the finite direct or cartesian product of an +++ 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 @@ -43413,13 +43444,14 @@ o )show HomogeneousDistributedMultivariatePolynomial ++ Keywords: polynomial, multivariate, distributed ++ References: ++ Description: -++ This type supports distributed multivariate polynomials +++ 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. + HomogeneousDistributedMultivariatePolynomial(vl,R): public == private where vl : List Symbol R : Ring @@ -43475,17 +43507,16 @@ HomogeneousDistributedMultivariatePolynomial(vl,R): public == private where <>= )abbrev domain HELLFDIV HyperellipticFiniteDivisor -++ Finite rational divisors on an hyperelliptic curve ++ Author: Manuel Bronstein ++ Date Created: 19 May 1993 ++ Date Last Updated: 20 July 1998 +++ Keywords: divisor, algebraic, curve. ++ Description: ++ This domains implements finite rational divisors on an hyperelliptic curve, ++ that is finite formal sums SUM(n * P) where the n's are integers and the ++ P's are finite rational points on the curve. ++ The equation of the curve must be y^2 = f(x) and f must have odd degree. -++ Keywords: divisor, algebraic, curve. -++ Examples: )r FDIV INPUT + HyperellipticFiniteDivisor(F, UP, UPUP, R): Exports == Implementation where F : Field UP : UnivariatePolynomialCategory F @@ -43678,8 +43709,10 @@ HyperellipticFiniteDivisor(F, UP, UPUP, R): Exports == Implementation where <>= )abbrev domain ICARD IndexCard -++ This domain implements a container of information -++ about the AXIOM library +++ Author: Mark Botch +++ Description: +++ This domain implements a container of information about the AXIOM library + IndexCard() : Exports == Implementation where Exports == OrderedSet with elt: (%,Symbol) -> String @@ -43831,25 +43864,24 @@ IndexCard() : Exports == Implementation where <>= )abbrev domain IBITS IndexedBits ++ Author: Stephen Watt and Michael Monagan -++ Date Created: -++ July 86 -++ Change History: -++ Oct 87 +++ Date Created: July 86 +++ Change History: Oct 87 ++ Basic Operations: range ++ Related Constructors: ++ Keywords: indexed bits -++ Description: \spadtype{IndexedBits} is a domain to compactly represent +++ Description: +++ \spadtype{IndexedBits} is a domain to compactly represent ++ large quantities of Boolean data. IndexedBits(mn:Integer): BitAggregate() with -- temporaries until parser gets better Not: % -> % - ++ Not(n) returns the bit-by-bit logical {\em Not} of n. + ++ Not(n) returns the bit-by-bit logical Not of n. Or : (%, %) -> % - ++ Or(n,m) returns the bit-by-bit logical {\em Or} of + ++ Or(n,m) returns the bit-by-bit logical Or of ++ n and m. And: (%, %) -> % - ++ And(n,m) returns the bit-by-bit logical {\em And} of + ++ And(n,m) returns the bit-by-bit logical And of ++ n and m. == add @@ -43929,9 +43961,12 @@ IndexedBits(mn:Integer): BitAggregate() with <>= )abbrev domain IDPAG IndexedDirectProductAbelianGroup +++ Author: Mark Botch +++ Description: ++ Indexed direct products of abelian groups over an abelian group \spad{A} of ++ generators indexed by the ordered set S. ++ All items have finite support: only non-zero terms are stored. + IndexedDirectProductAbelianGroup(A:AbelianGroup,S:OrderedSet): Join(AbelianGroup,IndexedDirectProductCategory(A,S)) == IndexedDirectProductAbelianMonoid(A,S) add @@ -44033,9 +44068,12 @@ IndexedDirectProductAbelianGroup(A:AbelianGroup,S:OrderedSet): <>= )abbrev domain IDPAM IndexedDirectProductAbelianMonoid -++ Indexed direct products of abelian monoids over an abelian monoid \spad{A} of -++ generators indexed by the ordered set S. All items have finite support. -++ Only non-zero terms are stored. +++ Author: Mark Botch +++ Description: +++ Indexed direct products of abelian monoids over an abelian monoid +++ \spad{A} of generators indexed by the ordered set S. All items have +++ finite support. Only non-zero terms are stored. + IndexedDirectProductAbelianMonoid(A:AbelianMonoid,S:OrderedSet): Join(AbelianMonoid,IndexedDirectProductCategory(A,S)) == IndexedDirectProductObject(A,S) add @@ -44050,10 +44088,10 @@ IndexedDirectProductAbelianMonoid(A:AbelianMonoid,S:OrderedSet): 0 == [] zero? x == null x - -- PERFORMANCE CRITICAL; Should build list up - -- by merging 2 sorted lists. Doing this will - -- avoid the recursive calls (very useful if there is a - -- large number of vars in a polynomial. + -- PERFORMANCE CRITICAL; Should build list up + -- by merging 2 sorted lists. Doing this will + -- avoid the recursive calls (very useful if there is a + -- large number of vars in a polynomial. -- x + y == -- null x => y -- null y => x @@ -44066,36 +44104,36 @@ IndexedDirectProductAbelianMonoid(A:AbelianMonoid,S:OrderedSet): qsetrest!(l: Rep, e: Rep): Rep == RPLACD(l, e)$Lisp x + y == - null x => y - null y => x - endcell: Rep := empty() - res: Rep := empty() - while not empty? x and not empty? y repeat - newcell := empty() - if x.first.k = y.first.k then - r:= x.first.c + y.first.c - if not zero? r then - newcell := cons([x.first.k, r], empty()) - x := rest x - y := rest y - else if x.first.k > y.first.k then - newcell := cons(x.first, empty()) - x := rest x - else - newcell := cons(y.first, empty()) - y := rest y - if not empty? newcell then - if not empty? endcell then - qsetrest!(endcell, newcell) - endcell := newcell - else - res := newcell; - endcell := res - if empty? x then end := y - else end := x - if empty? res then res := end - else qsetrest!(endcell, end) - res + null x => y + null y => x + endcell: Rep := empty() + res: Rep := empty() + while not empty? x and not empty? y repeat + newcell := empty() + if x.first.k = y.first.k then + r:= x.first.c + y.first.c + if not zero? r then + newcell := cons([x.first.k, r], empty()) + x := rest x + y := rest y + else if x.first.k > y.first.k then + newcell := cons(x.first, empty()) + x := rest x + else + newcell := cons(y.first, empty()) + y := rest y + if not empty? newcell then + if not empty? endcell then + qsetrest!(endcell, newcell) + endcell := newcell + else + res := newcell; + endcell := res + if empty? x then end := y + else end := x + if empty? res then res := end + else qsetrest!(endcell, end) + res n * x == n = 0 => 0 @@ -44143,9 +44181,13 @@ IndexedDirectProductAbelianMonoid(A:AbelianMonoid,S:OrderedSet): <>= )abbrev domain IDPO IndexedDirectProductObject +++ Author: Mark Botch +++ Description: ++ Indexed direct products of objects over a set \spad{A} ++ of generators indexed by an ordered set S. All items have finite support. -IndexedDirectProductObject(A:SetCategory,S:OrderedSet): IndexedDirectProductCategory(A,S) + +IndexedDirectProductObject(A:SetCategory,S:OrderedSet): _ + IndexedDirectProductCategory(A,S) == add --representations Term:= Record(k:S,c:A) @@ -44226,10 +44268,13 @@ IndexedDirectProductObject(A:SetCategory,S:OrderedSet): IndexedDirectProductCate <>= )abbrev domain IDPOAM IndexedDirectProductOrderedAbelianMonoid +++ Author: Mark Botch +++ Description: ++ Indexed direct products of ordered abelian monoids \spad{A} of ++ generators indexed by the ordered set S. ++ The inherited order is lexicographical. ++ All items have finite support: only non-zero terms are stored. + IndexedDirectProductOrderedAbelianMonoid(A:OrderedAbelianMonoid,S:OrderedSet): Join(OrderedAbelianMonoid,IndexedDirectProductCategory(A,S)) == IndexedDirectProductAbelianMonoid(A,S) add @@ -44292,9 +44337,12 @@ IndexedDirectProductOrderedAbelianMonoid(A:OrderedAbelianMonoid,S:OrderedSet): <>= )abbrev domain IDPOAMS IndexedDirectProductOrderedAbelianMonoidSup +++ Author: Mark Botch +++ Description: ++ Indexed direct products of ordered abelian monoid sups \spad{A}, ++ generators indexed by the ordered set S. ++ All items have finite support: only non-zero terms are stored. + IndexedDirectProductOrderedAbelianMonoidSup(A:OrderedAbelianMonoidSup,S:OrderedSet): Join(OrderedAbelianMonoidSup,IndexedDirectProductCategory(A,S)) == IndexedDirectProductOrderedAbelianMonoid(A,S) add @@ -44383,7 +44431,7 @@ IndexedDirectProductOrderedAbelianMonoidSup(A:OrderedAbelianMonoidSup,S:OrderedS ++ Keywords: ++ References: ++ Description: -++ IndexedExponents of an ordered set of variables gives a representation +++ 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 @@ -44503,10 +44551,11 @@ IndexedExponents(Varset:OrderedSet): C == T where <>= )abbrev domain IFARRAY IndexedFlexibleArray ++ Author: Michael Monagan July/87, modified SMW June/91 +++ Description: ++ A FlexibleArray is the notion of an array intended to allow for growth -++ at the end only. Hence the following efficient operations -++ \spad{append(x,a)} meaning append item x at the end of the array \spad{a} -++ \spad{delete(a,n)} meaning delete the last item from the array \spad{a} +++ at the end only. Hence the following efficient operations\br +++ \spad{append(x,a)} meaning append item x at the end of the array \spad{a}\br +++ \spad{delete(a,n)} meaning delete the last item from the array \spad{a}\br ++ 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 @@ -44867,14 +44916,15 @@ IndexedFlexibleArray(S:Type, mn: Integer): Exports == Implementation where ++ AMS Classification: ++ Keywords: list, aggregate, index ++ Description: -++ \spadtype{IndexedList} is a basic implementation of the functions -++ in \spadtype{ListAggregate}, often using functions in the underlying -++ LISP system. The second parameter to the constructor (\spad{mn}) -++ is the beginning index of the list. That is, if \spad{l} is a -++ list, then \spad{elt(l,mn)} is the first value. This constructor -++ is probably best viewed as the implementation of singly-linked -++ lists that are addressable by index rather than as a mere wrapper -++ for LISP lists. +++ \spadtype{IndexedList} is a basic implementation of the functions +++ in \spadtype{ListAggregate}, often using functions in the underlying +++ LISP system. The second parameter to the constructor (\spad{mn}) +++ is the beginning index of the list. That is, if \spad{l} is a +++ list, then \spad{elt(l,mn)} is the first value. This constructor +++ is probably best viewed as the implementation of singly-linked +++ lists that are addressable by index rather than as a mere wrapper +++ for LISP lists. + IndexedList(S:Type, mn:Integer): Exports == Implementation where cycleMax ==> 1000 -- value used in checking for cycles @@ -45146,14 +45196,15 @@ IndexedList(S:Type, mn:Integer): Exports == Implementation where ++ Examples: ++ References: ++ Description: -++ 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. +++ 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. + IndexedMatrix(R,mnRow,mnCol): Exports == Implementation where R : Ring mnRow, mnCol : Integer @@ -45304,6 +45355,7 @@ IndexedMatrix(R,mnRow,mnCol): Exports == Implementation where <>= )abbrev domain IARRAY1 IndexedOneDimensionalArray ++ Author Micheal Monagan Aug/87 +++ Description: ++ This is the basic one dimensional array data type. IndexedOneDimensionalArray(S:Type, mn:Integer): @@ -45503,7 +45555,7 @@ IndexedString(mn:Integer): Export == Implementation where Export ==> StringAggregate() with hash: % -> I - ++ hash(x) provides a hashing function for strings + ++ hash(x) provides a hashing function for strings Implementation ==> add -- These assume Character's Rep is Small I @@ -45515,176 +45567,169 @@ IndexedString(mn:Integer): Export == Implementation where Chlt ==> QSLESSP$Lisp Chgt ==> QSGREATERP$Lisp - c: Character + c: Character cc: CharacterClass --- new n == MAKE_-FULL_-CVEC(n, space$C)$Lisp - new(n, c) == MAKE_-FULL_-CVEC(n, c)$Lisp - empty() == MAKE_-FULL_-CVEC(0$Lisp)$Lisp - empty?(s) == Qsize(s) = 0 - #s == Qsize(s) - s = t == Qequal(s, t) - s < t == CGREATERP(t,s)$Lisp - concat(s:%,t:%) == STRCONC(s,t)$Lisp - copy s == COPY_-SEQ(s)$Lisp +-- new n == MAKE_-FULL_-CVEC(n, space$C)$Lisp + new(n, c) == MAKE_-FULL_-CVEC(n, c)$Lisp + empty() == MAKE_-FULL_-CVEC(0$Lisp)$Lisp + empty?(s) == Qsize(s) = 0 + #s == Qsize(s) + s = t == Qequal(s, t) + s < t == CGREATERP(t,s)$Lisp + concat(s:%,t:%) == STRCONC(s,t)$Lisp + copy s == COPY_-SEQ(s)$Lisp insert(s:%, t:%, i:I) == concat(concat(s(mn..i-1), t), s(i..)) coerce(s:%):OutputForm == outputForm(s pretend String) - minIndex s == mn - upperCase_! s == map_!(upperCase, s) - lowerCase_! s == map_!(lowerCase, s) + minIndex s == mn + upperCase_! s == map_!(upperCase, s) + lowerCase_! s == map_!(lowerCase, s) - latex s == concat("\mbox{``", concat(s pretend String, "''}")) + latex s == concat("\mbox{``", concat(s pretend String, "''}")) replace(s, sg, t) == - l := lo(sg) - mn - m := #s - n := #t - h:I := if hasHi sg then hi(sg) - mn else maxIndex s - mn - l < 0 or h >= m or h < l-1 => error "index out of range" - r := new((m-(h-l+1)+n)::N, space$C) - for k in 0.. for i in 0..l-1 repeat Qsetelt(r, k, Qelt(s, i)) - for k in k.. for i in 0..n-1 repeat Qsetelt(r, k, Qelt(t, i)) - for k in k.. for i in h+1..m-1 repeat Qsetelt(r, k, Qelt(s, i)) - r + l := lo(sg) - mn + m := #s + n := #t + h:I := if hasHi sg then hi(sg) - mn else maxIndex s - mn + l < 0 or h >= m or h < l-1 => error "index out of range" + r := new((m-(h-l+1)+n)::N, space$C) + for k in 0.. for i in 0..l-1 repeat Qsetelt(r, k, Qelt(s, i)) + for k in k.. for i in 0..n-1 repeat Qsetelt(r, k, Qelt(t, i)) + for k in k.. for i in h+1..m-1 repeat Qsetelt(r, k, Qelt(s, i)) + r setelt(s:%, i:I, c:C) == - i < mn or i > maxIndex(s) => error "index out of range" - Qsetelt(s, i - mn, c) - c + i < mn or i > maxIndex(s) => error "index out of range" + Qsetelt(s, i - mn, c) + c substring?(part, whole, startpos) == - np:I := Qsize part - nw:I := Qsize whole - (startpos := startpos - mn) < 0 => error "index out of bounds" - np > nw - startpos => false - for ip in 0..np-1 for iw in startpos.. repeat - not Cheq(Qelt(part, ip), Qelt(whole, iw)) => return false - true + np:I := Qsize part + nw:I := Qsize whole + (startpos := startpos - mn) < 0 => error "index out of bounds" + np > nw - startpos => false + for ip in 0..np-1 for iw in startpos.. repeat + not Cheq(Qelt(part, ip), Qelt(whole, iw)) => return false + true position(s:%, t:%, startpos:I) == - (startpos := startpos - mn) < 0 => error "index out of bounds" - startpos >= Qsize t => mn - 1 - r:I := STRPOS(s, t, startpos, NIL$Lisp)$Lisp - EQ(r, NIL$Lisp)$Lisp => mn - 1 - r + mn + (startpos := startpos - mn) < 0 => error "index out of bounds" + startpos >= Qsize t => mn - 1 + r:I := STRPOS(s, t, startpos, NIL$Lisp)$Lisp + EQ(r, NIL$Lisp)$Lisp => mn - 1 + r + mn + position(c: Character, t: %, startpos: I) == - (startpos := startpos - mn) < 0 => error "index out of bounds" - startpos >= Qsize t => mn - 1 - for r in startpos..Qsize t - 1 repeat - if Cheq(Qelt(t, r), c) then return r + mn - mn - 1 + (startpos := startpos - mn) < 0 => error "index out of bounds" + startpos >= Qsize t => mn - 1 + for r in startpos..Qsize t - 1 repeat + if Cheq(Qelt(t, r), c) then return r + mn + mn - 1 + position(cc: CharacterClass, t: %, startpos: I) == - (startpos := startpos - mn) < 0 => error "index out of bounds" - startpos >= Qsize t => mn - 1 - for r in startpos..Qsize t - 1 repeat - if member?(Qelt(t,r), cc) then return r + mn - mn - 1 + (startpos := startpos - mn) < 0 => error "index out of bounds" + startpos >= Qsize t => mn - 1 + for r in startpos..Qsize t - 1 repeat + if member?(Qelt(t,r), cc) then return r + mn + mn - 1 suffix?(s, t) == - (m := maxIndex s) > (n := maxIndex t) => false - substring?(s, t, mn + n - m) + (m := maxIndex s) > (n := maxIndex t) => false + substring?(s, t, mn + n - m) split(s, c) == - n := maxIndex s - for i in mn..n while s.i = c repeat 0 - l := empty()$List(%) - j:Integer -- j is conditionally intialized - while i <= n and (j := position(c, s, i)) >= mn repeat - l := concat(s(i..j-1), l) - for i in j..n while s.i = c repeat 0 - if i <= n then l := concat(s(i..n), l) - reverse_! l + n := maxIndex s + for i in mn..n while s.i = c repeat 0 + l := empty()$List(%) + j:Integer -- j is conditionally intialized + while i <= n and (j := position(c, s, i)) >= mn repeat + l := concat(s(i..j-1), l) + for i in j..n while s.i = c repeat 0 + if i <= n then l := concat(s(i..n), l) + reverse_! l + split(s, cc) == - n := maxIndex s - for i in mn..n while member?(s.i,cc) repeat 0 - l := empty()$List(%) - j:Integer -- j is conditionally intialized - while i <= n and (j := position(cc, s, i)) >= mn repeat - l := concat(s(i..j-1), l) - for i in j..n while member?(s.i,cc) repeat 0 - if i <= n then l := concat(s(i..n), l) - reverse_! l + n := maxIndex s + for i in mn..n while member?(s.i,cc) repeat 0 + l := empty()$List(%) + j:Integer -- j is conditionally intialized + while i <= n and (j := position(cc, s, i)) >= mn repeat + l := concat(s(i..j-1), l) + for i in j..n while member?(s.i,cc) repeat 0 + if i <= n then l := concat(s(i..n), l) + reverse_! l leftTrim(s, c) == - n := maxIndex s - for i in mn .. n while s.i = c repeat 0 - s(i..n) + n := maxIndex s + for i in mn .. n while s.i = c repeat 0 + s(i..n) + leftTrim(s, cc) == - n := maxIndex s - for i in mn .. n while member?(s.i,cc) repeat 0 - s(i..n) + n := maxIndex s + for i in mn .. n while member?(s.i,cc) repeat 0 + s(i..n) rightTrim(s, c) == - for j in maxIndex s .. mn by -1 while s.j = c repeat 0 - s(minIndex(s)..j) + for j in maxIndex s .. mn by -1 while s.j = c repeat 0 + s(minIndex(s)..j) + rightTrim(s, cc) == - for j in maxIndex s .. mn by -1 while member?(s.j, cc) repeat 0 - s(minIndex(s)..j) + for j in maxIndex s .. mn by -1 while member?(s.j, cc) repeat 0 + s(minIndex(s)..j) concat l == - t := new(+/[#s for s in l], space$C) - i := mn - for s in l repeat - copyInto_!(t, s, i) - i := i + #s - t + t := new(+/[#s for s in l], space$C) + i := mn + for s in l repeat + copyInto_!(t, s, i) + i := i + #s + t copyInto_!(y, x, s) == - m := #x - n := #y - s := s - mn - s < 0 or s+m > n => error "index out of range" - RPLACSTR(y, s, m, x, 0, m)$Lisp - y + m := #x + n := #y + s := s - mn + s < 0 or s+m > n => error "index out of range" + RPLACSTR(y, s, m, x, 0, m)$Lisp + y elt(s:%, i:I) == - i < mn or i > maxIndex(s) => error "index out of range" - Qelt(s, i - mn) + i < mn or i > maxIndex(s) => error "index out of range" + Qelt(s, i - mn) elt(s:%, sg:U) == - l := lo(sg) - mn - h := if hasHi sg then hi(sg) - mn else maxIndex s - mn - l < 0 or h >= #s => error "index out of bound" - SUBSTRING(s, l, max(0, h-l+1))$Lisp + l := lo(sg) - mn + h := if hasHi sg then hi(sg) - mn else maxIndex s - mn + l < 0 or h >= #s => error "index out of bound" + SUBSTRING(s, l, max(0, h-l+1))$Lisp hash(s:$):Integer == - n:I := Qsize s - zero? n => 0 --- one? n => ord(s.mn) - (n = 1) => ord(s.mn) - ord(s.mn) * ord s(mn+n-1) * ord s(mn + n quo 2) + n:I := Qsize s + zero? n => 0 +-- one? n => ord(s.mn) + (n = 1) => ord(s.mn) + ord(s.mn) * ord s(mn+n-1) * ord s(mn + n quo 2) - match(pattern,target,wildcard) == stringMatch(pattern,target,CHARACTER(wildcard)$Lisp)$Lisp + match(pattern,target,wildcard) == + stringMatch(pattern,target,CHARACTER(wildcard)$Lisp)$Lisp -@ - -Up to [[patch--40]] this read - -\begin{verbatim} - match(pattern,target,wildcard) == stringMatch(pattern,target,wildcard)$Lisp -\end{verbatim} - -which did not work (Issue~\#97), since [[wildcard]] is an Axiom-[[Character]], -not a Lisp-[[Character]]. The operation [[CHARACTER]] from [[Lisp]] performs -the coercion. - -<>= match?(pattern, target, dontcare) == - n := maxIndex pattern - p := position(dontcare, pattern, m := minIndex pattern)::N - p = m-1 => pattern = target - (p ^= m) and not prefix?(pattern(m..p-1), target) => false - i := p -- index into target - q := position(dontcare, pattern, p + 1)::N - while q ^= m-1 repeat - s := pattern(p+1..q-1) - i := position(s, target, i)::N - i = m-1 => return false - i := i + #s - p := q - q := position(dontcare, pattern, q + 1)::N - (p ^= n) and not suffix?(pattern(p+1..n), target) => false - true + n := maxIndex pattern + p := position(dontcare, pattern, m := minIndex pattern)::N + p = m-1 => pattern = target + (p ^= m) and not prefix?(pattern(m..p-1), target) => false + i := p -- index into target + q := position(dontcare, pattern, p + 1)::N + while q ^= m-1 repeat + s := pattern(p+1..q-1) + i := position(s, target, i)::N + i = m-1 => return false + i := i + #s + p := q + q := position(dontcare, pattern, q + 1)::N + (p ^= n) and not suffix?(pattern(p+1..n), target) => false + true @ <>= @@ -45757,6 +45802,10 @@ first column in an array and vice versa. <>= )abbrev domain IARRAY2 IndexedTwoDimensionalArray +++ Author: Mark Botch +++ Description: +++ This domain implements two dimensional arrays + IndexedTwoDimensionalArray(R,mnRow,mnCol):Exports == Implementation where R : Type mnRow, mnCol : Integer @@ -45859,7 +45908,7 @@ IndexedTwoDimensionalArray(R,mnRow,mnCol):Exports == Implementation where <>= )abbrev domain IVECTOR IndexedVector -++ Author: +++ Author: Mark Botch ++ Date Created: ++ Date Last Updated: ++ Basic Functions: @@ -45869,7 +45918,7 @@ IndexedTwoDimensionalArray(R,mnRow,mnCol):Exports == Implementation where ++ Keywords: ++ References: ++ Description: -++ This type represents vector like objects with varying lengths +++ This type represents vector like objects with varying lengths ++ and a user-specified initial index. IndexedVector(R:Type, mn:Integer): @@ -45900,16 +45949,17 @@ IndexedVector(R:Type, mn:Integer): <>= )abbrev domain ITUPLE InfiniteTuple -++ Infinite tuples for the interpreter ++ Author: Clifton J. Williamson ++ Date Created: 16 February 1990 ++ Date Last Updated: 16 February 1990 ++ Keywords: ++ Examples: ++ References: +++ Description: +++ This package implements 'infinite tuples' for the interpreter. +++ The representation is a stream. + InfiniteTuple(S:Type): Exports == Implementation where - ++ This package implements 'infinite tuples' for the interpreter. - ++ The representation is a stream. Exports ==> CoercibleTo OutputForm with map: (S -> S, %) -> % @@ -46043,12 +46093,13 @@ InfiniteTuple(S:Type): Exports == Implementation where <>= )abbrev domain IAN InnerAlgebraicNumber -++ Algebraic closure of the rational numbers ++ Author: Manuel Bronstein ++ Date Created: 22 March 1988 ++ Date Last Updated: 4 October 1995 (JHD) -++ Description: Algebraic closure of the rational numbers. ++ Keywords: algebraic, number. +++ Description: +++ Algebraic closure of the rational numbers. + InnerAlgebraicNumber(): Exports == Implementation where Z ==> Integer FE ==> Expression Z @@ -46098,9 +46149,9 @@ InnerAlgebraicNumber(): Exports == Implementation where -- mv:= mainVariable denom f -- mv case "failed" => f -- algv:=mv::K --- q:=univariate(f, algv, minPoly(algv))_ +-- q:=univariate(f, algv, minPoly(algv))_ -- $PolynomialCategoryQuotientFunctions(IndexedExponents K,K,Integer,P,%) --- q(algv::%) +-- q(algv::%) findDenominator(z:SUP %):Record(num:SUP %,den:%) == zz:=z @@ -46292,7 +46343,7 @@ InnerAlgebraicNumber(): Exports == Implementation where <>= )abbrev domain IFF InnerFiniteField -++ Author: ??? +++ Author: Mark Botch ++ Date Created: ??? ++ Date Last Updated: 29 May 1990 ++ Basic Operations: @@ -46308,9 +46359,10 @@ InnerAlgebraicNumber(): Exports == Implementation where ++ J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM. ++ AXIOM Technical Report Series, ATR/5 NP2522. ++ Description: -++ InnerFiniteField(p,n) implements finite fields with \spad{p**n} elements -++ where p is assumed prime but does not check. -++ For a version which checks that p is prime, see \spadtype{FiniteField}. +++ InnerFiniteField(p,n) implements finite fields with \spad{p**n} elements +++ where p is assumed prime but does not check. +++ For a version which checks that p is prime, see \spadtype{FiniteField}. + InnerFiniteField(p:PositiveInteger, n:PositiveInteger) == FiniteFieldExtension(InnerPrimeField p, n) @@ -46359,12 +46411,12 @@ InnerFiniteField(p:PositiveInteger, n:PositiveInteger) == <>= )abbrev domain IFAMON InnerFreeAbelianMonoid -++ Internal free abelian monoid on any set of generators ++ Author: Manuel Bronstein ++ Date Created: November 1989 ++ Date Last Updated: 6 June 1991 ++ Description: -++ Internal implementation of a free abelian monoid. +++ Internal implementation of a free abelian monoid on any set of generators + InnerFreeAbelianMonoid(S: SetCategory, E:CancellationAbelianMonoid, un:E): FreeAbelianMonoidCategory(S, E) == ListMonoidOps(S, E, un) add Rep := ListMonoidOps(S, E, un) @@ -46455,6 +46507,10 @@ This is an internal type which provides an implementation of <>= )abbrev domain IIARRAY2 InnerIndexedTwoDimensionalArray +++ Author: Mark Botch +++ Description: +++ There is no description for this domain + InnerIndexedTwoDimensionalArray(R,mnRow,mnCol,Row,Col):_ Exports == Implementation where R : Type @@ -46618,8 +46674,9 @@ InnerIndexedTwoDimensionalArray(R,mnRow,mnCol,Row,Col):_ ++ Examples: ++ References: ++ Description: -++ This domain implements Zp, the p-adic completion of the integers. -++ This is an internal domain. +++ This domain implements Zp, the p-adic completion of the integers. +++ This is an internal domain. + InnerPAdicInteger(p,unBalanced?): Exports == Implementation where p : Integer unBalanced? : Boolean @@ -46961,8 +47018,6 @@ InnerPAdicInteger(p,unBalanced?): Exports == Implementation where <>= )abbrev domain IPF InnerPrimeField --- Argument MUST be a prime. --- This domain does not check, PrimeField does. ++ Authors: N.N., J.Grabmeier, A.Scheerhorn ++ Date Created: ?, November 1990, 26.03.1991 ++ Date Last Updated: 12 April 1991 @@ -46976,10 +47031,9 @@ InnerPAdicInteger(p,unBalanced?): Exports == Implementation where ++ Its Applications, Vol. 20, Cambridge Univ. Press, 1983, ISBN 0 521 30240 4 ++ AXIOM Technical Report Series, to appear. ++ Description: -++ InnerPrimeField(p) implements the field with p elements. -++ Note: argument p MUST be a prime (this domain does not check). -++ See \spadtype{PrimeField} for a domain that does check. - +++ InnerPrimeField(p) implements the field with p elements. +++ Note: argument p MUST be a prime (this domain does not check). +++ See \spadtype{PrimeField} for a domain that does check. InnerPrimeField(p:PositiveInteger): Exports == Implementation where @@ -47258,8 +47312,10 @@ InnerPrimeField(p:PositiveInteger): Exports == Implementation where ++ Keywords: sparse, series ++ Examples: ++ References: -++ Description: InnerSparseUnivariatePowerSeries is an internal domain -++ used for creating sparse Taylor and Laurent series. +++ Description: +++ InnerSparseUnivariatePowerSeries is an internal domain +++ used for creating sparse Taylor and Laurent series. + InnerSparseUnivariatePowerSeries(Coef): Exports == Implementation where Coef : Ring B ==> Boolean @@ -48400,8 +48456,8 @@ InnerSparseUnivariatePowerSeries(Coef): Exports == Implementation where ++ Examples: ++ References: ++ Description: -++ This domain is used to provide a conditional "add" domain -++ for the implementation of \spadtype{Table}. +++ This domain is used to provide a conditional "add" domain +++ for the implementation of \spadtype{Table}. InnerTable(Key: SetCategory, Entry: SetCategory, addDom):Exports == Implementation where addDom : TableAggregate(Key, Entry) with @@ -48469,7 +48525,8 @@ InnerTable(Key: SetCategory, Entry: SetCategory, addDom):Exports == Implementati ++ Keywords: stream, dense Taylor series ++ Examples: ++ References: -++ Description: Internal package for dense Taylor series. +++ Description: +++ 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 @@ -48650,14 +48707,13 @@ InnerTaylorSeries(Coef): Exports == Implementation where <>= )abbrev domain INFORM InputForm -++ Parser forms ++ Author: Manuel Bronstein ++ Date Created: ??? ++ Date Last Updated: 19 April 1991 ++ Description: -++ Domain of parsed forms which can be passed to the interpreter. -++ This is also the interface between algebra code and facilities -++ in the interpreter. +++ Domain of parsed forms which can be passed to the interpreter. +++ This is also the interface between algebra code and facilities +++ in the interpreter. --)boot $noSubsumption := true @@ -49606,14 +49662,14 @@ o )show Integer <>= )abbrev domain INT Integer -++ Author: +++ Author: Mark Botch ++ Date Created: ++ Change History: ++ Basic Operations: ++ Related Constructors: ++ Keywords: integer -++ Description: \spadtype{Integer} provides the domain of arbitrary precision -++ integers. +++ Description: +++ \spadtype{Integer} provides the domain of arbitrary precision integers. Integer: Join(IntegerNumberSystem, ConvertibleTo String, OpenMath) with random : % -> % @@ -49829,7 +49885,7 @@ Integer: Join(IntegerNumberSystem, ConvertibleTo String, OpenMath) with <>= )abbrev domain ZMOD IntegerMod -++ Author: +++ Author: Mark Botch ++ Date Created: ++ Date Last Updated: ++ Basic Functions: @@ -49839,8 +49895,7 @@ Integer: Join(IntegerNumberSystem, ConvertibleTo String, OpenMath) with ++ Keywords: ++ References: ++ Description: -++ IntegerMod(n) creates the ring of integers reduced modulo the integer -++ n. +++ IntegerMod(n) creates the ring of integers reduced modulo the integer n. IntegerMod(p:PositiveInteger): Join(CommutativeRing, Finite, ConvertibleTo Integer, StepThrough) == add @@ -49944,46 +49999,47 @@ IntegerMod(p:PositiveInteger): ++ Date Created: March 1995 ++ Date Last Updated: June 1995 ++ Description: -++ +++ There is no description for this domain + IntegrationFunctionsTable(): E == I where - EF2 ==> ExpressionFunctions2 - EFI ==> Expression Fraction Integer - FI ==> Fraction Integer - LEDF ==> List Expression DoubleFloat - KEDF ==> Kernel Expression DoubleFloat - EEDF ==> Equation Expression DoubleFloat - EDF ==> Expression DoubleFloat - PDF ==> Polynomial DoubleFloat - LDF ==> List DoubleFloat - SDF ==> Stream DoubleFloat - DF ==> DoubleFloat - F ==> Float - ST ==> String - LST ==> List String - SI ==> SingleInteger - SOCDF ==> Segment OrderedCompletion DoubleFloat - OCDF ==> OrderedCompletion DoubleFloat - OCEDF ==> OrderedCompletion Expression DoubleFloat + EF2 ==> ExpressionFunctions2 + EFI ==> Expression Fraction Integer + FI ==> Fraction Integer + LEDF ==> List Expression DoubleFloat + KEDF ==> Kernel Expression DoubleFloat + EEDF ==> Equation Expression DoubleFloat + EDF ==> Expression DoubleFloat + PDF ==> Polynomial DoubleFloat + LDF ==> List DoubleFloat + SDF ==> Stream DoubleFloat + DF ==> DoubleFloat + F ==> Float + ST ==> String + LST ==> List String + SI ==> SingleInteger + SOCDF ==> Segment OrderedCompletion DoubleFloat + OCDF ==> OrderedCompletion DoubleFloat + OCEDF ==> OrderedCompletion Expression DoubleFloat EOCEFI ==> Equation OrderedCompletion Expression Fraction Integer OCEFI ==> OrderedCompletion Expression Fraction Integer OCFI ==> OrderedCompletion Fraction Integer - NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) - INT ==> Integer - CTYPE ==> Union(continuous: "Continuous at the end points", + NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) + INT ==> Integer + CTYPE ==> Union(continuous: "Continuous at the end points", lowerSingular: "There is a singularity at the lower end point", upperSingular: "There is a singularity at the upper end point", bothSingular: "There are singularities at both end points", notEvaluated: "End point continuity not yet evaluated") - RTYPE ==> Union(finite: "The range is finite", + RTYPE ==> Union(finite: "The range is finite", lowerInfinite: "The bottom of range is infinite", upperInfinite: "The top of range is infinite", bothInfinite: "Both top and bottom points are infinite", notEvaluated: "Range not yet evaluated") - STYPE ==> Union(str:SDF, + STYPE ==> Union(str:SDF, notEvaluated:"Internal singularities not yet evaluated") - ATT ==> Record(endPointContinuity:CTYPE, + ATT ==> Record(endPointContinuity:CTYPE, singularitiesStream:STYPE,range:RTYPE) - ROA ==> Record(key:NIA,entry:ATT) + ROA ==> Record(key:NIA,entry:ATT) E ==> with @@ -49998,11 +50054,11 @@ IntegrationFunctionsTable(): E == I where insert!:Record(key:NIA,entry:ATT) -> $ ++ insert!(r) inserts an entry r into theIFTable showAttributes:NIA -> Union(ATT,"failed") - ++ showAttributes(x) \undocumented{} + ++ showAttributes(x) is not documented entries : $ -> List Record(key:NIA,entry:ATT) - ++ entries(x) \undocumented{} + ++ entries(x) is not documented entry:NIA -> ATT - ++ entry(n) \undocumented{} + ++ entry(n) is not documented I ==> add Rep := Table(NIA,ATT) @@ -50075,11 +50131,12 @@ IntegrationFunctionsTable(): E == I where <>= )abbrev domain IR IntegrationResult -++ The result of a transcendental integration. ++ Author: Barry Trager, Manuel Bronstein ++ Date Created: 1987 ++ Date Last Updated: 12 August 1992 +++ Keywords: integration. ++ Description: +++ The result of a transcendental integration. ++ If a function f has an elementary integral g, then g can be written ++ in the form \spad{g = h + c1 log(u1) + c2 log(u2) + ... + cn log(un)} ++ where h, which is in the same field than f, is called the rational @@ -50087,8 +50144,7 @@ IntegrationFunctionsTable(): E == I where ++ logarithmic part of the integral. This domain manipulates integrals ++ represented in that form, by keeping both parts separately. The logs ++ are not explicitly computed. -++ Keywords: integration. -++ Examples: )r RATINT INPUT + IntegrationResult(F:Field): Exports == Implementation where O ==> OutputForm B ==> Boolean @@ -50335,18 +50391,19 @@ IntegrationResult(F:Field): Exports == Implementation where <>= )abbrev domain INTRVL Interval -+++ Author: Mike Dewar -+++ Date Created: November 1996 -+++ Date Last Updated: -+++ Basic Functions: -+++ Related Constructors: -+++ Also See: -+++ AMS Classifications: -+++ Keywords: -+++ References: -+++ Description: -+++ This domain is an implementation of interval arithmetic and transcendental -+++ functions over intervals. +++ Author: Mike Dewar +++ Date Created: November 1996 +++ Date Last Updated: +++ Basic Functions: +++ Related Constructors: +++ Also See: +++ AMS Classifications: +++ Keywords: +++ References: +++ Description: +++ This domain is an implementation of interval arithmetic and transcendental +++ functions over intervals. + Interval(R:Join(FloatingPointSystem,TranscendentalFunctionCategory)): IntervalCategory(R) == add import Integer @@ -50465,8 +50522,8 @@ Interval(R:Join(FloatingPointSystem,TranscendentalFunctionCategory)): IntervalCa _~_= (a:%,b:%):Boolean == (inf(a)~=inf(b)) or (sup(a)~=sup(b)) 1 == - one : R := normaliseFloat 1 - [one,one] + one : R := normaliseFloat 1 + [one,one] 0 == [0,0] @@ -51128,13 +51185,13 @@ o )show Kernel <>= )abbrev domain KERNEL Kernel -++ Operators applied to elements of a set ++ Author: Manuel Bronstein ++ Date Created: 22 March 1988 ++ Date Last Updated: 10 August 1994 ++ Description: ++ A kernel over a set S is an operator applied to a given list ++ of arguments from S. + Kernel(S:OrderedSet): Exports == Implementation where O ==> OutputForm N ==> NonNegativeInteger @@ -51681,8 +51738,8 @@ o )show KeyedAccessFile ++ Examples: ++ References: ++ Description: -++ This domain allows a random access file to be viewed both as a table -++ and as a file object. +++ This domain allows a random access file to be viewed both as a table +++ and as a file object. KeyedAccessFile(Entry): KAFcategory == KAFcapsule where Name ==> FileName @@ -51867,10 +51924,12 @@ KeyedAccessFile(Entry): KAFcategory == KAFcapsule where <>= )abbrev domain LAUPOL LaurentPolynomial -++ Univariate polynomials with negative and positive exponents. ++ Author: Manuel Bronstein ++ Date Created: May 1988 ++ Date Last Updated: 26 Apr 1990 +++ Description: +++ Univariate polynomials with negative and positive exponents. + LaurentPolynomial(R, UP): Exports == Implementation where R : IntegralDomain UP: UnivariatePolynomialCategory R @@ -51884,27 +51943,27 @@ LaurentPolynomial(R, UP): Exports == Implementation where Exports ==> Join(DifferentialExtension UP, IntegralDomain, ConvertibleTo RF, FullyRetractableTo R, RetractableTo UP) with monomial? : % -> B - ++ monomial?(x) \undocumented + ++ monomial?(x) is not documented degree : % -> Z - ++ degree(x) \undocumented + ++ degree(x) is not documented order : % -> Z - ++ order(x) \undocumented + ++ order(x) is not documented reductum : % -> % - ++ reductum(x) \undocumented + ++ reductum(x) is not documented leadingCoefficient : % -> R - ++ leadingCoefficient \undocumented + ++ leadingCoefficient is not documented trailingCoefficient: % -> R - ++ trailingCoefficient \undocumented + ++ trailingCoefficient is not documented coefficient : (%, Z) -> R - ++ coefficient(x,n) \undocumented + ++ coefficient(x,n) is not documented monomial : (R, Z) -> % - ++ monomial(x,n) \undocumented + ++ monomial(x,n) is not documented if R has CharacteristicZero then CharacteristicZero if R has CharacteristicNonZero then CharacteristicNonZero if R has Field then EuclideanDomain separate: RF -> Record(polyPart:%, fracPart:RF) - ++ separate(x) \undocumented + ++ separate(x) is not documented Implementation ==> add Rep := Record(polypart: UP, order0: Z) @@ -52273,7 +52332,8 @@ o )show Library ++ Examples: ++ References: ++ Description: -++ This domain provides a simple way to save values in files. +++ This domain provides a simple way to save values in files. + Library(): TableAggregate(String, Any) with library: FileName -> % ++ library(ln) creates a new library file. @@ -52572,12 +52632,10 @@ o )show LieExponentials ++ Description: ++ Management of the Lie Group associated with a ++ free nilpotent Lie algebra. Every Lie bracket with -++ length greater than \axiom{Order} are -++ assumed to be null. +++ length greater than \axiom{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.fr). +++ domain constructor: Lyndon coordinates are exponential coordinates +++ of the second kind. LieExponentials(VarSet, R, Order): XDPcat == XDPdef where @@ -53159,11 +53217,12 @@ o )show LiePolynomial ++ Also See: ++ AMS Classifications: ++ Keywords: -++ References:Free Lie Algebras by C. Reutenauer (Oxford science publications). +++ References: +++ Free Lie Algebras by C. Reutenauer (Oxford science publications). ++ Description: ++ This type supports Lie polynomials in Lyndon basis ++ see Free Lie Algebras by C. Reutenauer -++ (Oxford science publications). \newline Author: Michel Petitot (petitot@lifl.fr). +++ (Oxford science publications). LiePolynomial(VarSet:OrderedSet, R:CommutativeRing) : Public == Private where MAGMA ==> Magma(VarSet) @@ -53499,11 +53558,12 @@ LiePolynomial(VarSet:OrderedSet, R:CommutativeRing) : Public == Private where ++ Keywords: ++ References: ++ Description: -++ LieSquareMatrix(n,R) implements the Lie algebra of the n by n -++ matrices over the commutative ring 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(n,R)} is the usual matrix multiplication. +++ LieSquareMatrix(n,R) implements the Lie algebra of the n by n +++ matrices over the commutative ring R. +++ The Lie bracket (commutator) of the algebra is given by\br +++ \spad{a*b := (a *$SQMATRIX(n,R) b - b *$SQMATRIX(n,R) a)},\br +++ where \spadfun{*$SQMATRIX(n,R)} is the usual matrix multiplication. + LieSquareMatrix(n,R): Exports == Implementation where n : PositiveInteger @@ -54141,11 +54201,12 @@ o )show LinearOrdinaryDifferentialOperator ++ Date Last Updated: 15 April 1994 ++ Keywords: differential operator ++ Description: -++ \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: -++ \spad{(L1 * L2).(f) = L1 L2 f} +++ \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:\br +++ \spad{(L1 * L2).(f) = L1 L2 f} + LinearOrdinaryDifferentialOperator(A:Ring, diff: A -> A): LinearOrdinaryDifferentialOperatorCategory A == SparseUnivariateSkewPolynomial(A, 1, diff) add @@ -54636,10 +54697,11 @@ o )show LinearOrdinaryDifferentialOperator1 ++ Date Last Updated: 31 January 1994 ++ Keywords: differential operator ++ Description: -++ \spad{LinearOrdinaryDifferentialOperator1} defines a ring of -++ differential operators with coefficients in a differential ring A. -++ Multiplication of operators corresponds to functional composition: -++ \spad{(L1 * L2).(f) = L1 L2 f} +++ \spad{LinearOrdinaryDifferentialOperator1} defines a ring of +++ differential operators with coefficients in a differential ring A. +++ Multiplication of operators corresponds to functional composition:\br +++ \spad{(L1 * L2).(f) = L1 L2 f} + LinearOrdinaryDifferentialOperator1(A:DifferentialRing) == LinearOrdinaryDifferentialOperator(A, differentiate$A) @@ -55245,16 +55307,17 @@ o )show LinearOrdinaryDifferentialOperator2 ++ Date Last Updated: 1 February 1994 ++ Keywords: differential operator ++ Description: -++ \spad{LinearOrdinaryDifferentialOperator2} defines a ring of -++ differential operators with coefficients in a differential ring A -++ and acting on an A-module M. -++ Multiplication of operators corresponds to functional composition: -++ \spad{(L1 * L2).(f) = L1 L2 f} +++ \spad{LinearOrdinaryDifferentialOperator2} defines a ring of +++ differential operators with coefficients in a differential ring A +++ and acting on an A-module M. +++ Multiplication of operators corresponds to functional composition:\br +++ \spad{(L1 * L2).(f) = L1 L2 f} + LinearOrdinaryDifferentialOperator2(A, M): Exports == Implementation where A: DifferentialRing M: LeftModule A with - differentiate: $ -> $ - ++ differentiate(x) returns the derivative of x + differentiate: $ -> $ + ++ differentiate(x) returns the derivative of x Exports ==> Join(LinearOrdinaryDifferentialOperatorCategory A, Eltable(M, M)) @@ -55954,22 +56017,17 @@ o )show List ++ Author: Michael Monagan ++ Date Created: Sep 1987 ++ Change History: -++ Basic Operations: -++ \#, append, concat, concat!, cons, construct, copy, elt, elt, -++ empty, empty?, eq?, first, member?, merge!, mergeSort, minIndex, -++ nil, null, parts, removeDuplicates!, rest, rest, reverse, -++ reverse!, setDifference, setIntersection, setUnion, setelt, -++ setfirst!, setrest!, sort!, split! ++ Related Constructors: ListFunctions2, ListFunctions3, ListToMap ++ Also See: IndexList, ListAggregate ++ AMS Classification: ++ Keywords: list, index, aggregate, lisp ++ Description: -++ \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{IndexedList}, this constructor provides some -++ LISP-like functions such as \spadfun{null} and \spadfun{cons}. +++ \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{IndexedList}, this constructor provides some +++ LISP-like functions such as \spadfun{null} and \spadfun{cons}. + List(S:Type): Exports == Implementation where LISTMININDEX ==> 1 -- this is the minimum list index @@ -56131,7 +56189,6 @@ List(S:Type): Exports == Implementation where <>= )abbrev domain LMOPS ListMonoidOps -++ Internal representation for monoids ++ Author: Manuel Bronstein ++ Date Created: November 1989 ++ Date Last Updated: 6 June 1991 @@ -56139,6 +56196,7 @@ List(S:Type): Exports == Implementation where ++ 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. + ListMonoidOps(S, E, un): Exports == Implementation where S : SetCategory E : AbelianMonoid @@ -56344,7 +56402,7 @@ ListMonoidOps(S, E, un): Exports == Implementation where <>= )abbrev domain LMDICT ListMultiDictionary -++ Author: MBM Nov/87, MB Oct/89 +++ Author: Mark Botch ++ Date Created: ++ Date Last Updated: 13 June 1994 Frederic Lehobey ++ Basic Operations: @@ -56353,28 +56411,27 @@ ListMonoidOps(S, E, un): Exports == Implementation where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: The \spadtype{ListMultiDictionary} domain implements a +++ Description: +++ 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. --- The operations \spadfun{pick}, \spadfun{count} and \spadfun{delete} can be used to iterate --- over the objects in the dictionary. --- [FDLL : those functions have not been implemented in the parent Categories] -++ If the objects in the -++ dictionary belong to an ordered set, the entries are maintained in -++ ascending order. +++ If the objects in the dictionary belong to an ordered set, +++ the entries are maintained in ascending order. + +ListMultiDictionary(S:SetCategory): EE == II where -NNI ==> NonNegativeInteger -D ==> Record(entry:S, count:NonNegativeInteger) + NNI ==> NonNegativeInteger + D ==> Record(entry:S, count:NonNegativeInteger) -ListMultiDictionary(S:SetCategory): MultiDictionary(S) with + EE ==> MultiDictionary(S) with finiteAggregate duplicates?: % -> Boolean ++ duplicates?(d) tests if dictionary d has duplicate entries. substitute : (S, S, %) -> % ++ substitute(x,y,d) replace x's with y's in dictionary d. - == add + II ==> add Rep := Reference List S sub: (S, S, S) -> S @@ -56548,8 +56605,10 @@ ListMultiDictionary(S:SetCategory): MultiDictionary(S) with ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: LocalAlgebra produces the localization of an algebra, i.e. +++ Description: +++ LocalAlgebra produces the localization of an algebra, i.e. ++ fractions whose numerators come from some R algebra. + LocalAlgebra(A: Algebra R, R: CommutativeRing, S: SubsetCategory(Monoid, R)): Algebra R with @@ -56619,9 +56678,10 @@ LocalAlgebra(A: Algebra R, ++ AMS Classifications: ++ Keywords: localization ++ References: -++ Description: Localize(M,R,S) produces fractions with numerators -++ from an R module M and denominators from some multiplicative subset -++ D of R. +++ Description: +++ Localize(M,R,S) produces fractions with numerators +++ from an R module M and denominators from some multiplicative subset D of R. + Localize(M:Module R, R:CommutativeRing, S:SubsetCategory(Monoid, R)): Module R with @@ -57065,7 +57125,8 @@ o )show LyndonWord ++ Also See: ++ AMS Classifications: ++ Keywords: -++ References: Free Lie Algebras by C. Reutenauer (Oxford science publications). +++ References: +++ Free Lie Algebras by C. Reutenauer (Oxford science publications). ++ Description: ++ Lyndon words over arbitrary (ordered) symbols: ++ see Free Lie Algebras by C. Reutenauer (Oxford science publications). @@ -57073,13 +57134,13 @@ o )show LyndonWord ++ w.r.t. the pure lexicographical ordering. ++ If \axiom{a} and \axiom{b} are two Lyndon words such that \axiom{a < b} ++ holds w.r.t lexicographical ordering then \axiom{a*b} is a Lyndon word. -++ Parenthesized Lyndon words can be generated from symbols by using the following -++ rule: \axiom{[[a,b],c]} is a Lyndon word iff \axiom{a*b < c <= b} holds. +++ Parenthesized Lyndon words can be generated from symbols by using the +++ following rule:\br +++ \axiom{[[a,b],c]} is a Lyndon word iff \axiom{a*b < c <= b} holds.\br ++ Lyndon words are internally represented by binary trees using the ++ \spadtype{Magma} domain constructor. ++ Two ordering are provided: lexicographic and -++ length-lexicographic. \newline -++ Author : Michel Petitot (petitot@lifl.fr). +++ length-lexicographic. LyndonWord(VarSet:OrderedSet):Public == Private where OFMON ==> OrderedFreeMonoid(VarSet) @@ -57091,13 +57152,14 @@ LyndonWord(VarSet:OrderedSet):Public == Private where Public == Join(OrderedSet,RetractableTo VarSet) with retractable? : $ -> Boolean - ++ \axiom{retractable?(x)} tests if \axiom{x} is a tree with only one entry. + ++ \axiom{retractable?(x)} tests if \axiom{x} is a tree + ++ with only one entry. left : $ -> $ ++ \axiom{left(x)} returns left subtree of \axiom{x} or - ++ error if \axiomOpFrom{retractable?}{LyndonWord}(\axiom{x}) is true. + ++ error if retractable?(x) is true. right : $ -> $ ++ \axiom{right(x)} returns right subtree of \axiom{x} or - ++ error if \axiomOpFrom{retractable?}{LyndonWord}(\axiom{x}) is true. + ++ error if retractable?(x) is true. length : $ -> PI ++ \axiom{length(x)} returns the number of entries in \axiom{x}. lexico : ($,$) -> Boolean @@ -57383,8 +57445,10 @@ LyndonWord(VarSet:OrderedSet):Public == Private where ++ Keywords: ++ Examples: ++ References: -++ Description: A domain which models the complex number representation +++ Description: +++ A domain which models the complex number representation ++ used by machines in the AXIOM-NAG link. + MachineComplex():Exports == Implementation where Exports ==> Join (FortranMachineTypeCategory, @@ -57527,8 +57591,10 @@ MachineComplex():Exports == Implementation where ++ Keywords: ++ Examples: ++ References: -++ Description: A domain which models the floating point representation +++ Description: +++ A domain which models the floating point representation ++ used by machines in the AXIOM-NAG link. + MachineFloat(): Exports == Implementation where PI ==> PositiveInteger @@ -57567,7 +57633,7 @@ MachineFloat(): Exports == Implementation where exponent : $ -> I ++ exponent(u) returns the exponent of u changeBase : (I,I,PI) -> $ - ++ changeBase(exp,man,base) \undocumented{} + ++ changeBase(exp,man,base) is not documented Implementation ==> add @@ -57931,8 +57997,10 @@ MachineFloat(): Exports == Implementation where ++ Keywords: ++ Examples: ++ References: -++ Description: A domain which models the integer representation +++ Description: +++ A domain which models the integer representation ++ used by machines in the AXIOM-NAG link. + MachineInteger(): Exports == Implementation where S ==> String @@ -58339,27 +58407,28 @@ Magma(VarSet:OrderedSet):Public == Private where ++ \axiom{first(x)} returns the first entry of the tree \axiom{x}. left : $ -> $ ++ \axiom{left(x)} returns left subtree of \axiom{x} or - ++ error if \axiomOpFrom{retractable?}{Magma}(\axiom{x}) is true. + ++ error if retractable?(x) is true. length : $ -> PositiveInteger ++ \axiom{length(x)} returns the number of entries in \axiom{x}. lexico : ($,$) -> Boolean - ++ \axiom{lexico(x,y)} returns \axiom{true} iff \axiom{x} is smaller than - ++ \axiom{y} w.r.t. the lexicographical ordering induced by \axiom{VarSet}. + ++ \axiom{lexico(x,y)} returns \axiom{true} iff \axiom{x} is smaller + ++ than \axiom{y} w.r.t. the lexicographical ordering induced by + ++ \axiom{VarSet}. ++ N.B. This operation does not take into account the tree structure of ++ its arguments. Thus this is not a total ordering. mirror : $ -> $ ++ \axiom{mirror(x)} returns the reversed word of \axiom{x}. - ++ That is \axiom{x} itself if - ++ \axiomOpFrom{retractable?}{Magma}(\axiom{x}) is true and + ++ That is \axiom{x} itself if retractable?(x) is true and ++ \axiom{mirror(z) * mirror(y)} if \axiom{x} is \axiom{y*z}. rest : $ -> $ ++ \axiom{rest(x)} return \axiom{x} without the first entry or - ++ error if \axiomOpFrom{retractable?}{Magma}(\axiom{x}) is true. + ++ error if retractable?(x) is true. retractable? : $ -> Boolean - ++ \axiom{retractable?(x)} tests if \axiom{x} is a tree with only one entry. + ++ \axiom{retractable?(x)} tests if \axiom{x} is a tree with + ++ only one entry. right : $ -> $ ++ \axiom{right(x)} returns right subtree of \axiom{x} or - ++ error if \axiomOpFrom{retractable?}{Magma}(\axiom{x}) is true. + ++ error if retractable?(x) is true. varList : $ -> List VarSet ++ \axiom{varList(x)} returns the list of distinct entries of \axiom{x}. @@ -58435,7 +58504,7 @@ Magma(VarSet:OrderedSet):Public == Private where x.left = y.left => x.right < y.right x.left < y.left - lexico(x,y) == -- peut etre amelioree !!!!!!!!!!! + lexico(x,y) == -- peut etre amelioree !!!!!!!!!!! x case VarSet => y case VarSet => x::VarSet < y::VarSet x::VarSet <= first y @@ -58444,7 +58513,7 @@ Magma(VarSet:OrderedSet):Public == Private where fx = fy => lexico(rest x , rest y) fx < fy - x < y == -- recursif par longueur + x < y == -- recursif par longueur lx,ly: PositiveInteger lx:= length x ; ly:= length y lx = ly => recursif(x,y) @@ -58485,12 +58554,12 @@ Magma(VarSet:OrderedSet):Public == Private where <>= )abbrev domain MKCHSET MakeCachableSet -++ Make a cachable set from any set ++ Author: Manuel Bronstein ++ Date Created: ??? ++ Date Last Updated: 14 May 1991 ++ Description: -++ MakeCachableSet(S) returns a cachable set which is equal to S as a set. +++ MakeCachableSet(S) returns a cachable set which is equal to S as a set. + MakeCachableSet(S:SetCategory): Exports == Implementation where Exports ==> Join(CachableSet, CoercibleTo S) with coerce: S -> % @@ -58687,20 +58756,20 @@ extension from ".stex" to ".smml". To the "section{output}" table I added the line \begin{verbatim} - mathml created output in MathML style Off:CONSOLE + mathml created output in MathML style Off:CONSOLE \end{verbatim} Added the code chunk "outputmathml" to the code chunk "output" in "section{output}". Relevant code chunks: \begin{verbatim} - outputmathml + outputmathml \end{verbatim} Relevant variables: \begin{verbatim} - setOutputMathml - $mathmlFormat - $mathmlOutputFile + setOutputMathml + $mathmlFormat + $mathmlOutputFile \end{verbatim} Note when copying the tex stuff I changed occurrences of "tex" @@ -58844,12 +58913,11 @@ really good. )abbrev domain MMLFORM MathMLFormat ++ Author: Arthur C. Ralfs ++ Date: January 2007 -++ This package is based on the TeXFormat domain by Robert S. Sutor -++ without which I wouldn't have known where to start. ++ Basic Operations: coerce, coerceS, coerceL, exprex, display ++ Description: -++ \spadtype{MathMLFormat} provides a coercion from \spadtype{OutputForm} -++ to MathML format. +++ This package is based on the TeXFormat domain by Robert S. Sutor +++ \spadtype{MathMLFormat} provides a coercion from \spadtype{OutputForm} +++ to MathML format. MathMLFormat(): public == private where E ==> OutputForm @@ -59109,9 +59177,9 @@ returning Void. I really only need the one coerce function. s : S := concat ["{",sop] if nargs > 0 then for a in args repeat --- sayTeX$Lisp concat ["2: ",stringify a] - s1 : S := exprex a - s := concat [s,s1] +-- sayTeX$Lisp concat ["2: ",stringify a] + s1 : S := exprex a + s := concat [s,s1] s := concat [s,"}"] @ @@ -59149,16 +59217,16 @@ returning Void. I really only need the one coerce function. if enE < length then -- sayTeX$Lisp "****displayElt3****" u := segment(1,enE)$US - sayTeX$Lisp mathML.u + sayTeX$Lisp mathML.u else -- sayTeX$Lisp "****displayElt4****" enT := tagEnd(name,1,mathML) - u := segment(1,enT)$US - sayTeX$Lisp mathML.u - u := segment(enT+1,enE-#name-3)$US - displayElt(mathML.u) - u := segment(enE-#name-2,enE)$US - sayTeX$Lisp mathML.u + u := segment(1,enT)$US + sayTeX$Lisp mathML.u + u := segment(enT+1,enE-#name-3)$US + displayElt(mathML.u) + u := segment(enE-#name-2,enE)$US + sayTeX$Lisp mathML.u if end > enE then -- sayTeX$Lisp "****displayElt5****" u := segment(enE+1,end)$US @@ -59191,19 +59259,19 @@ returning Void. I really only need the one coerce function. while (level > 0) repeat startI := position(startS,mathML,pI)$String - endI := position(endS,mathML,pI)$String + endI := position(endS,mathML,pI)$String - if (startI = 0) then - level := level-1 + if (startI = 0) then + level := level-1 --sayTeX$Lisp "****eltLimit 1******" - pI := tagEnd(name,endI,mathML) - else - if (startI < endI) then - level := level+1 - pI := tagEnd(name,startI,mathML) - else - level := level-1 - pI := tagEnd(name,endI,mathML) + pI := tagEnd(name,endI,mathML) + else + if (startI < endI) then + level := level+1 + pI := tagEnd(name,startI,mathML) + else + level := level-1 + pI := tagEnd(name,endI,mathML) pI @@ -59266,7 +59334,6 @@ have to be switched by swapping names. for a in letmp repeat le := append(le,atomize a) le - ungroup(str: S): S == len : I := #str @@ -59288,10 +59355,10 @@ have to be switched by swapping names. pos : I := position(plusminus,str,1) if pos > 0 then ustart:US := segment(1,pos-1)$US - uend:US := segment(pos+20,len)$US + uend:US := segment(pos+20,len)$US str := concat [str.ustart,"-",str.uend] - if pos < len-18 then - str := postcondition(str) + if pos < len-18 then + str := postcondition(str) str stringify expr == (mathObject2String$Lisp expr)@S @@ -59323,7 +59390,7 @@ have to be switched by swapping names. group concat [formatMml(first args,prec), "→", formatMml(second args,prec)] - --RightArrow + --RightArrow op = "SLASH" => group concat [formatMml(first args,prec), "/",formatMml(second args,prec)] @@ -59346,14 +59413,17 @@ have to be switched by swapping names. group parenthesize ungroup formatMml(first args, minPrec) op = "OVERBAR" => null args => "" - group concat ["",formatMml(first args,minPrec),"¯"] - --OverBar + group concat ["",_ + formatMml(first args,minPrec),_ + "¯"] + --OverBar op = "ROOT" => null args => "" tmp : S := group formatMml(first args, minPrec) null rest args => concat ["",tmp,""] group concat - ["",tmp,"",formatMml(first rest args, minPrec),""] + ["",tmp,"",_ + formatMml(first rest args, minPrec),""] op = "SEGMENT" => tmp : S := concat [formatMml(first args, minPrec),".."] group @@ -59368,19 +59438,33 @@ have to be switched by swapping names. -- the code here for now. op = "SUPERSUB" => base:S := formatMml(first args, minPrec) - args := rest args - if #args = 1 then - ""base""formatMml(first args, minPrec)"" - else if #args = 2 then - -- it would be nice to substitue ′ for , in the case of - -- an ordinary derivative, it looks a lot better. - ""base""formatMml(first args,minPrec)""formatMml(first rest args, minPrec)"" - else if #args = 3 then - ""base""formatMml(first args,minPrec)""formatMml(first rest args,minPrec)""formatMml(first rest rest args,minPrec)"" - else if #args = 4 then - ""base""formatMml(first args,minPrec)""formatMml(first rest args,minPrec)""formatMml(first rest rest args,minPrec)""formatMml(first rest rest rest args,minPrec)"" - else - "Problem with multiscript object" + args := rest args + if #args = 1 then + ""base""_ + formatMml(first args, minPrec)"" + else if #args = 2 then + -- it would be nice to substitue ′ for , in the case of + -- an ordinary derivative, it looks a lot better. + ""base""_ + formatMml(first args,minPrec)_ + ""_ + formatMml(first rest args, minPrec)_ + "" + else if #args = 3 then + ""base""_ + formatMml(first args,minPrec)""_ + formatMml(first rest args,minPrec)""_ + formatMml(first rest rest args,minPrec)_ + "" + else if #args = 4 then + ""base""_ + formatMml(first args,minPrec)""_ + formatMml(first rest args,minPrec)""_ + formatMml(first rest rest args,minPrec)_ + ""formatMml(first rest rest rest args,minPrec)_ + "" + else + "Problem with multiscript object" op = "SC" => -- need to handle indentation someday null args => "" @@ -59388,7 +59472,8 @@ have to be switched by swapping names. group concat ["",tmp,""] op = "MATRIX" => formatMatrix rest args op = "ZAG" => --- {{+}{3}{{ZAG}{1}{7}}{{ZAG}{1}{15}}{{ZAG}{1}{1}}{{ZAG}{1}{25}}{{ZAG}{1}{1}}{{ZAG}{1}{7}}{{ZAG}{1}{4}}} +-- {{+}{3}{{ZAG}{1}{7}}{{ZAG}{1}{15}}{{ZAG}{1}{1}} +-- {{ZAG}{1}{25}}{{ZAG}{1}{1}}{{ZAG}{1}{7}}{{ZAG}{1}{4}}} -- to format continued fraction traditionally need to intercept it at the -- formatNary of the "+" concat [" \zag{",formatMml(first args, minPrec),"}{", @@ -59402,11 +59487,13 @@ have to be switched by swapping names. -- At this time this is only to handle partial derivatives. -- If the SUB case handles anything else I'm not aware of it. -- This an example of the 4th partial of y(x,z) w.r.t. x,x,z,x - -- {{{SUB}{y}{{CONCAT}{{CONCAT}{{CONCAT}{{CONCAT}{,}{1}}{{CONCAT}{,}{1}}}{{CONCAT}{,}{2}}}{{CONCAT}{,}{1}}}}{x}{z}} + -- {{{SUB}{y}{{CONCAT}{{CONCAT}{{CONCAT}{{CONCAT}{,}{1}} + -- {{CONCAT}{,}{1}}}{{CONCAT}{,}{2}}}{{CONCAT}{,}{1}}}}{x}{z}} atomE : L E := atomize(expr) op : S := stringify first atomE op ^= "SUB" => "Mistake in formatSub: no SUB" - stringify first rest rest atomE ^= "CONCAT" => "Mistake in formatSub: no CONCAT" + stringify first rest rest atomE ^= "CONCAT" => _ + "Mistake in formatSub: no CONCAT" -- expecting form for atomE like --[{SUB}{func}{CONCAT}...{CONCAT}{,}{n}{CONCAT}{,}{n}...{CONCAT}{,}{n}], --counting the first CONCATs before the comma gives the number of @@ -59415,13 +59502,13 @@ have to be switched by swapping names. tmpLE : L E := rest rest atomE while stringify first tmpLE = "CONCAT" repeat ndiffs := ndiffs+1 - tmpLE := rest tmpLE + tmpLE := rest tmpLE numLS : L S := nil i : I := 1 while i < ndiffs repeat numLS := append(numLS,list(stringify first rest tmpLE)) - tmpLE := rest rest rest tmpLE - i := i+1 + tmpLE := rest rest rest tmpLE + i := i+1 numLS := append(numLS,list(stringify first rest tmpLE)) -- numLS contains the numbers of the bound variables as strings -- for the differentiations, thus for the differentiation [x,x,z,x] @@ -59431,7 +59518,7 @@ have to be switched by swapping names. -- sayTeX$Lisp "formatSub: nargs = "string(#args) while i < #args repeat posLS := append(posLS,list(string(i+1))) - i := i+1 + i := i+1 -- posLS contains the positions of the bound variables in args -- as a list of strings, e.g. for the above example ["1","2"] tmpS: S := stringify atomE.2 @@ -59446,25 +59533,26 @@ have to be switched by swapping names. k : I tmpS: S while i < #posLS+1 repeat - j := 0 - k := 1 - while k < #numLS + 1 repeat - if numLS.k = string i then j := j + 1 - k := k+1 + j := 0 + k := 1 + while k < #numLS + 1 repeat + if numLS.k = string i then j := j + 1 + k := k+1 if j > 0 then - tmpS := stringify args.i - if j = 1 then - s := s"∂"tmpS"" - else - s := s"∂"tmpS""string(j)"" + tmpS := stringify args.i + if j = 1 then + s := s"∂"tmpS"" + else + s := s"∂"tmpS_ + ""string(j)"" i := i + 1 s := s"(" i := 1 while i < #posLS+1 repeat tmpS := stringify args.i - s := s""tmpS"" - if i < #posLS then s := s"," - i := i+1 + s := s""tmpS"" + if i < #posLS then s := s"," + i := i+1 s := s")" formatSub1(expr : E, args : L E, opPrec : I) : S == @@ -59489,13 +59577,13 @@ have to be switched by swapping names. tmpLE : L E := rest rest atomE while stringify first tmpLE = "CONCAT" repeat ndiffs := ndiffs+1 - tmpLE := rest tmpLE + tmpLE := rest tmpLE numLS : L S := nil i : I := 1 while i < ndiffs repeat numLS := append(numLS,list(stringify first rest tmpLE)) - tmpLE := rest rest rest tmpLE - i := i+1 + tmpLE := rest rest rest tmpLE + i := i+1 numLS := append(numLS,list(stringify first rest tmpLE)) -- numLS contains the numbers of the bound variables as strings -- for the differentiations, thus for the differentiation [x,x,z,x] @@ -59505,7 +59593,7 @@ have to be switched by swapping names. -- sayTeX$Lisp "formatSub: nargs = "string(#args) while i < #args repeat posLS := append(posLS,list(string(i+1))) - i := i+1 + i := i+1 -- posLS contains the positions of the bound variables in args -- as a list of strings, e.g. for the above example ["1","2"] funcS: S := stringify atomE.2 @@ -59513,16 +59601,16 @@ have to be switched by swapping names. i := 1 while i < #numLS+1 repeat s := s","numLS.i"" - i := i + 1 + i := i + 1 s := s"(" i := 1 while i < #posLS+1 repeat -- tmpS := stringify args.i - tmpS := formatMml(first args,minPrec) - args := rest args - s := s""tmpS"" - if i < #posLS then s := s"," - i := i+1 + tmpS := formatMml(first args,minPrec) + args := rest args + s := s""tmpS"" + if i < #posLS then s := s"," + i := i+1 s := s")" formatSuperSub(expr : E, args : L E, opPrec : I) : S == @@ -59550,14 +59638,15 @@ have to be switched by swapping names. i : I := 0 while position(commaTest,commaS,1) > 0 repeat i := i+1 - commaTest := commaTest"," + commaTest := commaTest"," s : S := ""funcS"" -- WriteLine$Lisp "s: "s j : I := 0 while j < i repeat s := s"′" - j := j + 1 - s := s"⁡("formatMml(first args,minPrec)")" + j := j + 1 + s := s"⁡("_ + formatMml(first args,minPrec)")" formatSuperSub1(expr : E, args : L E, opPrec : I) : S == -- This one produces ordinary derivatives with differential notation, @@ -59582,8 +59671,12 @@ have to be switched by swapping names. ndiffs : I := 0 while position(commaTest,commaS,1) > 0 repeat ndiffs := ndiffs+1 - commaTest := commaTest"," - s : S := "ⅆ"string(ndiffs)""funcS"ⅆ"formatMml(first args,minPrec)""string(ndiffs)"⁡("formatMml(first args,minPrec)")" + commaTest := commaTest"," + s : S := "ⅆ"string(ndiffs)_ + ""funcS"ⅆ"_ + formatMml(first args,minPrec)""string(ndiffs)_ + "⁡("_ + formatMml(first args,minPrec)")" formatPlex(op : S, args : L E, prec : I) : S == checkarg:Boolean := false @@ -59598,45 +59691,46 @@ have to be switched by swapping names. op = "SIGMA" => checkarg := true "∑" - -- Sum + -- Sum op = "SIGMA2" => checkarg := true "∑" - -- Sum + -- Sum op = "PI" => checkarg := true "∏" - -- Product + -- Product op = "PI2" => checkarg := true "∏" - -- Product + -- Product -- op = "INTSIGN" => "∫" - -- Integral, int + -- Integral, int op = "INDEFINTEGRAL" => "∫" - -- Integral, int + -- Integral, int "????" hold := formatMml(first args,minPrec) args := rest args if op ^= "INDEFINTEGRAL" then if hold ^= "" then s := concat ["",s,group hold] - else - s := concat ["",s,group " "] + else + s := concat ["",s,group " "] if not null rest args then hold := formatMml(first args,minPrec) - if hold ^= "" then + if hold ^= "" then s := concat [s,group hold,""] - else - s := concat [s,group " ",""] + else + s := concat [s,group " ",""] args := rest args - -- if checkarg true need to test op arg for "+" at least - -- and wrap parentheses if so - if checkarg then + -- if checkarg true need to test op arg for "+" at least + -- and wrap parentheses if so + if checkarg then la : L E := (first args pretend L E) opa : S := stringify first la - if opa = "+" then - s := concat [s,"(",formatMml(first args,minPrec),")"] + if opa = "+" then + s := + concat [s,"(",formatMml(first args,minPrec),")"] else s := concat [s,formatMml(first args,minPrec)] else s := concat [s,formatMml(first args,minPrec)] else @@ -59654,27 +59748,28 @@ have to be switched by swapping names. -- starting at the NOTHING or ... (stringify first args) = "NOTHING" => -- the bound variable is the second one in the argument list - bvar : E := first rest args - bvarS : S := stringify bvar - tmpS : S - i : I := 0 - u1 : US - u2 : US - -- this next one atomizes the integrand plus differential - atomE : L E := atomize(first rest rest args) - -- pick out the bound variable used by axiom - varRS : S := stringify last(atomE) - tmpLE : L E := ((first rest rest args) pretend L E) + bvar : E := first rest args + bvarS : S := stringify bvar + tmpS : S + i : I := 0 + u1 : US + u2 : US + -- this next one atomizes the integrand plus differential + atomE : L E := atomize(first rest rest args) + -- pick out the bound variable used by axiom + varRS : S := stringify last(atomE) + tmpLE : L E := ((first rest rest args) pretend L E) integrand : S := formatMml(first rest tmpLE,minPrec) - -- replace the bound variable, i.e. axiom uses someting of the form - -- %A for the bound variable and puts the original variable used - -- in the input command as a superscript on the integral sign. - -- I'm assuming that the axiom variable is 2 characters. - while (i := position(varRS,integrand,i+1)) > 0 repeat - u1 := segment(1,i-1)$US - u2 := segment(i+2,#integrand)$US - integrand := concat [integrand.u1,bvarS,integrand.u2] - concat ["∫" integrand "ⅆ" bvarS ""] + -- replace the bound variable, i.e. axiom uses someting of the form + -- %A for the bound variable and puts the original variable used + -- in the input command as a superscript on the integral sign. + -- I'm assuming that the axiom variable is 2 characters. + while (i := position(varRS,integrand,i+1)) > 0 repeat + u1 := segment(1,i-1)$US + u2 := segment(i+2,#integrand)$US + integrand := concat [integrand.u1,bvarS,integrand.u2] + concat ["∫" integrand _ + "ⅆ" bvarS ""] lowlim : S := stringify first args highlim : S := stringify first rest args @@ -59771,10 +59866,11 @@ have to be switched by swapping names. -- to handle the whole continued fraction at once, i.e. we can't -- just look for, e.g., {{ZAG}{1}{6}} (#args > 1) and (position("ZAG",stringify first rest args,1) > 0) => - tmpS : S := stringify first args - position("ZAG",tmpS,1) > 0 => formatZag(args) --- position("ZAG",tmpS,1) > 0 => formatZag1(args) - concat [formatMml(first args,minPrec) "+" formatZag(rest args)] + tmpS : S := stringify first args + position("ZAG",tmpS,1) > 0 => formatZag(args) +-- position("ZAG",tmpS,1) > 0 => formatZag1(args) + concat [formatMml(first args,minPrec) "+" _ + formatZag(rest args)] -- At least for the ops "*","+","-" we need to test to see if a sigma -- or pi is one of their arguments because we might need parentheses -- as indicated by the problem with @@ -59785,13 +59881,13 @@ have to be switched by swapping names. op = "," => "," --originally , \: op = ";" => ";" --originally ; \: should figure these out op = "*" => "" - -- InvisibleTimes + -- InvisibleTimes op = " " => "" op = "ROW" => "" - op = "+" => + op = "+" => checkargs := true "+" - op = "-" => + op = "-" => checkargs := true "-" op @@ -59804,22 +59900,22 @@ have to be switched by swapping names. for a in args repeat -- WriteLine$Lisp "checking args" if checkargs then - if count < #args then - -- check here for sum or product - if ATOM(a)$Lisp@Boolean then - opa:S := stringify a - else - la : L E := (a pretend L E) - opa : S := stringify first la - if opa = "SIGMA" or opa = "SIGMA2" or _ + if count < #args then + -- check here for sum or product + if ATOM(a)$Lisp@Boolean then + opa:S := stringify a + else + la : L E := (a pretend L E) + opa : S := stringify first la + if opa = "SIGMA" or opa = "SIGMA2" or _ opa = "PI" or opa = "PI2" then - l := concat(op,concat(_ + l := concat(op,concat(_ concat ["(",formatMml(a,opPrec),_ ")"],l)$L(S))$L(S) - else l := concat(op,concat(formatMml(a,opPrec),l)$L(S))$L(S) - else l := concat(op,concat(formatMml(a,opPrec),l)$L(S))$L(S) - else l := concat(op,concat(formatMml(a,opPrec),l)$L(S))$L(S) - count := count + 1 + else l := concat(op,concat(formatMml(a,opPrec),l)$L(S))$L(S) + else l := concat(op,concat(formatMml(a,opPrec),l)$L(S))$L(S) + else l := concat(op,concat(formatMml(a,opPrec),l)$L(S))$L(S) + count := count + 1 s : S := concat reverse rest l opPrec < prec => parenthesize s s @@ -59854,7 +59950,7 @@ have to be switched by swapping names. ATOM(expr)$Lisp@Boolean => str := stringify expr len := #str - -- this bit seems to deal with integers + -- this bit seems to deal with integers FIXP$Lisp expr => i := expr pretend Integer if (i < 0) or (i > 9) @@ -59873,15 +59969,15 @@ have to be switched by swapping names. concat ["",elt(nstr,segment(2)$US),""] else str := concat ["",str,""] str = "%pi" => "π" - -- pi + -- pi str = "%e" => "ⅇ" - -- ExponentialE + -- ExponentialE str = "%i" => "ⅈ" - -- ImaginaryI + -- ImaginaryI len > 0 and str.1 = char "%" => concat(concat("",str),"") -- should handle floats len > 1 and digit? str.1 => concat ["",str,""] - -- presumably this is a literal string + -- presumably this is a literal string len > 0 and str.1 = char "_"" => concat(concat("",str),"") len = 1 and str.1 = char " " => " " @@ -59889,10 +59985,10 @@ have to be switched by swapping names. specialStringsInMML.i (i := position(char " ",str)) > 0 => -- We want to preserve spacing, so use a roman font. - -- What's this for? Leave the \rm in for now so I can see - -- where it arises. Removed 2007-02-14 + -- What's this for? Leave the \rm in for now so I can see + -- where it arises. Removed 2007-02-14 concat(concat("",str),"") - -- if we get to here does that mean it's a variable? + -- if we get to here does that mean it's a variable? concat ["",str,""] l : L E := (expr pretend L E) null l => blank @@ -61130,8 +61226,9 @@ o )show Matrix ++ Examples: ++ References: ++ Description: -++ \spadtype{Matrix} is a matrix domain where 1-based indexing is used -++ for both rows and columns. +++ \spadtype{Matrix} is a matrix domain where 1-based indexing is used +++ for both rows and columns. + Matrix(R): Exports == Implementation where R : Ring Row ==> Vector R @@ -61159,7 +61256,7 @@ Matrix(R): Exports == Implementation where -- ++ matrix -- diagonalMatrix: Vector $ -> $ -- ++ \spad{diagonalMatrix([m1,...,mk])} creates a block diagonal matrix --- ++ M with block matrices {\em m1},...,{\em mk} down the diagonal, +-- ++ M with block matrices m1,...,mk down the diagonal, -- ++ with 0 block matrices elsewhere. -- vectorOfVectors: $ -> Vector Vector R -- ++ \spad{vectorOfVectors(m)} returns the rows of the matrix m as a @@ -61435,8 +61532,9 @@ Matrix(R): Exports == Implementation where <>= )abbrev domain MODMON ModMonic +++ Author: Mark Botch ++ Description: -++ This package \undocumented +++ This package has not been documented -- following line prevents caching ModMonic )bo PUSH('ModMonic, $mutableDomains) @@ -61447,28 +61545,28 @@ ModMonic(R,Rep): C == T C == UnivariatePolynomialCategory(R) with --operations setPoly : Rep -> Rep - ++ setPoly(x) \undocumented + ++ setPoly(x) is not documented modulus : -> Rep - ++ modulus() \undocumented + ++ modulus() is not documented reduce: Rep -> % - ++ reduce(x) \undocumented + ++ reduce(x) is not documented lift: % -> Rep --reduce lift = identity - ++ lift(x) \undocumented + ++ lift(x) is not documented coerce: Rep -> % - ++ coerce(x) \undocumented + ++ coerce(x) is not documented Vectorise: % -> Vector(R) - ++ Vectorise(x) \undocumented + ++ Vectorise(x) is not documented UnVectorise: Vector(R) -> % - ++ UnVectorise(v) \undocumented + ++ UnVectorise(v) is not documented An: % -> Vector(R) - ++ An(x) \undocumented + ++ An(x) is not documented pow : -> PrimitiveArray(%) - ++ pow() \undocumented + ++ pow() is not documented computePowers : -> PrimitiveArray(%) - ++ computePowers() \undocumented + ++ computePowers() is not documented if R has FiniteFieldCategory then frobenius: % -> % - ++ frobenius(x) \undocumented + ++ frobenius(x) is not documented --LinearTransf: (%,Vector(R)) -> SquareMatrix R --assertions if R has Finite then Finite @@ -61667,10 +61765,13 @@ ModMonic(R,Rep): C == T <>= )abbrev domain MODFIELD ModularField +++ Author: Mark Botch +++ Description: ++ 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} + ModularField(R,Mod,reduction:(R,Mod) -> R, merge:(Mod,Mod) -> Union(Mod,"failed"), exactQuo : (R,R,Mod) -> Union(R,"failed")) : C == T @@ -61679,14 +61780,14 @@ ModularField(R,Mod,reduction:(R,Mod) -> R, Mod : AbelianMonoid C == Field with - modulus : % -> Mod - ++ modulus(x) \undocumented - coerce : % -> R - ++ coerce(x) \undocumented - reduce : (R,Mod) -> % - ++ reduce(r,m) \undocumented - exQuo : (%,%) -> Union(%,"failed") - ++ exQuo(x,y) \undocumented + modulus: % -> Mod + ++ modulus(x) is not documented + coerce: % -> R + ++ coerce(x) is not documented + reduce: (R,Mod) -> % + ++ reduce(r,m) is not documented + exQuo: (%,%) -> Union(%,"failed") + ++ exQuo(x,y) is not documented T == ModularRing(R,Mod,reduction,merge,exactQuo) @@ -61757,18 +61858,18 @@ ModularRing(R,Mod,reduction:(R,Mod) -> R, Mod : AbelianMonoid C == Ring with - modulus : % -> Mod - ++ modulus(x) \undocumented - coerce : % -> R - ++ coerce(x) \undocumented - reduce : (R,Mod) -> % - ++ reduce(r,m) \undocumented - exQuo : (%,%) -> Union(%,"failed") - ++ exQuo(x,y) \undocumented - recip : % -> Union(%,"failed") - ++ recip(x) \undocumented - inv : % -> % - ++ inv(x) \undocumented + modulus: % -> Mod + ++ modulus(x) is not documented + coerce: % -> R + ++ coerce(x) is not documented + reduce: (R,Mod) -> % + ++ reduce(r,m) is not documented + exQuo: (%,%) -> Union(%,"failed") + ++ exQuo(x,y) is not documented + recip: % -> Union(%,"failed") + ++ recip(x) is not documented + inv: % -> % + ++ inv(x) is not documented T == add --representation @@ -61856,8 +61957,10 @@ ModularRing(R,Mod,reduction:(R,Mod) -> R, <>= )abbrev domain MODMONOM ModuleMonomial +++ Author: Mark Botch ++ Description: -++ This package \undocumented +++ This package has no documentation + ModuleMonomial(IS: OrderedSet, E: SetCategory, ff:(MM, MM) -> Boolean): T == C where @@ -61865,16 +61968,16 @@ ModuleMonomial(IS: OrderedSet, MM ==> Record(index:IS, exponent:E) T == OrderedSet with - exponent: $ -> E - ++ exponent(x) \undocumented - index: $ -> IS - ++ index(x) \undocumented - coerce: MM -> $ - ++ coerce(x) \undocumented - coerce: $ -> MM - ++ coerce(x) \undocumented - construct: (IS, E) -> $ - ++ construct(i,e) \undocumented + exponent: $ -> E + ++ exponent(x) is not documented + index: $ -> IS + ++ index(x) is not documented + coerce: MM -> $ + ++ coerce(x) is not documented + coerce: $ -> MM + ++ coerce(x) is not documented + construct: (IS, E) -> $ + ++ construct(i,e) is not documented C == MM add Rep:= MM x:$ < y:$ == ff(x::Rep, y::Rep) @@ -61938,6 +62041,7 @@ ModuleMonomial(IS: OrderedSet, ++ Date Last Updated: 17 June 1993 ++ Description: ++ Algebra of ADDITIVE operators on a module. + ModuleOperator(R: Ring, M:LeftModule(R)): Exports == Implementation where O ==> OutputForm OP ==> BasicOperator @@ -61970,11 +62074,11 @@ ModuleOperator(R: Ring, M:LeftModule(R)): Exports == Implementation where ++ This implies that \spad{g(n a) = n g(a)} for ++ any \spad{a} in M and integer \spad{n > 0}. evaluateInverse: ($, M -> M) -> $ - ++ evaluateInverse(x,f) \undocumented + ++ evaluateInverse(x,f) is not documented "**": (OP, Integer) -> $ - ++ op**n \undocumented + ++ op**n is not documented "**": ($, Integer) -> $ - ++ op**n \undocumented + ++ op**n is not documented opeval : (OP, M) -> M ++ opeval should be local but conditional makeop : (R, FG) -> $ @@ -62198,16 +62302,17 @@ ModuleOperator(R: Ring, M:LeftModule(R)): Exports == Implementation where <>= )abbrev domain MOEBIUS MoebiusTransform -++ 2-by-2 matrices acting on P1(F). ++ Author: Stephen "Say" Watt ++ Date Created: January 1987 ++ Date Last Updated: 11 April 1990 ++ Keywords: ++ Examples: ++ References: +++ Description: +++ MoebiusTransform(F) is the domain of fractional linear (Moebius) +++ transformations over F. This a domain of 2-by-2 matrices acting on P1(F). + MoebiusTransform(F): Exports == Implementation where - ++ MoebiusTransform(F) is the domain of fractional linear (Moebius) - ++ transformations over F. F : Field OUT ==> OutputForm P1F ==> OnePointCompletion F -- projective 1-space over F @@ -62227,20 +62332,20 @@ MoebiusTransform(F): Exports == Implementation where ++ \spad{x -> 1 / x}. shift: (%,F) -> % ++ shift(m,h) returns \spad{shift(h) * m} - ++ (see \spadfunFrom{shift}{MoebiusTransform}). + ++ (see shift from MoebiusTransform). scale: (%,F) -> % ++ scale(m,h) returns \spad{scale(h) * m} - ++ (see \spadfunFrom{shift}{MoebiusTransform}). + ++ (see shift from MoebiusTransform). recip: % -> % ++ recip(m) = recip() * m eval: (%,F) -> F ++ eval(m,x) returns \spad{(a*x + b)/(c*x + d)} ++ where \spad{m = moebius(a,b,c,d)} - ++ (see \spadfunFrom{moebius}{MoebiusTransform}). + ++ (see moebius from MoebiusTransform). eval: (%,P1F) -> P1F ++ eval(m,x) returns \spad{(a*x + b)/(c*x + d)} ++ where \spad{m = moebius(a,b,c,d)} - ++ (see \spadfunFrom{moebius}{MoebiusTransform}). + ++ (see moebius from MoebiusTransform). Implementation ==> add @@ -62362,21 +62467,21 @@ MoebiusTransform(F): Exports == Implementation where ++ indeterminates ++ References: ++ Description: -++ \spadtype{MonoidRing}(R,M), implements the algebra -++ of all maps from the monoid M to the commutative ring R with -++ finite support. -++ Multiplication of two maps f and g is defined -++ to map an element c of M to the (convolution) sum over {\em f(a)g(b)} -++ such that {\em ab = c}. Thus M can be identified with a canonical -++ basis and the maps can also be considered as formal linear combinations -++ of the elements in 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 M is -++ \spadtype{FreeMonoid Symbol}, one gets polynomials -++ in infinitely many non-commuting variables. Another application -++ area is representation theory of finite groups G, where modules -++ over \spadtype{MonoidRing}(R,G) are studied. +++ \spadtype{MonoidRing}(R,M), implements the algebra +++ of all maps from the monoid M to the commutative ring R with +++ finite support. +++ Multiplication of two maps f and g is defined +++ to map an element c of M to the (convolution) sum over f(a)g(b) +++ such that ab = c. Thus M can be identified with a canonical +++ basis and the maps can also be considered as formal linear combinations +++ of the elements in 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 M is +++ \spadtype{FreeMonoid Symbol}, one gets polynomials +++ in infinitely many non-commuting variables. Another application +++ area is representation theory of finite groups G, where modules +++ over \spadtype{MonoidRing}(R,G) are studied. MonoidRing(R: Ring, M: Monoid): MRcategory == MRdefinition where Term ==> Record(coef: R, monom: M) @@ -62958,7 +63063,9 @@ o )show Multiset ++ Keywords: ++ Examples: ++ References: -++ Description: A multiset is a set with multiplicities. +++ Description: +++ A multiset is a set with multiplicities. + Multiset(S: SetCategory): MultisetAggregate S with finiteAggregate shallowlyMutable @@ -62970,7 +63077,7 @@ Multiset(S: SetCategory): MultisetAggregate S with ++ multiset(ls) creates a multiset with elements from \spad{ls}. members: % -> List S ++ members(ms) returns a list of the elements of \spad{ms} - ++ {\em without} their multiplicity. See also \spadfun{parts}. + ++ without their multiplicity. See also \spadfun{parts}. remove: (S,%,Integer) -> % ++ remove(x,ms,number) removes at most \spad{number} copies of ++ element x if \spad{number} is positive, all of them if @@ -63013,7 +63120,7 @@ Multiset(S: SetCategory): MultisetAggregate S with empty():% == [0,tbl()] multiset():% == empty() - dictionary():% == empty() -- DictionaryOperations + dictionary():% == empty() -- DictionaryOperations set():% == empty() brace():% == empty() @@ -63025,8 +63132,8 @@ Multiset(S: SetCategory): MultisetAggregate S with n := inc n [n, t] multiset(l:List S):% == construct l - bag(l:List S):% == construct l -- BagAggregate - dictionary(l:List S):% == construct l -- DictionaryOperations + bag(l:List S):% == construct l -- BagAggregate + dictionary(l:List S):% == construct l -- DictionaryOperations set(l:List S):% == construct l brace(l:List S):% == construct l @@ -63052,14 +63159,14 @@ Multiset(S: SetCategory): MultisetAggregate S with l := cons(item,l) brace l - duplicates(ms:%):List D == -- MultiDictionary + duplicates(ms:%):List D == -- MultiDictionary ld : List D := empty() t := ms.table for e in keys t | (n := t.e) > 1 repeat ld := cons([e,n::NonNegativeInteger],ld) ld - extract_!(ms:%):S == -- BagAggregate + extract_!(ms:%):S == -- BagAggregate empty? ms => error "extract: Empty multiset" ms.count := dec ms.count t := ms.table @@ -63068,9 +63175,9 @@ Multiset(S: SetCategory): MultisetAggregate S with else remove_!(e,t) e - inspect(ms:%):S == inspect(ms.table).key -- BagAggregate + inspect(ms:%):S == inspect(ms.table).key -- BagAggregate - insert_!(e:S,ms:%):% == -- BagAggregate + insert_!(e:S,ms:%):% == -- BagAggregate ms.count := inc ms.count ms.table.e := inc ms.table.e ms @@ -63117,36 +63224,36 @@ Multiset(S: SetCategory): MultisetAggregate S with remove(p: S -> Boolean,ms:%,max:Integer):% == remove_!(p, copy ms, max) - remove_!(e:S, ms:%):% == -- DictionaryOperations + remove_!(e:S, ms:%):% == -- DictionaryOperations t := ms.table if member?(e, keys t) then ms.count := ms.count-t.e remove_!(e, t) ms - remove_!(p:S ->Boolean, ms:%):% == -- DictionaryOperations + remove_!(p:S ->Boolean, ms:%):% == -- DictionaryOperations t := ms.table for e in keys t | p(e) repeat ms.count := ms.count-t.e remove_!(e, t) ms - select_!(p: S -> Boolean, ms:%):% == -- DictionaryOperations + select_!(p: S -> Boolean, ms:%):% == -- DictionaryOperations remove_!((s1:S):Boolean+->not p(s1), ms) - removeDuplicates_!(ms:%):% == -- MultiDictionary + removeDuplicates_!(ms:%):% == -- MultiDictionary t := ms.table l := keys t for e in l repeat t.e := 1 ms.count := #l ms - insert_!(e:S,ms:%,more:NonNegativeInteger):% == -- MultiDictionary + insert_!(e:S,ms:%,more:NonNegativeInteger):% == -- MultiDictionary ms.count := ms.count+more ms.table.e := ms.table.e+more ms - map_!(f: S->S, ms:%):% == -- HomogeneousAggregate + map_!(f: S->S, ms:%):% == -- HomogeneousAggregate t := ms.table t1 := tbl() for e in keys t repeat @@ -63155,7 +63262,7 @@ Multiset(S: SetCategory): MultisetAggregate S with ms.table := t1 ms - map(f: S -> S, ms:%):% == map_!(f, copy ms) -- HomogeneousAggregate + map(f: S -> S, ms:%):% == map_!(f, copy ms) -- HomogeneousAggregate parts(m:%):List S == l := empty()$List(S) @@ -63544,7 +63651,7 @@ o )show MultivariatePolynomial ++ Keywords: polynomial, multivariate ++ References: ++ Description: -++ This type is the basic representation of sparse recursive multivariate +++ 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, @@ -63674,6 +63781,10 @@ MultivariatePolynomial(vl:List Symbol, R:Ring) <>= )abbrev domain MYEXPR MyExpression +++ Author: Mark Botch +++ Description: +++ This domain has no description + MyExpression(q: Symbol, R): Exports == Implementation where R: Join(Ring, OrderedSet, IntegralDomain) @@ -63689,7 +63800,6 @@ MyExpression(q: Symbol, R): Exports == Implementation where numerator : % -> % denominator : % -> % ground? : % -> Boolean - coerce: Fraction UP -> % retract: % -> Fraction UP @@ -63857,6 +63967,10 @@ MyExpression(q: Symbol, R): Exports == Implementation where <>= )abbrev domain MYUP MyUnivariatePolynomial +++ Author: Mark Botch +++ Description: +++ This domain has no description + MyUnivariatePolynomial(x:Symbol, R:Ring): UnivariatePolynomialCategory(R) with RetractableTo Symbol; @@ -64055,11 +64169,11 @@ by means of triangular sets. ++ Keywords: ++ Examples: ++ References: -++ Description: A post-facto extension for \axiomType{SMP} in order +++ Description: +++ A post-facto extension for \axiomType{SMP} in order ++ to speed up operations related to pseudo-division and gcd. ++ This domain is based on the \axiomType{NSUP} constructor which is ++ itself a post-facto extension of the \axiomType{SUP} constructor. -++ Version: 2 NewSparseMultivariatePolynomial(R,VarSet) : Exports == Implementation where R:Ring @@ -64070,8 +64184,8 @@ NewSparseMultivariatePolynomial(R,VarSet) : Exports == Implementation where SMPR ==> SparseMultivariatePolynomial(R, VarSet) SUP2 ==> NewSparseUnivariatePolynomialFunctions2($,$) - Exports == Join(RecursivePolynomialCategory(R,IndexedExponents VarSet, VarSet), - CoercibleTo(SMPR),RetractableTo(SMPR)) + Exports == Join(RecursivePolynomialCategory(R,IndexedExponents VarSet,_ + VarSet), CoercibleTo(SMPR),RetractableTo(SMPR)) Implementation == SparseMultivariatePolynomial(R, VarSet) add @@ -64606,7 +64720,8 @@ constructur {\bf SparseUnivariatePolynomial}. ++ Keywords: ++ Examples: ++ References: -++ Description: A post-facto extension for \axiomType{SUP} in order +++ Description: +++ A post-facto extension for \axiomType{SUP} in order ++ to speed up operations related to pseudo-division and gcd for ++ both \axiomType{SUP} and, consequently, \axiomType{NSMP}. @@ -64634,8 +64749,8 @@ NewSparseUnivariatePolynomial(R): Exports == Implementation where ++ \axiom{lazyPseudoRemainder(a,b)} returns \axiom{r} if ++ \axiom{lazyResidueClass(a,b)} returns \axiom{[r,c,n]}. ++ This lazy pseudo-remainder is computed by means of the - ++ \axiomOpFrom{fmecg}{NewSparseUnivariatePolynomial} operation. - lazyPseudoDivide: ($,$) -> Record(coef:R, gap:NNI, quotient:$, remainder: $) + ++ fmecg from NewSparseUnivariatePolynomial operation. + lazyPseudoDivide: ($,$) -> Record(coef:R,gap:NNI,quotient:$,remainder:$) ++ \axiom{lazyPseudoDivide(a,b)} returns \axiom{[c,g,q,r]} such that ++ \axiom{c^n * a = q*b +r} and \axiom{lazyResidueClass(a,b)} returns ++ \axiom{[r,c,n]} where @@ -64696,14 +64811,14 @@ NewSparseUnivariatePolynomial(R): Exports == Implementation where (p pretend SUPR)::Union(SUPR,"failed") monicModulo(x,y) == - zero? y => - error "in monicModulo$NSUP: division by 0" - ground? y => - error "in monicModulo$NSUP: ground? #2" + zero? y => + error "in monicModulo$NSUP: division by 0" + ground? y => + error "in monicModulo$NSUP: ground? #2" yy := rep y -- not one? (yy.first.c) => not ((yy.first.c) = 1) => - error "in monicModulo$NSUP: not monic #2" + error "in monicModulo$NSUP: not monic #2" xx := rep x; empty? xx => x e := yy.first.k; y := per(yy.rest) -- while (not empty? xx) repeat @@ -64714,10 +64829,10 @@ NewSparseUnivariatePolynomial(R): Exports == Implementation where per xx lazyResidueClass(x,y) == - zero? y => - error "in lazyResidueClass$NSUP: division by 0" - ground? y => - error "in lazyResidueClass$NSUP: ground? #2" + zero? y => + error "in lazyResidueClass$NSUP: division by 0" + ground? y => + error "in lazyResidueClass$NSUP: ground? #2" yy := rep y; co := yy.first.c; xx: Rep := rep x empty? xx => [x, co, 0] pow: NNI := 0; e := yy.first.k; y := per(yy.rest); @@ -64729,11 +64844,11 @@ NewSparseUnivariatePolynomial(R): Exports == Implementation where [per xx, co, pow] lazyPseudoRemainder(x,y) == - zero? y => - error "in lazyPseudoRemainder$NSUP: division by 0" - ground? y => - error "in lazyPseudoRemainder$NSUP: ground? #2" - ground? x => x + zero? y => + error "in lazyPseudoRemainder$NSUP: division by 0" + ground? y => + error "in lazyPseudoRemainder$NSUP: ground? #2" + ground? x => x yy := rep y; co := yy.first.c -- one? co => monicModulo(x,y) (co = 1) => monicModulo(x,y) @@ -64746,13 +64861,13 @@ NewSparseUnivariatePolynomial(R): Exports == Implementation where per xx lazyPseudoDivide(x,y) == - zero? y => - error "in lazyPseudoDivide$NSUP: division by 0" - ground? y => - error "in lazyPseudoDivide$NSUP: ground? #2" + zero? y => + error "in lazyPseudoDivide$NSUP: division by 0" + ground? y => + error "in lazyPseudoDivide$NSUP: ground? #2" yy := rep y; e := yy.first.k; xx: Rep := rep x; co := yy.first.c - (empty? xx) or (xx.first.k < e) => [co,0,0,x] + (empty? xx) or (xx.first.k < e) => [co,0,0,x] pow: NNI := subtractIfCan(xx.first.k,e)::NNI + 1 qq: Rep := []; y := per(yy.rest) repeat @@ -64764,12 +64879,12 @@ NewSparseUnivariatePolynomial(R): Exports == Implementation where [co, pow, per reverse qq, per xx] lazyPseudoQuotient(x,y) == - zero? y => - error "in lazyPseudoQuotient$NSUP: division by 0" - ground? y => - error "in lazyPseudoQuotient$NSUP: ground? #2" + zero? y => + error "in lazyPseudoQuotient$NSUP: division by 0" + ground? y => + error "in lazyPseudoQuotient$NSUP: ground? #2" yy := rep y; e := yy.first.k; xx: Rep := rep x - (empty? xx) or (xx.first.k < e) => 0 + (empty? xx) or (xx.first.k < e) => 0 qq: Rep := []; co := yy.first.c; y := per(yy.rest) repeat if (u:=subtractIfCan(xx.first.k,e)) case "failed" then break @@ -64815,13 +64930,13 @@ NewSparseUnivariatePolynomial(R): Exports == Implementation where [re.gcd, re.coef2] pseudoDivide(x,y) == - zero? y => - error "in pseudoDivide$NSUP: division by 0" - ground? y => - error "in pseudoDivide$NSUP: ground? #2" + zero? y => + error "in pseudoDivide$NSUP: division by 0" + ground? y => + error "in pseudoDivide$NSUP: ground? #2" yy := rep y; e := yy.first.k xx: Rep := rep x; co := yy.first.c - (empty? xx) or (xx.first.k < e) => [co,0,x] + (empty? xx) or (xx.first.k < e) => [co,0,x] pow: NNI := subtractIfCan(xx.first.k,e)::NNI + 1 qq: Rep := []; y := per(yy.rest) repeat @@ -64837,12 +64952,12 @@ NewSparseUnivariatePolynomial(R): Exports == Implementation where [co, q, x] pseudoQuotient(x,y) == - zero? y => - error "in pseudoDivide$NSUP: division by 0" - ground? y => - error "in pseudoDivide$NSUP: ground? #2" + zero? y => + error "in pseudoDivide$NSUP: division by 0" + ground? y => + error "in pseudoDivide$NSUP: ground? #2" yy := rep y; e := yy.first.k; xx: Rep := rep x - (empty? xx) or (xx.first.k < e) => 0 + (empty? xx) or (xx.first.k < e) => 0 pow: NNI := subtractIfCan(xx.first.k,e)::NNI + 1 qq: Rep := []; co := yy.first.c; y := per(yy.rest) repeat @@ -64945,7 +65060,7 @@ o )show None <>= )abbrev domain NONE None -++ Author: +++ Author: Mark Botch ++ Date Created: ++ Change History: ++ Basic Functions: coerce @@ -64954,10 +65069,9 @@ o )show None ++ AMS Classification: ++ Keywords: none, empty ++ Description: -++ \spadtype{None} implements a type with no objects. It is mainly -++ used in technical situations where such a thing is needed (e.g. -++ the interpreter and some of the internal \spadtype{Expression} -++ code). +++ \spadtype{None} implements a type with no objects. It is mainly +++ used in technical situations where such a thing is needed (e.g. +++ the interpreter and some of the internal \spadtype{Expression} code). None():SetCategory == add coerce(none:%):OutputForm == "NONE" :: OutputForm @@ -65017,14 +65131,15 @@ None():SetCategory == add <>= )abbrev domain NNI NonNegativeInteger -++ Author: +++ Author: Mark Botch ++ Date Created: ++ Change History: ++ Basic Operations: ++ Related Constructors: ++ Keywords: integer -++ Description: \spadtype{NonNegativeInteger} provides functions for non -++ negative integers. +++ Description: +++ \spadtype{NonNegativeInteger} provides functions for non-negative integers. + NonNegativeInteger: Join(OrderedAbelianMonoidSup,Monoid) with _quo : (%,%) -> % ++ a quo b returns the quotient of \spad{a} and b, forgetting @@ -65045,7 +65160,8 @@ NonNegativeInteger: Join(OrderedAbelianMonoidSup,Monoid) with random : % -> % ++ random(n) returns a random integer from 0 to \spad{n-1}. commutative("*") - ++ commutative("*") means multiplication is commutative : \spad{x*y = y*x}. + ++ commutative("*") means multiplication is commutative, + ++ that is, \spad{x*y = y*x}. == SubDomain(Integer,#1 >= 0) add x,y:% @@ -65231,6 +65347,10 @@ o )show UnivariateFormalPowerSeries <>= )abbrev domain NOTTING NottinghamGroup +++ Author: Mark Botch +++ Description: +++ This is an implmenentation of the Nottingham Group + NottinghamGroup(F:FiniteFieldCategory): Group with retract: UnivariateFormalPowerSeries F -> % == add @@ -65286,41 +65406,41 @@ NottinghamGroup(F:FiniteFieldCategory): Group with ++ The representation is a Union of two record types - one for integration of ++ a function of one variable: ++ -++ \axiomType{Record}(var:\axiomType{Symbol}, -++ fn:\axiomType{Expression DoubleFloat}, -++ range:\axiomType{Segment OrderedCompletion DoubleFloat}, -++ abserr:\axiomType{DoubleFloat}, +++ \axiomType{Record}(var:\axiomType{Symbol},\br +++ fn:\axiomType{Expression DoubleFloat},\br +++ range:\axiomType{Segment OrderedCompletion DoubleFloat},\br +++ abserr:\axiomType{DoubleFloat},\br ++ relerr:\axiomType{DoubleFloat},) ++ ++ and one for multivariate integration: ++ -++ \axiomType{Record}(fn:\axiomType{Expression DoubleFloat}, -++ range:\axiomType{List Segment OrderedCompletion DoubleFloat}, -++ abserr:\axiomType{DoubleFloat}, +++ \axiomType{Record}(fn:\axiomType{Expression DoubleFloat},\br +++ range:\axiomType{List Segment OrderedCompletion DoubleFloat},\br +++ abserr:\axiomType{DoubleFloat},\br ++ relerr:\axiomType{DoubleFloat},). ++ - -EDFA ==> Expression DoubleFloat -SOCDFA ==> Segment OrderedCompletion DoubleFloat -DFA ==> DoubleFloat -NIAA ==> Record(var:Symbol,fn:EDFA,range:SOCDFA,abserr:DFA,relerr:DFA) -MDNIAA ==> Record(fn:EDFA,range:List SOCDFA,abserr:DFA,relerr:DFA) -NumericalIntegrationProblem():SetCategory with +NumericalIntegrationProblem(): EE == II where + + EDFA ==> Expression DoubleFloat + SOCDFA ==> Segment OrderedCompletion DoubleFloat + DFA ==> DoubleFloat + NIAA ==> Record(var:Symbol,fn:EDFA,range:SOCDFA,abserr:DFA,relerr:DFA) + MDNIAA ==> Record(fn:EDFA,range:List SOCDFA,abserr:DFA,relerr:DFA) + + EE ==> SetCategory with coerce: NIAA -> % - ++ coerce(x) \undocumented{} + ++ coerce(x) is not documented coerce: MDNIAA -> % - ++ coerce(x) \undocumented{} + ++ coerce(x) is not documented coerce: Union(nia:NIAA,mdnia:MDNIAA) -> % - ++ coerce(x) \undocumented{} + ++ coerce(x) is not documented coerce: % -> OutputForm - ++ coerce(x) \undocumented{} + ++ coerce(x) is not documented retract: % -> Union(nia:NIAA,mdnia:MDNIAA) - ++ retract(x) \undocumented{} + ++ retract(x) is not documented - == - - add + II ==> add Rep := Union(nia:NIAA,mdnia:MDNIAA) coerce(s:NIAA) == [s] @@ -65371,31 +65491,31 @@ NumericalIntegrationProblem():SetCategory with ++ ++ The representation is of type: ++ -++ \axiomType{Record}(xinit:\axiomType{DoubleFloat}, -++ xend:\axiomType{DoubleFloat}, -++ fn:\axiomType{Vector Expression DoubleFloat}, -++ yinit:\axiomType{List DoubleFloat},intvals:\axiomType{List DoubleFloat}, -++ g:\axiomType{Expression DoubleFloat},abserr:\axiomType{DoubleFloat}, +++ \axiomType{Record}(xinit:\axiomType{DoubleFloat},\br +++ xend:\axiomType{DoubleFloat},\br +++ fn:\axiomType{Vector Expression DoubleFloat},\br +++ yinit:\axiomType{List DoubleFloat},intvals:\axiomType{List DoubleFloat},\br +++ g:\axiomType{Expression DoubleFloat},abserr:\axiomType{DoubleFloat},\br ++ relerr:\axiomType{DoubleFloat}) ++ -DFB ==> DoubleFloat -VEDFB ==> Vector Expression DoubleFloat -LDFB ==> List DoubleFloat -EDFB ==> Expression DoubleFloat -ODEAB ==> Record(xinit:DFB,xend:DFB,fn:VEDFB,yinit:LDFB,intvals:LDFB,g:EDFB,abserr:DFB,relerr:DFB) -NumericalODEProblem():SetCategory with +NumericalODEProblem(): EE == II where + DFB ==> DoubleFloat + VEDFB ==> Vector Expression DoubleFloat + LDFB ==> List DoubleFloat + EDFB ==> Expression DoubleFloat + ODEAB ==> Record(xinit:DFB,xend:DFB,fn:VEDFB,yinit:LDFB,intvals:LDFB,g:EDFB,abserr:DFB,relerr:DFB) + + EE ==> SetCategory with coerce: ODEAB -> % - ++ coerce(x) \undocumented{} + ++ coerce(x) is not documented coerce: % -> OutputForm - ++ coerce(x) \undocumented{} + ++ coerce(x) is not documented retract: % -> ODEAB - ++ retract(x) \undocumented{} + ++ retract(x) is not documented - == - - add + II ==> add Rep := ODEAB coerce(s:ODEAB) == s @@ -65442,43 +65562,42 @@ NumericalODEProblem():SetCategory with ++ The representation is a Union of two record types - one for otimization of ++ a single function of one or more variables: ++ -++ \axiomType{Record}( -++ fn:\axiomType{Expression DoubleFloat}, -++ init:\axiomType{List DoubleFloat}, -++ lb:\axiomType{List OrderedCompletion DoubleFloat}, -++ cf:\axiomType{List Expression DoubleFloat}, +++ \axiomType{Record}(\br +++ fn:\axiomType{Expression DoubleFloat},\br +++ init:\axiomType{List DoubleFloat},\br +++ lb:\axiomType{List OrderedCompletion DoubleFloat},\br +++ cf:\axiomType{List Expression DoubleFloat},\br ++ ub:\axiomType{List OrderedCompletion DoubleFloat}) ++ ++ and one for least-squares problems i.e. optimization of a set of ++ observations of a data set: ++ -++ \axiomType{Record}(lfn:\axiomType{List Expression DoubleFloat}, +++ \axiomType{Record}(lfn:\axiomType{List Expression DoubleFloat},\br ++ init:\axiomType{List DoubleFloat}). -++ -LDFD ==> List DoubleFloat -LEDFD ==> List Expression DoubleFloat -LSAD ==> Record(lfn:LEDFD, init:LDFD) -UNOALSAD ==> Union(noa:NOAD,lsa:LSAD) -EDFD ==> Expression DoubleFloat -LOCDFD ==> List OrderedCompletion DoubleFloat -NOAD ==> Record(fn:EDFD, init:LDFD, lb:LOCDFD, cf:LEDFD, ub:LOCDFD) -NumericalOptimizationProblem():SetCategory with +NumericalOptimizationProblem(): EE == II where + + LDFD ==> List DoubleFloat + LEDFD ==> List Expression DoubleFloat + LSAD ==> Record(lfn:LEDFD, init:LDFD) + UNOALSAD ==> Union(noa:NOAD,lsa:LSAD) + EDFD ==> Expression DoubleFloat + LOCDFD ==> List OrderedCompletion DoubleFloat + NOAD ==> Record(fn:EDFD, init:LDFD, lb:LOCDFD, cf:LEDFD, ub:LOCDFD) + EE ==> SetCategory with coerce: NOAD -> % - ++ coerce(x) \undocumented{} + ++ coerce(x) is not documented coerce: LSAD -> % - ++ coerce(x) \undocumented{} + ++ coerce(x) is not documented coerce: UNOALSAD -> % - ++ coerce(x) \undocumented{} + ++ coerce(x) is not documented coerce: % -> OutputForm - ++ coerce(x) \undocumented{} + ++ coerce(x) is not documented retract: % -> UNOALSAD - ++ retract(x) \undocumented{} + ++ retract(x) is not documented - == - - add + II ==> add Rep := UNOALSAD coerce(s:NOAD) == [s] @@ -65529,43 +65648,42 @@ NumericalOptimizationProblem():SetCategory with ++ ++ The representation is of type: ++ -++ \axiomType{Record}(pde:\axiomType{List Expression DoubleFloat}, -++ constraints:\axiomType{List PDEC}, -++ f:\axiomType{List List Expression DoubleFloat}, -++ st:\axiomType{String}, +++ \axiomType{Record}(pde:\axiomType{List Expression DoubleFloat}, \br +++ constraints:\axiomType{List PDEC}, \br +++ f:\axiomType{List List Expression DoubleFloat},\br +++ st:\axiomType{String},\br ++ tol:\axiomType{DoubleFloat}) ++ ++ where \axiomType{PDEC} is of type: ++ -++ \axiomType{Record}(start:\axiomType{DoubleFloat}, -++ finish:\axiomType{DoubleFloat}, -++ grid:\axiomType{NonNegativeInteger}, -++ boundaryType:\axiomType{Integer}, -++ dStart:\axiomType{Matrix DoubleFloat}, +++ \axiomType{Record}(start:\axiomType{DoubleFloat}, \br +++ finish:\axiomType{DoubleFloat},\br +++ grid:\axiomType{NonNegativeInteger},\br +++ boundaryType:\axiomType{Integer},\br +++ dStart:\axiomType{Matrix DoubleFloat}, \br ++ dFinish:\axiomType{Matrix DoubleFloat}) -++ -DFC ==> DoubleFloat -NNIC ==> NonNegativeInteger -INTC ==> Integer -MDFC ==> Matrix DoubleFloat -PDECC ==> Record(start:DFC, finish:DFC, grid:NNIC, boundaryType:INTC, +NumericalPDEProblem(): EE == II where + + DFC ==> DoubleFloat + NNIC ==> NonNegativeInteger + INTC ==> Integer + MDFC ==> Matrix DoubleFloat + PDECC ==> Record(start:DFC, finish:DFC, grid:NNIC, boundaryType:INTC, dStart:MDFC, dFinish:MDFC) -LEDFC ==> List Expression DoubleFloat -PDEBC ==> Record(pde:LEDFC, constraints:List PDECC, f:List LEDFC, + LEDFC ==> List Expression DoubleFloat + PDEBC ==> Record(pde:LEDFC, constraints:List PDECC, f:List LEDFC, st:String, tol:DFC) -NumericalPDEProblem():SetCategory with + EE ==> SetCategory with coerce: PDEBC -> % - ++ coerce(x) \undocumented{} + ++ coerce(x) is not documented coerce: % -> OutputForm - ++ coerce(x) \undocumented{} + ++ coerce(x) is not documented retract: % -> PDEBC - ++ retract(x) \undocumented{} + ++ retract(x) is not documented - == - - add + II ==> add Rep := PDEBC coerce(s:PDEBC) == s @@ -65940,15 +66058,15 @@ o )show Octonion ++ Hypercomplex Numbers, Springer Verlag Heidelberg, 1989, ++ ISBN 0-387-96980-2 ++ Description: -++ 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 i imaginary part, the j -++ imaginary part, the k imaginary part, (as with quaternions) -++ and in addition the imaginary parts E, I, J, K. --- Examples: octonion.input +++ 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 octon which takes 8 +++ arguments: the real part, the i imaginary part, the j +++ imaginary part, the k imaginary part, (as with quaternions) +++ and in addition the imaginary parts E, I, J, K. + --)boot $noSubsumption := true Octonion(R:CommutativeRing): export == impl where @@ -65957,7 +66075,7 @@ Octonion(R:CommutativeRing): export == impl where export ==> Join(OctonionCategory R, FullyRetractableTo QR) with octon: (QR,QR) -> % ++ octon(qe,qE) constructs an octonion from two quaternions - ++ using the relation {\em O = Q + QE}. + ++ using the relation O = Q + QE. impl ==> add Rep := Record(e: QR,E: QR) @@ -66024,30 +66142,30 @@ Octonion(R:CommutativeRing): export == impl where ++ functions to store details found out about sets of ODE's. ODEIntensityFunctionsTable(): E == I where - LEDF ==> List Expression DoubleFloat - LEEDF ==> List Equation Expression DoubleFloat - EEDF ==> Equation Expression DoubleFloat - VEDF ==> Vector Expression DoubleFloat - MEDF ==> Matrix Expression DoubleFloat - MDF ==> Matrix DoubleFloat - EDF ==> Expression DoubleFloat - DF ==> DoubleFloat - F ==> Float - INT ==> Integer - CDF ==> Complex DoubleFloat - LDF ==> List DoubleFloat - LF ==> List Float - S ==> Symbol - LS ==> List Symbol - MFI ==> Matrix Fraction Integer - LFI ==> List Fraction Integer - FI ==> Fraction Integer - ODEA ==> Record(xinit:DF,xend:DF,fn:VEDF,yinit:LDF,intvals:LDF,g:EDF,abserr:DF,relerr:DF) - ON ==> Record(additions:INT,multiplications:INT,exponentiations:INT,functionCalls:INT) - RVE ==> Record(val:EDF,exponent:INT) - RSS ==> Record(stiffnessFactor:F,stabilityFactor:F) - ATT ==> Record(stiffness:F,stability:F,expense:F,accuracy:F,intermediateResults:F) - ROA ==> Record(key:ODEA,entry:ATT) + LEDF ==> List Expression DoubleFloat + LEEDF ==> List Equation Expression DoubleFloat + EEDF ==> Equation Expression DoubleFloat + VEDF ==> Vector Expression DoubleFloat + MEDF ==> Matrix Expression DoubleFloat + MDF ==> Matrix DoubleFloat + EDF ==> Expression DoubleFloat + DF ==> DoubleFloat + F ==> Float + INT ==> Integer + CDF ==> Complex DoubleFloat + LDF ==> List DoubleFloat + LF ==> List Float + S ==> Symbol + LS ==> List Symbol + MFI ==> Matrix Fraction Integer + LFI ==> List Fraction Integer + FI ==> Fraction Integer + ODEA ==> Record(xinit:DF,xend:DF,fn:VEDF,yinit:LDF,intvals:LDF,g:EDF,abserr:DF,relerr:DF) + ON ==> Record(additions:INT,multiplications:INT,exponentiations:INT,functionCalls:INT) + RVE ==> Record(val:EDF,exponent:INT) + RSS ==> Record(stiffnessFactor:F,stabilityFactor:F) + ATT ==> Record(stiffness:F,stability:F,expense:F,accuracy:F,intermediateResults:F) + ROA ==> Record(key:ODEA,entry:ATT) E ==> with showTheIFTable:() -> $ @@ -66333,6 +66451,8 @@ o )show OneDimensionalArray <>= )abbrev domain ARRAY1 OneDimensionalArray +++ Author: Mark Botch +++ Description: ++ This is the domain of 1-based one dimensional arrays OneDimensionalArray(S:Type): Exports == Implementation where @@ -66415,11 +66535,13 @@ OneDimensionalArray(S:Type): Exports == Implementation where <>= )abbrev domain ONECOMP OnePointCompletion -++ Completion with infinity ++ Author: Manuel Bronstein -++ Description: Adjunction of a complex infinity to a set. ++ Date Created: 4 Oct 1989 ++ Date Last Updated: 1 Nov 1989 +++ Description: +++ Completion with infinity. +++ Adjunction of a complex infinity to a set. + OnePointCompletion(R:SetCategory): Exports == Implementation where B ==> Boolean @@ -66551,10 +66673,10 @@ OnePointCompletion(R:SetCategory): Exports == Implementation where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: \spadtype{OpenMathConnection} provides low-level functions +++ Description: +++ \spadtype{OpenMathConnection} provides low-level functions ++ for handling connections to and from \spadtype{OpenMathDevice}s. - OpenMathConnection(): with OMmakeConn : SingleInteger -> % ++ \spad{OMmakeConn} OMcloseConn : % -> Void ++ \spad{OMcloseConn} @@ -66649,11 +66771,11 @@ OpenMathConnection(): with ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: \spadtype{OpenMathDevice} provides support for reading +++ Description: +++ \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. - OpenMathDevice(): with OMopenFile : (String, String, OpenMathEncoding) -> % ++ OMopenFile(f,mode,enc) opens file \axiom{f} for reading or writing @@ -66844,6 +66966,7 @@ OpenMathDevice(): with ++ References: ++ Description: ++ \spadtype{OpenMathEncoding} is the set of valid OpenMath encodings. + OpenMathEncoding(): SetCategory with OMencodingUnknown : () -> % ++ OMencodingUnknown() is the constant for unknown encoding types. If this @@ -66913,7 +67036,9 @@ OpenMathEncoding(): SetCategory with ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: \spadtype{OpenMathError} is the domain of OpenMath errors. +++ Description: +++ \spadtype{OpenMathError} is the domain of OpenMath errors. + OpenMathError() : SetCategory with errorKind : % -> OpenMathErrorKind ++ errorKind(u) returns the type of error which u represents. @@ -66984,9 +67109,11 @@ OpenMathError() : SetCategory with ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: \spadtype{OpenMathErrorKind} represents different kinds +++ Description: +++ \spadtype{OpenMathErrorKind} represents different kinds ++ of OpenMath errors: specifically parse errors, unknown CD or symbol ++ errors, and read errors. + OpenMathErrorKind() : SetCategory with coerce : Symbol -> % ++ coerce(u) creates an OpenMath error object of an appropriate type if @@ -67461,6 +67588,7 @@ o )show Operator ++ Date Last Updated: 12 February 1993 ++ Description: ++ Algebra of ADDITIVE operators over a ring. + Operator(R: Ring) == ModuleOperator(R,R) @ @@ -67525,10 +67653,10 @@ Operator(R: Ring) == ModuleOperator(R,R) ++ Examples: ++ References: ++ Description: -++ This constructor creates the \spadtype{MonogenicLinearOperator} domain -++ which is ``opposite'' in the ring sense to P. -++ That is, as sets \spad{P = $} but \spad{a * b} in \spad{$} is equal to -++ \spad{b * a} in P. +++ This constructor creates the \spadtype{MonogenicLinearOperator} domain +++ which is ``opposite'' in the ring sense to P. +++ That is, as sets \spad{P = $} but \spad{a * b} in \spad{$} is equal to +++ \spad{b * a} in P. OppositeMonogenicLinearOperator(P, R): OPRcat == OPRdef where P: MonogenicLinearOperator(R) @@ -67607,11 +67735,13 @@ OppositeMonogenicLinearOperator(P, R): OPRcat == OPRdef where <>= )abbrev domain ORDCOMP OrderedCompletion -++ Completion with + and - infinity ++ Author: Manuel Bronstein -++ Description: Adjunction of two real infinites quantities to a set. ++ Date Created: 4 Oct 1989 ++ Date Last Updated: 1 Nov 1989 +++ Description: +++ Completion with + and - infinity. +++ Adjunction of two real infinites quantities to a set. + OrderedCompletion(R:SetCategory): Exports == Implementation where B ==> Boolean @@ -67833,7 +67963,7 @@ OrderedCompletion(R:SetCategory): Exports == Implementation where -- without subsumption, set SourceLevelSubset to EQUAL --)bo $noSubsumption := true -++ Author: +++ Author: Mark Botch ++ Date Created: ++ Date Last Updated: ++ Basic Functions: @@ -67843,7 +67973,7 @@ OrderedCompletion(R:SetCategory): Exports == Implementation where ++ Keywords: ++ References: ++ Description: -++ This type represents the finite direct or cartesian product of an +++ 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 @@ -68448,7 +68578,7 @@ o )show OrderedFreeMonoid ++ Keywords: ++ References: ++ Description: -++ The free monoid on a set \spad{S} is the monoid of finite products of +++ The free monoid on a set \spad{S} is the monoid of finite products of ++ the form \spad{reduce(*,[si ** ni])} where the si's are in S, and the ni's ++ are non-negative integers. The multiplication is not commutative. ++ For two elements \spad{x} and \spad{y} the relation \spad{x < y} @@ -68456,7 +68586,6 @@ o )show OrderedFreeMonoid ++ are equal and if \spad{x} is smaller than \spad{y} w.r.t. the ++ lexicographical ordering induced by \spad{S}. ++ This domain inherits implementation from \spadtype{FreeMonoid}. -++ Author: Michel Petitot (petitot@lifl.fr) OrderedFreeMonoid(S: OrderedSet): OFMcategory == OFMdefinition where NNI ==> NonNegativeInteger @@ -68798,13 +68927,15 @@ o )show OrderedVariableList <>= )abbrev domain OVAR OrderedVariableList +++ Author: Mark Botch ++ Description: ++ This domain implements ordered variables + OrderedVariableList(VariableList:List Symbol): Join(OrderedFinite, ConvertibleTo Symbol, ConvertibleTo InputForm, ConvertibleTo Pattern Float, ConvertibleTo Pattern Integer) with variable: Symbol -> Union(%,"failed") - ++ variable(s) returns a member of the variable set or failed + ++ variable(s) returns a member of the variable set or failed == add VariableList := removeDuplicates VariableList Rep := PositiveInteger @@ -69604,12 +69735,11 @@ o )show OrderlyDifferentialPolynomial ++ References:Kolchin, E.R. "Differential Algebra and Algebraic Groups" ++ (Academic Press, 1973). ++ Description: -++ \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}. -++ +++ \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}. OrderlyDifferentialPolynomial(R): Exports == Implementation where @@ -69676,17 +69806,17 @@ OrderlyDifferentialPolynomial(R): ++ References:Kolchin, E.R. "Differential Algebra and Algebraic Groups" ++ (Academic Press, 1973). ++ Description: -++ \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 u and v, -++ u \spadfun{<} v if the \spadfun{order} of u is less than that -++ of 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 u via the -++ lexicographic order on the pair -++ (\spadfun{order}(u), \spadfun{variable}(u)). +++ \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 u and v, +++ u \spadfun{<} v if the \spadfun{order} of u is less than that of 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 u via the +++ lexicographic order on the pair +++ (\spadfun{order}(u), \spadfun{variable}(u)). + OrderlyDifferentialVariable(S:OrderedSet):DifferentialVariableCategory(S) == add Rep := Record(var:S, ord:NonNegativeInteger) @@ -69773,8 +69903,8 @@ OrderlyDifferentialVariable(S:OrderedSet):DifferentialVariableCategory(S) ++ Examples: ++ References: ++ Description: -++ This constructor produces an ordinary differential ring from -++ a partial differential ring by specifying a variable. +++ This constructor produces an ordinary differential ring from +++ a partial differential ring by specifying a variable. OrdinaryDifferentialRing(Kernels,R,var): DRcategory == DRcapsule where Kernels:SetCategory @@ -69859,16 +69989,17 @@ OrdinaryWeightedPolynomials(R:Ring, Ring with if R has CommutativeRing then Algebra(R) coerce: $ -> Polynomial(R) - ++ coerce(p) converts back into a Polynomial(R), ignoring weights + ++ coerce(p) converts back into a Polynomial(R), ignoring weights coerce: Polynomial(R) -> $ - ++ coerce(p) coerces a Polynomial(R) into Weighted form, - ++ applying weights and ignoring terms + ++ coerce(p) coerces a Polynomial(R) into Weighted form, + ++ applying weights and ignoring terms if R has Field then "/": ($,$) -> Union($,"failed") - ++ x/y division (only works if minimum weight - ++ of divisor is zero, and if R is a Field) + ++ x/y division (only works if minimum weight + ++ of divisor is zero, and if R is a Field) changeWeightLevel: NonNegativeInteger -> Void - ++ changeWeightLevel(n) This changes the weight level to the new value given: - ++ NB: previously calculated terms are not affected + ++ changeWeightLevel(n) This changes the weight level to the + ++ new value given: + ++ NB: previously calculated terms are not affected == WeightedPolynomials(R,Symbol,IndexedExponents(Symbol), Polynomial(R), vl,wl,wtlevel) @@ -69906,12 +70037,14 @@ OrdinaryWeightedPolynomials(R:Ring, <>= )abbrev domain OSI OrdSetInts -++ Author : Larry Lambe -++ Date created : 14 August 1988 -++ Date Last Updated : 11 March 1991 -++ Description : A domain used in order to take the free R-module on the -++ Integers I. This is actually the forgetful functor from OrderedRings -++ to OrderedSets applied to I +++ Author: Larry Lambe +++ Date created: 14 August 1988 +++ Date Last Updated: 11 March 1991 +++ Description: +++ A domain used in order to take the free R-module on the +++ Integers I. This is actually the forgetful functor from OrderedRings +++ to OrderedSets applied to I + OrdSetInts: Export == Implement where I ==> Integer L ==> List @@ -69919,9 +70052,9 @@ OrdSetInts: Export == Implement where Export == OrderedSet with coerce : Integer -> % - ++ coerce(i) returns the element corresponding to i + ++ coerce(i) returns the element corresponding to i value : % -> I - ++ value(x) returns the integer associated with x + ++ value(x) returns the integer associated with x Implement == add Rep := Integer @@ -70571,8 +70704,9 @@ OutputForm(): SetCategory with ++ Examples: ++ References: ++ Description: -++ Stream-based implementation of Zp: p-adic numbers are represented as -++ sum(i = 0.., a[i] * p^i), where the a[i] lie in 0,1,...,(p - 1). +++ Stream-based implementation of Zp: p-adic numbers are represented as +++ sum(i = 0.., a[i] * p^i), where the a[i] lie in 0,1,...,(p - 1). + PAdicInteger(p:Integer) == InnerPAdicInteger(p,true$Boolean) @ @@ -70693,8 +70827,9 @@ PAdicInteger(p:Integer) == InnerPAdicInteger(p,true$Boolean) ++ Examples: ++ References: ++ Description: -++ Stream-based implementation of Qp: numbers are represented as -++ sum(i = k.., a[i] * p^i) where the a[i] lie in 0,1,...,(p - 1). +++ Stream-based implementation of Qp: numbers are represented as +++ sum(i = k.., a[i] * p^i) where the a[i] lie in 0,1,...,(p - 1). + PAdicRational(p:Integer) == PAdicRationalConstructor(p,PAdicInteger p) @ @@ -70815,7 +70950,9 @@ PAdicRational(p:Integer) == PAdicRationalConstructor(p,PAdicInteger p) ++ Keywords: p-adic, completion ++ Examples: ++ References: -++ Description: This is the category of stream-based representations of Qp. +++ Description: +++ This is the category of stream-based representations of Qp. + PAdicRationalConstructor(p,PADIC): Exports == Implementation where p : Integer PADIC : PAdicIntegerCategory p @@ -71024,7 +71161,8 @@ PAdicRationalConstructor(p,PADIC): Exports == Implementation where ++ AMS Classifications: ++ Keywords: dim,bright,pastel,coerce ++ References: -++ Description: This domain describes four groups of color shades (palettes). +++ Description: +++ This domain describes four groups of color shades (palettes). Palette(): Exports == Implementation where I ==> Integer @@ -71100,7 +71238,8 @@ Palette(): Exports == Implementation where ++ AMS Classifications: ++ Keywords: parametric curve, graphics ++ References: -++ Description: ParametricPlaneCurve is used for plotting parametric plane +++ Description: +++ ParametricPlaneCurve is used for plotting parametric plane ++ curves in the affine plane. ParametricPlaneCurve(ComponentFunction): Exports == Implementation where @@ -71158,7 +71297,8 @@ ParametricPlaneCurve(ComponentFunction): Exports == Implementation where ++ AMS Classifications: ++ Keywords: parametric curve, graphics ++ References: -++ Description: ParametricSpaceCurve is used for plotting parametric space +++ Description: +++ ParametricSpaceCurve is used for plotting parametric space ++ curves in affine 3-space. ParametricSpaceCurve(ComponentFunction): Exports == Implementation where @@ -71219,7 +71359,8 @@ ParametricSpaceCurve(ComponentFunction): Exports == Implementation where ++ AMS Classifications: ++ Keywords: parametric surface, graphics ++ References: -++ Description: ParametricSurface is used for plotting parametric surfaces in +++ Description: +++ ParametricSurface is used for plotting parametric surfaces in ++ affine 3-space. ParametricSurface(ComponentFunction): Exports == Implementation where @@ -71717,18 +71858,18 @@ o )show PartialFraction ++ Keywords: partial fraction, factorization, euclidean domain ++ References: ++ Description: -++ 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 -++ ``compact'' form has only one fractional term per prime in the -++ denominator, while the ``p-adic'' form expands each numerator -++ p-adically via the prime p in the denominator. For computational -++ efficiency, the compact form is used, though the p-adic form may -++ be gotten by calling the function \spadfunFrom{padicFraction}{PartialFraction}. For a -++ general euclidean domain, it is not known how to factor the -++ denominator. Thus the function \spadfunFrom{partialFraction}{PartialFraction} takes as its -++ second argument an element of \spadtype{Factored(R)}. +++ 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 +++ ``compact'' form has only one fractional term per prime in the +++ denominator, while the ``p-adic'' form expands each numerator +++ p-adically via the prime p in the denominator. For computational +++ efficiency, the compact form is used, though the p-adic form may +++ be gotten by calling the function padicFraction}. For a +++ general euclidean domain, it is not known how to factor the +++ denominator. Thus the function partialFraction takes as its +++ second argument an element of \spadtype{Factored(R)}. PartialFraction(R: EuclideanDomain): Cat == Capsule where FRR ==> Factored R @@ -71764,7 +71905,7 @@ PartialFraction(R: EuclideanDomain): Cat == Capsule where firstDenom: % -> FRR ++ firstDenom(p) extracts the denominator of the first fractional ++ term. This returns 1 if there is no fractional part (use - ++ \spadfunFrom{wholePart}{PartialFraction} to get the whole part). + ++ wholePart from PartialFraction to get the whole part). ++ ++X a:=partialFraction(1,factorial 10) ++X firstDenom(a) @@ -71772,7 +71913,7 @@ PartialFraction(R: EuclideanDomain): Cat == Capsule where firstNumer: % -> R ++ firstNumer(p) extracts the numerator of the first fractional ++ term. This returns 0 if there is no fractional part (use - ++ \spadfunFrom{wholePart}{PartialFraction} to get the whole part). + ++ wholePart from PartialFraction to get the whole part). ++ ++X a:=partialFraction(1,factorial 10) ++X firstNumer(a) @@ -71804,7 +71945,7 @@ PartialFraction(R: EuclideanDomain): Cat == Capsule where ++ padicFraction(q) expands the fraction p-adically in the primes ++ \spad{p} in the denominator of \spad{q}. For example, ++ \spad{padicFraction(3/(2**2)) = 1/2 + 1/(2**2)}. - ++ Use \spadfunFrom{compactFraction}{PartialFraction} to + ++ Use compactFraction from PartialFraction to ++ return to compact form. ++ ++X a:=partialFraction(1,factorial 10) @@ -72106,18 +72247,20 @@ PartialFraction(R: EuclideanDomain): Cat == Capsule where <>= )abbrev domain PRTITION Partition -++ Domain for partitions of positive integers ++ Author: William H. Burge ++ Date Created: 29 October 1987 ++ Date Last Updated: 23 Sept 1991 ++ Keywords: ++ Examples: ++ References: +++ Description: +++ Domain for partitions of positive integers +++ 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}. + Partition: Exports == Implementation where - ++ 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}. L ==> List I ==> Integer OUT ==> OutputForm @@ -72162,7 +72305,7 @@ Partition: Exports == Implementation where first x < first y x = y == - EQUAL(x,y)$Lisp + EQUAL(x,y)$Lisp -- empty? x => empty? y -- empty? y => false -- first x = first y => rest x = rest y @@ -72295,14 +72438,15 @@ Partition: Exports == Implementation where <>= )abbrev domain PATTERN Pattern -++ Patterns for use by the pattern matcher ++ Author: Manuel Bronstein ++ Date Created: 10 Nov 1988 ++ Date Last Updated: 20 June 1991 -++ Description: Patterns for use by the pattern matcher. ++ Keywords: pattern, matching. +++ Description: +++ Patterns for use by the pattern matcher. -- Not exposed. -- Patterns are optimized for quick answers to structural questions. + Pattern(R:SetCategory): Exports == Implementation where B ==> Boolean SI ==> SingleInteger @@ -72698,17 +72842,17 @@ Pattern(R:SetCategory): Exports == Implementation where <>= )abbrev domain PATLRES PatternMatchListResult -++ Result returned by the pattern matcher when using lists ++ Author: Manuel Bronstein ++ Date Created: 4 Dec 1989 ++ Date Last Updated: 4 Dec 1989 -++ Description: -++ 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. ++ Keywords: pattern, matching, list. +++ Description: +++ 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. -- not exported + PatternMatchListResult(R:SetCategory, S:SetCategory, L:ListAggregate S): SetCategory with failed? : % -> Boolean @@ -72778,17 +72922,17 @@ PatternMatchListResult(R:SetCategory, S:SetCategory, L:ListAggregate S): <>= )abbrev domain PATRES PatternMatchResult -++ Result returned by the pattern matcher ++ Author: Manuel Bronstein ++ Date Created: 28 Nov 1989 ++ Date Last Updated: 5 Jul 1990 -++ Description: -++ 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. ++ Keywords: pattern, matching. +++ Description: +++ 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. -- not exported + PatternMatchResult(R:SetCategory, S:SetCategory): SetCategory with failed? : % -> Boolean ++ failed?(r) tests if r is a failed match. @@ -72946,6 +73090,10 @@ a left and a right both PendantTree(S)'s <>= )abbrev domain PENDTREE PendantTree +++ Author: Mark Botch +++ Description: +++ This domain has no description + PendantTree(S: SetCategory): T == C where T == BinaryRecursiveAggregate(S) with ptree : S->% @@ -72954,13 +73102,13 @@ PendantTree(S: SetCategory): T == C where ++X t1:=ptree([1,2,3]) ptree:(%, %)->% - ++ ptree(x,y) \undocumented + ++ ptree(x,y) is not documented ++ ++X t1:=ptree([1,2,3]) ++X ptree(t1,ptree([1,2,3])) coerce:%->Tree S - ++ coerce(x) \undocumented + ++ coerce(x) is not documented ++ ++X t1:=ptree([1,2,3]) ++X t2:=ptree(t1,ptree([1,2,3])) @@ -73175,13 +73323,14 @@ o )show Permutation ++ Keywords: ++ Reference: G. James/A. Kerber: The Representation Theory of the Symmetric ++ Group. Encycl. of Math. and its Appl., Vol. 16., Cambridge -++ Description: Permutation(S) implements the group of all bijections -++ on a set S, which move only a finite number of points. -++ A permutation is considered as a map from S into S. In particular -++ multiplication is defined as composition of maps: -++ {\em pi1 * pi2 = pi1 o pi2}. -++ The internal representation of permuatations are two lists -++ of equal length representing preimages and images. +++ Description: +++ Permutation(S) implements the group of all bijections +++ on a set S, which move only a finite number of points. +++ A permutation is considered as a map from S into S. In particular +++ multiplication is defined as composition of maps:\br +++ pi1 * pi2 = pi1 o pi2.\br +++ The internal representation of permuatations are two lists +++ of equal length representing preimages and images. Permutation(S:SetCategory): public == private where @@ -73199,33 +73348,33 @@ Permutation(S:SetCategory): public == private where public ==> PermutationCategory S with listRepresentation: % -> RECPRIM - ++ listRepresentation(p) produces a representation {\em rep} of + ++ listRepresentation(p) produces a representation rep of ++ the permutation p as a list of preimages and images, i.e - ++ p maps {\em (rep.preimage).k} to {\em (rep.image).k} for all - ++ indices k. Elements of \spad{S} not in {\em (rep.preimage).k} + ++ p maps (rep.preimage).k to (rep.image).k for all + ++ indices k. Elements of \spad{S} not in (rep.preimage).k ++ are fixed points, and these are the only fixed points of the ++ permutation. coercePreimagesImages : List List S -> % - ++ coercePreimagesImages(lls) coerces the representation {\em lls} + ++ coercePreimagesImages(lls) coerces the representation 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. ++ ++X p := coercePreimagesImages([[1,2,3],[1,2,3]]) ++X q := coercePreimagesImages([[0,1,2,3],[3,0,2,1]])$PERM ZMOD 4 coerce : List List S -> % - ++ coerce(lls) coerces a list of cycles {\em lls} to a + ++ coerce(lls) coerces a list of cycles 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, + ++ ls.i to ls.i+1, indices modulo the length of the list, ++ then these permutations are mutiplied. ++ Error: if repetitions occur in one cycle. coerce : List S -> % - ++ coerce(ls) coerces a cycle {\em ls}, 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. + ++ coerce(ls) coerces a cycle ls, i.e. a list with not + ++ repetitions to a permutation, which maps ls.i to + ++ ls.i+1, indices modulo the length of the list. ++ Error: if repetitions occur. coerceListOfPairs : List List S -> % - ++ coerceListOfPairs(lls) coerces a list of pairs {\em lls} to a + ++ coerceListOfPairs(lls) coerces a list of pairs lls to a ++ permutation. ++ Error: if not consistent, i.e. the set of the first elements ++ coincides with the set of second elements. @@ -73252,15 +73401,15 @@ Permutation(S:SetCategory): public == private where ++ sign(p) returns the signum of the permutation p, +1 or -1. even? : % -> Boolean ++ even?(p) returns true if and only if p is an even permutation, - ++ i.e. {\em sign(p)} is 1. + ++ i.e. sign(p) is 1. ++ ++X p := coercePreimagesImages([[1,2,3],[1,2,3]]) ++X even? p odd? : % -> Boolean ++ odd?(p) returns true if and only if p is an odd permutation - ++ i.e. {\em sign(p)} is {\em -1}. + ++ i.e. sign(p) is -1. sort : L % -> L % - ++ sort(lp) sorts a list of permutations {\em lp} according to + ++ sort(lp) sorts a list of permutations lp according to ++ cycle structure first according to length of cycles, ++ second, if S has \spadtype{Finite} or S has ++ \spadtype{OrderedSet} according to lexicographical order of @@ -73272,9 +73421,9 @@ Permutation(S:SetCategory): public == private where ++X fixedPoints p if S has IntegerNumberSystem or S has Finite then coerceImages : L S -> % - ++ 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]}. + ++ coerceImages(ls) coerces the list ls to a permutation + ++ whose image is given by ls and the preimage is fixed + ++ to be [1,...,n]. ++ Note: {coerceImages(ls)=coercePreimagesImages([1,...,n],ls)}. ++ We assume that both preimage and image do not contain repetitions. @@ -73611,15 +73760,15 @@ Permutation(S:SetCategory): public == private where ++ in Computers in Algebra and Number Theory, SIAM-AMS Proc., Vol. 4, ++ Amer. Math. Soc., Providence, R. I., 1971, pp. 191-195 ++ Description: -++ PermutationGroup implements permutation groups acting -++ on a set S, i.e. all subgroups of the symmetric group of 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. +++ PermutationGroup implements permutation groups acting +++ on a set S, i.e. all subgroups of the symmetric group of 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. --++ Note: we plan to implement lattice operations on the subgroup --++ lattice in a later release @@ -73643,88 +73792,88 @@ PermutationGroup(S:SetCategory): public == private where public ==> SetCategory with coerce : % -> L PERM S - ++ coerce(gp) returns the generators of the group {\em gp}. + ++ coerce(gp) returns the generators of the group gp. generators : % -> L PERM S - ++ generators(gp) returns the generators of the group {\em gp}. + ++ generators(gp) returns the generators of the group gp. elt : (%,NNI) -> PERM S - ++ elt(gp,i) returns the i-th generator of the group {\em gp}. + ++ elt(gp,i) returns the i-th generator of the group gp. random : (%,I) -> PERM S ++ random(gp,i) returns a random product of maximal i generators - ++ of the group {\em gp}. + ++ of the group gp. random : % -> PERM S ++ random(gp) returns a random product of maximal 20 generators - ++ of the group {\em gp}. - ++ Note: {\em random(gp)=random(gp,20)}. + ++ of the group gp. + ++ Note: random(gp)=random(gp,20). order : % -> NNI - ++ order(gp) returns the order of the group {\em gp}. + ++ order(gp) returns the order of the group gp. degree : % -> NNI ++ degree(gp) returns the number of points moved by all permutations - ++ of the group {\em gp}. + ++ of the group gp. base : % -> L S - ++ base(gp) returns a base for the group {\em gp}. + ++ base(gp) returns a base for the group gp. strongGenerators : % -> L PERM S ++ strongGenerators(gp) returns strong generators for - ++ the group {\em gp}. + ++ the group gp. wordsForStrongGenerators : % -> L L NNI ++ wordsForStrongGenerators(gp) returns the words for the strong - ++ generators of the group {\em gp} in the original generators of - ++ {\em gp}, represented by their indices in the list, given by - ++ {\em generators}. + ++ generators of the group gp in the original generators of + ++ gp, represented by their indices in the list, given by + ++ generators. coerce : L PERM S -> % - ++ coerce(ls) coerces a list of permutations {\em ls} to the group + ++ coerce(ls) coerces a list of permutations ls to the group ++ generated by this list. permutationGroup : L PERM S -> % - ++ permutationGroup(ls) coerces a list of permutations {\em ls} to + ++ permutationGroup(ls) coerces a list of permutations ls to ++ the group generated by this list. orbit : (%,S) -> FSET S - ++ orbit(gp,el) returns the orbit of the element {\em el} under the - ++ group {\em gp}, i.e. the set of all points gained by applying - ++ each group element to {\em el}. + ++ orbit(gp,el) returns the orbit of the element el under the + ++ group gp, i.e. the set of all points gained by applying + ++ each group element to el. orbits : % -> FSET FSET S - ++ orbits(gp) returns the orbits of the group {\em gp}, i.e. + ++ orbits(gp) returns the orbits of the group gp, i.e. ++ it partitions the (finite) of all moved points. orbit : (%,FSET S)-> FSET FSET S ++ orbit(gp,els) returns the orbit of the unordered - ++ set {\em els} under the group {\em gp}. + ++ set els under the group gp. orbit : (%,L S) -> FSET L S ++ orbit(gp,ls) returns the orbit of the ordered - ++ list {\em ls} under the group {\em gp}. + ++ list ls under the group gp. ++ Note: return type is L L S temporarily because FSET L S has an error. -- (GILT DAS NOCH?) member? : (PERM S, %)-> B ++ member?(pp,gp) answers the question, whether the - ++ permutation {\em pp} is in the group {\em gp} or not. + ++ permutation pp is in the group gp or not. wordInStrongGenerators : (PERM S, %)-> L NNI ++ wordInStrongGenerators(p,gp) returns the word for the - ++ permutation p in the strong generators of the group {\em gp}, - ++ represented by the indices of the list, given by {\em strongGenerators}. + ++ permutation p in the strong generators of the group gp, + ++ represented by the indices of the list, given by strongGenerators. wordInGenerators : (PERM S, %)-> L NNI ++ wordInGenerators(p,gp) returns the word for the permutation p - ++ in the original generators of the group {\em gp}, - ++ represented by the indices of the list, given by {\em generators}. + ++ in the original generators of the group gp, + ++ represented by the indices of the list, given by generators. movedPoints : % -> FSET S - ++ movedPoints(gp) returns the points moved by the group {\em gp}. + ++ movedPoints(gp) returns the points moved by the group gp. "<" : (%,%) -> B - ++ gp1 < gp2 returns true if and only if {\em gp1} - ++ is a proper subgroup of {\em gp2}. + ++ gp1 < gp2 returns true if and only if gp1 + ++ is a proper subgroup of gp2. "<=" : (%,%) -> B - ++ gp1 <= gp2 returns true if and only if {\em gp1} - ++ is a subgroup of {\em gp2}. + ++ gp1 <= gp2 returns true if and only if gp1 + ++ is a subgroup of gp2. ++ Note: because of a bug in the parser you have to call this - ++ function explicitly by {\em gp1 <=$(PERMGRP S) gp2}. + ++ function explicitly by gp1 <=$(PERMGRP S) gp2. -- (GILT DAS NOCH?) initializeGroupForWordProblem : % -> Void - ++ initializeGroupForWordProblem(gp) initializes the group {\em gp} + ++ initializeGroupForWordProblem(gp) initializes the group gp ++ for the word problem. ++ Notes: it calls the other function of this name with parameters - ++ 0 and 1: {\em initializeGroupForWordProblem(gp,0,1)}. + ++ 0 and 1: initializeGroupForWordProblem(gp,0,1). ++ Notes: (1) be careful: invoking this routine will destroy the ++ possibly information about your group (but will recompute it again) ++ (2) users need not call this function normally for the soultion of ++ the word problem. initializeGroupForWordProblem :(%,I,I) -> Void ++ initializeGroupForWordProblem(gp,m,n) initializes the group - ++ {\em gp} for the word problem. + ++ gp for the word problem. ++ Notes: (1) with a small integer you get shorter words, but the ++ routine takes longer than the standard routine for longer words. ++ (2) be careful: invoking this routine will destroy the possibly stored @@ -74421,14 +74570,14 @@ PermutationGroup(S:SetCategory): public == private where <>= )abbrev domain HACKPI Pi -++ Expressions in %pi only ++ Author: Manuel Bronstein -++ Description: -++ Symbolic fractions in %pi with integer coefficients; -++ The point for using Pi as the default domain for those fractions -++ is that Pi is coercible to the float types, and not Expression. ++ Date Created: 21 Feb 1990 ++ Date Last Updated: 12 Mai 1992 +++ Description: +++ Symbolic fractions in %pi with integer coefficients; +++ The point for using Pi as the default domain for those fractions +++ is that Pi is coercible to the float types, and not Expression. + Pi(): Exports == Implementation where PZ ==> Polynomial Integer UP ==> SparseUnivariatePolynomial Integer @@ -75123,14 +75272,14 @@ listBranches(refined) <>= )abbrev domain ACPLOT PlaneAlgebraicCurvePlot ---% PlaneAlgebraicCurvePlot -++ Plot a NON-SINGULAR plane algebraic curve p(x,y) = 0. ++ Author: Clifton J. Williamson and Timothy Daly ++ Date Created: Fall 1988 ++ Date Last Updated: 27 April 1990 ++ Keywords: algebraic curve, non-singular, plot ++ Examples: ++ References: +++ Description: +++ Plot a NON-SINGULAR plane algebraic curve p(x,y) = 0. PlaneAlgebraicCurvePlot(): PlottablePlaneCurveCategory _ with @@ -75138,10 +75287,10 @@ PlaneAlgebraicCurvePlot(): PlottablePlaneCurveCategory _ makeSketch:(Polynomial Integer,Symbol,Symbol,Segment Fraction Integer,_ Segment Fraction Integer) -> % ++ makeSketch(p,x,y,a..b,c..d) creates an ACPLOT of the - ++ curve \spad{p = 0} in the region {\em a <= x <= b, c <= y <= d}. + ++ curve \spad{p = 0} in the region a <= x <= b, c <= y <= d. ++ More specifically, 'makeSketch' plots a non-singular algebraic curve - ++ \spad{p = 0} in an rectangular region {\em xMin <= x <= xMax}, - ++ {\em yMin <= y <= yMax}. The user inputs + ++ \spad{p = 0} in an rectangular region xMin <= x <= xMax, + ++ yMin <= y <= yMax. The user inputs ++ \spad{makeSketch(p,x,y,xMin..xMax,yMin..yMax)}. ++ Here p is a polynomial in the variables x and y with ++ integer coefficients (p belongs to the domain @@ -75156,7 +75305,7 @@ PlaneAlgebraicCurvePlot(): PlottablePlaneCurveCategory _ ++X makeSketch(x+y,x,y,-1/2..1/2,-1/2..1/2)$ACPLOT refine:(%,DoubleFloat) -> % - ++ refine(p,x) \undocumented{} + ++ refine(p,x) is not documented ++ ++X sketch:=makeSketch(x+y,x,y,-1/2..1/2,-1/2..1/2)$ACPLOT ++X refined:=refine(sketch,0.1) @@ -76484,12 +76633,14 @@ o )show Plot ++ AMS Classifications: ++ Keywords: plot, function, parametric ++ References: -++ Description: The Plot domain supports plotting of functions defined over a +++ Description: +++ 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. + Plot(): Exports == Implementation where B ==> Boolean F ==> DoubleFloat @@ -76564,16 +76715,16 @@ Plot(): Exports == Implementation where ++ the parametric curve \spad{x = f(t)*cos(t)}, \spad{y = f(t)*sin(t)}. plot: (%,R) -> % -- change the range - ++ plot(x,r) \undocumented + ++ plot(x,r) is not documented parametric?: % -> B ++ parametric? determines whether it is a parametric plot? zoom: (%,R) -> % - ++ zoom(x,r) \undocumented + ++ zoom(x,r) is not documented zoom: (%,R,R) -> % - ++ zoom(x,r,s) \undocumented + ++ zoom(x,r,s) is not documented refine: (%,R) -> % - ++ refine(x,r) \undocumented + ++ refine(x,r) is not documented refine: % -> % ++ refine(p) performs a refinement on the plot p @@ -76651,13 +76802,13 @@ Plot(): Exports == Implementation where listBranches plot == outList : L L P := nil() for curve in plot.functions repeat - -- curve is C - newl:L P:=nil() - for p in curve.points repeat + -- curve is C + newl:L P:=nil() + for p in curve.points repeat if not Pnan? p then newl:=cons(p,newl) else if not empty? newl then - outList := concat(newl:=reverse! newl,outList) - newl:=nil() + outList := concat(newl:=reverse! newl,outList) + newl:=nil() if not empty? newl then outList := concat(newl:=reverse! newl,outList) -- print(outList::OutputForm) outList @@ -76956,7 +77107,7 @@ Plot(): Exports == Implementation where NUMFUNEVALS := minPoints() if adaptive? then p := adaptivePlot(p,first r,second r,third r,1) - r := p.ranges + r := p.ranges [ false, rest r, r, nil(), [ p ] ] plot(f:F -> F,xRange:R,yRange:R) == @@ -76970,7 +77121,7 @@ Plot(): Exports == Implementation where NUMFUNEVALS := minPoints() if adaptive? then p := adaptivePlot(p,first r,second r,third r,8) - r := p.ranges + r := p.ranges [ true, rest r, r, nil(), [ p ] ] plot(f:F -> F,g:F -> F,tRange:R,xRange:R,yRange:R) == @@ -76984,7 +77135,7 @@ Plot(): Exports == Implementation where NUMFUNEVALS := minPoints() if adaptive? then p := adaptivePlot(p,first r,second r,third r,8) - r := p.ranges + r := p.ranges [ true, rest r, r, nil(), [ p ] ] pointPlot(f:F -> P,tRange:R,xRange:R,yRange:R) == @@ -77088,12 +77239,14 @@ Plot(): Exports == Implementation where ++ AMS Classifications: ++ Keywords: plot, parametric ++ References: -++ Description: Plot3D supports parametric plots defined over a real +++ Description: +++ 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. + Plot3D(): Exports == Implementation where B ==> Boolean F ==> DoubleFloat @@ -77113,21 +77266,21 @@ Plot3D(): Exports == Implementation where ++ pointPlot(f,g,h,a..b) plots {/emx = f(t), y = g(t), z = h(t)} as ++ t ranges over {/em[a,b]}. pointPlot: (F -> P,R,R,R,R) -> % - ++ pointPlot(f,x,y,z,w) \undocumented + ++ pointPlot(f,x,y,z,w) is not documented plot: (F -> F,F -> F,F -> F,F -> F,R) -> % ++ plot(f,g,h,a..b) plots {/emx = f(t), y = g(t), z = h(t)} as ++ t ranges over {/em[a,b]}. plot: (F -> F,F -> F,F -> F,F -> F,R,R,R,R) -> % - ++ plot(f1,f2,f3,f4,x,y,z,w) \undocumented + ++ plot(f1,f2,f3,f4,x,y,z,w) is not documented plot: (%,R) -> % -- change the range - ++ plot(x,r) \undocumented + ++ plot(x,r) is not documented zoom: (%,R,R,R) -> % - ++ zoom(x,r,s,t) \undocumented + ++ zoom(x,r,s,t) is not documented refine: (%,R) -> % - ++ refine(x,r) \undocumented + ++ refine(x,r) is not documented refine: % -> % - ++ refine(x) \undocumented + ++ refine(x) is not documented tRange: % -> R ++ tRange(p) returns the range of the parameter in a parametric plot p. @@ -77614,7 +77767,7 @@ Plot3D(): Exports == Implementation where ++ over the Poincare-Birkhoff-Witt basis. ++ See the \spadtype{XPBWPolynomial} domain constructor. ++ See Free Lie Algebras by C. Reutenauer -++ (Oxford science publications). \newline Author: Michel Petitot (petitot@lifl.fr). +++ (Oxford science publications). PoincareBirkhoffWittLyndonBasis(VarSet: OrderedSet): Public == Private where WORD ==> OrderedFreeMonoid(VarSet) @@ -77805,6 +77958,7 @@ PoincareBirkhoffWittLyndonBasis(VarSet: OrderedSet): Public == Private where <>= )abbrev domain POINT Point +++ Author: Mark Botch ++ Description: ++ This domain implements points in coordinate space @@ -78741,7 +78895,7 @@ o )show Polynomial ++ Keywords: polynomial, multivariate ++ References: ++ Description: -++ This type is the basic representation of sparse recursive multivariate +++ 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, @@ -78821,7 +78975,8 @@ Polynomial(R:Ring): ++ AMS Classifications: ++ Keywords: ++ References: GTZ -++ Description: This domain represents polynomial ideals with coefficients in any +++ Description: +++ 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 @@ -78876,26 +79031,28 @@ PolynomialIdeals(F,Expon,VarSet,DPoly) : C == T zeroDim? : Ideal -> Boolean ++ zeroDim?(I) tests if the ideal I is zero dimensional, i.e. ++ all its associated primes are maximal, - ++ in the ring \spad{F[lvar]}, where lvar are the variables appearing in I + ++ in the ring \spad{F[lvar]}, + ++ where lvar are the variables appearing in I intersect : (Ideal,Ideal) -> Ideal ++ intersect(I,J) computes the intersection of the ideals I and J. intersect : List(Ideal) -> Ideal ++ intersect(LI) computes the intersection of the list of ideals LI. quotient : (Ideal,Ideal) -> Ideal - ++ quotient(I,J) computes the quotient of the ideals I and J, \spad{(I:J)}. + ++ quotient(I,J) computes the quotient of the ideals I and J, + ++ \spad{(I:J)}. quotient : (Ideal,DPoly) -> Ideal ++ quotient(I,f) computes the quotient of the ideal I by the principal ++ ideal generated by the polynomial f, \spad{(I:(f))}. groebner : Ideal -> Ideal - ++ groebner(I) returns a set of generators of I that are a Groebner basis - ++ for I. + ++ groebner(I) returns a set of generators of I that are a + ++ Groebner basis for I. generalPosition : (Ideal,List VarSet) -> GenMPos ++ generalPosition(I,listvar) perform a random linear ++ transformation on the variables in listvar and returns ++ the transformed ideal along with the change of basis matrix. backOldPos : GenMPos -> Ideal ++ backOldPos(genPos) takes the result - ++ produced by \spadfunFrom{generalPosition}{PolynomialIdeals} + ++ produced by generalPosition from PolynomialIdeals ++ and performs the inverse transformation, returning the original ideal ++ \spad{backOldPos(generalPosition(I,listvar))} = I. dimension : (Ideal,List VarSet) -> Z @@ -78903,7 +79060,8 @@ PolynomialIdeals(F,Expon,VarSet,DPoly) : C == T ++ in the ring \spad{F[lvar]} dimension : Ideal -> Z ++ dimension(I) gives the dimension of the ideal I. - ++ in the ring \spad{F[lvar]}, where lvar are the variables appearing in I + ++ in the ring \spad{F[lvar]}, where lvar are the variables + ++ appearing in I leadingIdeal : Ideal -> Ideal ++ leadingIdeal(I) is the ideal generated by the ++ leading terms of the elements of the ideal I. @@ -78916,11 +79074,13 @@ PolynomialIdeals(F,Expon,VarSet,DPoly) : C == T ++ basis. ++ Note: this operation avoids a Groebner basis computation. groebner? : Ideal -> Boolean - ++ groebner?(I) tests if the generators of the ideal I are a Groebner basis. + ++ groebner?(I) tests if the generators of the ideal I are a + ++ Groebner basis. generators : Ideal -> List DPoly ++ generators(I) returns a list of generators for the ideal I. coerce : List DPoly -> Ideal - ++ coerce(polyList) converts the list of polynomials polyList to an ideal. + ++ coerce(polyList) converts the list of polynomials polyList + ++ to an ideal. saturate : (Ideal,DPoly) -> Ideal ++ saturate(I,f) is the saturation of the ideal I @@ -79160,54 +79320,54 @@ PolynomialIdeals(F,Expon,VarSet,DPoly) : C == T g relationsIdeal(listf : List DPoly): ST == - empty? listf => [empty(),empty()]$ST - nf:=#listf - lvint := "setUnion"/[variables g for g in listf] - vl: List Symbol := [convert vv for vv in lvint] - nvar:List Symbol:=[new() for i in 1..nf] - VarSet1:=OrderedVariableList(concat(vl,nvar)) - lv1:=[variable(vv)$VarSet1::VarSet1 for vv in nvar] - DirP:=DirectProduct(nf,NNI) - nExponent:=Product(Expon,DirP) - nPoly := PolynomialRing(F,nExponent) - gp:=GroebnerPackage(F,nExponent,VarSet1,nPoly) - lf:List nPoly :=[] - lp:List P:=[] - for f in listf for i in 1.. repeat - vec2:Vector(NNI):=new(nf,0$NNI) - vec2.i:=1 - g:nPoly:=0$nPoly - pol:=0$P - while f^=0 repeat - df:=degree(f-reductum f,lvint) - lcf:=leadingCoefficient f - pol:=pol+monompol(df,lcf,lvint) - g:=g+monomial(lcf,makeprod(degree f,0))$nPoly - f:=reductum f - lp:=concat(pol,lp) - lf:=concat(monomial(1,makeprod(0,directProduct vec2))-g,lf) - npol:List P :=[v::P for v in nvar] - leq : List Equation P := - [p = pol for p in npol for pol in reverse lp ] - lf:=(groebner lf)$gp - while lf^=[] repeat - q:=lf.first - dq:nExponent:=degree q - n:=selectfirst (dq) - if n=0 then leave "done" - lf:=lf.rest - solsn:List P:=[] - for q in lf repeat - g:Polynomial F :=0 - while q^=0 repeat - dq:=degree q - lcq:=leadingCoefficient q - q:=reductum q - vdq:=(selectsecond dq):Vector NNI - g:=g+ lcq* - _*/[p**vdq.j for p in npol for j in 1..] - solsn:=concat(g,solsn) - [solsn,leq]$ST + empty? listf => [empty(),empty()]$ST + nf:=#listf + lvint := "setUnion"/[variables g for g in listf] + vl: List Symbol := [convert vv for vv in lvint] + nvar:List Symbol:=[new() for i in 1..nf] + VarSet1:=OrderedVariableList(concat(vl,nvar)) + lv1:=[variable(vv)$VarSet1::VarSet1 for vv in nvar] + DirP:=DirectProduct(nf,NNI) + nExponent:=Product(Expon,DirP) + nPoly := PolynomialRing(F,nExponent) + gp:=GroebnerPackage(F,nExponent,VarSet1,nPoly) + lf:List nPoly :=[] + lp:List P:=[] + for f in listf for i in 1.. repeat + vec2:Vector(NNI):=new(nf,0$NNI) + vec2.i:=1 + g:nPoly:=0$nPoly + pol:=0$P + while f^=0 repeat + df:=degree(f-reductum f,lvint) + lcf:=leadingCoefficient f + pol:=pol+monompol(df,lcf,lvint) + g:=g+monomial(lcf,makeprod(degree f,0))$nPoly + f:=reductum f + lp:=concat(pol,lp) + lf:=concat(monomial(1,makeprod(0,directProduct vec2))-g,lf) + npol:List P :=[v::P for v in nvar] + leq : List Equation P := + [p = pol for p in npol for pol in reverse lp ] + lf:=(groebner lf)$gp + while lf^=[] repeat + q:=lf.first + dq:nExponent:=degree q + n:=selectfirst (dq) + if n=0 then leave "done" + lf:=lf.rest + solsn:List P:=[] + for q in lf repeat + g:Polynomial F :=0 + while q^=0 repeat + dq:=degree q + lcq:=leadingCoefficient q + q:=reductum q + vdq:=(selectsecond dq):Vector NNI + g:=g+ lcq* + _*/[p**vdq.j for p in npol for j in 1..] + solsn:=concat(g,solsn) + [solsn,leq]$ST coerce(Id:List DPoly) : Ideal == [Id,false] @@ -79379,94 +79539,94 @@ PolynomialRing(R:Ring,E:OrderedAbelianMonoid): T == C entireRing? := R has EntireRing times!(r: R, x: %): % == - res, endcell, newend, xx: Rep + res, endcell, newend, xx: Rep if entireRing? then for tx in x repeat tx.c := r*tx.c else - xx := x - res := empty() - while not empty? xx repeat - tx := first xx - tx.c := r * tx.c - if zero? tx.c then - xx := rest xx - else - newend := xx - xx := rest xx - if empty? res then - res := newend - endcell := res - else - qsetrest!(endcell, newend) - endcell := newend - res; - - --- term * polynomial + xx := x + res := empty() + while not empty? xx repeat + tx := first xx + tx.c := r * tx.c + if zero? tx.c then + xx := rest xx + else + newend := xx + xx := rest xx + if empty? res then + res := newend + endcell := res + else + qsetrest!(endcell, newend) + endcell := newend + res; + + --- term * polynomial termTimes: (R, E, Term) -> Term termTimes(r: R, e: E, tx:Term): Term == [e+tx.k, r*tx.c] times(tco: R, tex: E, rx: %): % == if entireRing? then - map(x1+->termTimes(tco, tex, x1), rx::Rep) + map(x1+->termTimes(tco, tex, x1), rx::Rep) else - [[tex + tx.k, r] for tx in rx::Rep | not zero? (r := tco * tx.c)] + [[tex + tx.k, r] for tx in rx::Rep | not zero? (r := tco * tx.c)] -- local addm! addm!: (Rep, R, E, Rep) -> Rep - -- p1 + coef*x^E * p2 - -- `spare' (commented out) is for storage efficiency (not so good for - -- performance though. + -- p1 + coef*x^E * p2 + -- `spare' (commented out) is for storage efficiency (not so good for + -- performance though. addm!(p1:Rep, coef:R, exp: E, p2:Rep): Rep == --local res, newend, last: Rep res, newcell, endcell: Rep - spare: List Rep + spare: List Rep res := empty() - endcell := empty() - --spare := empty() + endcell := empty() + --spare := empty() while not empty? p1 and not empty? p2 repeat tx := first p1 ty := first p2 exy := exp + ty.k - newcell := empty(); - if tx.k = exy then - newcoef := tx.c + coef * ty.c - if not zero? newcoef then - tx.c := newcoef - newcell := p1 - --else - -- spare := cons(p1, spare) - p1 := rest p1 - p2 := rest p2 - else if tx.k > exy then - newcell := p1 - p1 := rest p1 + newcell := empty(); + if tx.k = exy then + newcoef := tx.c + coef * ty.c + if not zero? newcoef then + tx.c := newcoef + newcell := p1 + --else + -- spare := cons(p1, spare) + p1 := rest p1 + p2 := rest p2 + else if tx.k > exy then + newcell := p1 + p1 := rest p1 else - newcoef := coef * ty.c - if not entireRing? and zero? newcoef then - newcell := empty() - --else if empty? spare then - -- ttt := [exy, newcoef] - -- newcell := cons(ttt, empty()) - --else - -- newcell := first spare - -- spare := rest spare - -- ttt := first newcell - -- ttt.k := exy - -- ttt.c := newcoef + newcoef := coef * ty.c + if not entireRing? and zero? newcoef then + newcell := empty() + --else if empty? spare then + -- ttt := [exy, newcoef] + -- newcell := cons(ttt, empty()) + --else + -- newcell := first spare + -- spare := rest spare + -- ttt := first newcell + -- ttt.k := exy + -- ttt.c := newcoef else - ttt := [exy, newcoef] - newcell := cons(ttt, empty()) - p2 := rest p2 - if not empty? newcell then - if empty? res then - res := newcell - endcell := res - else - qsetrest!(endcell, newcell) - endcell := newcell + ttt := [exy, newcoef] + newcell := cons(ttt, empty()) + p2 := rest p2 + if not empty? newcell then + if empty? res then + res := newcell + endcell := res + else + qsetrest!(endcell, newcell) + endcell := newcell if not empty? p1 then -- then end is const * p1 - newcell := p1 + newcell := p1 else -- then end is (coef, exp) * p2 newcell := times(coef, exp, p2) empty? res => newcell @@ -79481,8 +79641,8 @@ PolynomialRing(R:Ring,E:OrderedAbelianMonoid): T == C zero? first(xx).k => first(xx).c * p2 zero? first(yy).k => p1 * first(yy).c --if #xx > #yy then - -- (xx, yy) := (yy, xx) - -- (p1, p2) := (p2, p1) + -- (xx, yy) := (yy, xx) + -- (p1, p2) := (p2, p1) xx := reverse xx res : Rep := empty() for tx in xx repeat res:=addm!(res,tx.c,tx.k,yy) @@ -79643,14 +79803,16 @@ PolynomialRing(R:Ring,E:OrderedAbelianMonoid): T == C <>= )abbrev domain PI PositiveInteger -++ Author: +++ Author: Mark Botch ++ Date Created: ++ Change History: ++ Basic Operations: ++ Related Constructors: ++ Keywords: positive integer -++ Description: \spadtype{PositiveInteger} provides functions for -++ positive integers. +++ Description: +++ \spadtype{PositiveInteger} provides functions for +++ positive integers. + PositiveInteger: Join(AbelianSemiGroup,OrderedSet,Monoid) with gcd: (%,%) -> % ++ gcd(a,b) computes the greatest common divisor of two @@ -79783,11 +79945,10 @@ PositiveInteger: Join(AbelianSemiGroup,OrderedSet,Monoid) with ++ R.Lidl, H.Niederreiter: Finite Field, Encycoldia of Mathematics and ++ Its Applications, Vol. 20, Cambridge Univ. Press, 1983, ISBN 0 521 30240 4 ++ Description: -++ PrimeField(p) implements the field with p elements if p is a -++ prime number. -++ Error: if p is not prime. -++ Note: this domain does not check that argument is a prime. ---++ with new compiler, want to put the error check before the add +++ PrimeField(p) implements the field with p elements if p is a prime number. +++ Error: if p is not prime. +++ Note: this domain does not check that argument is a prime. + PrimeField(p:PositiveInteger): Exp == Impl where Exp ==> Join(FiniteFieldCategory,FiniteAlgebraicExtensionField($),_ ConvertibleTo(Integer)) @@ -79882,8 +80043,11 @@ PrimeField(p:PositiveInteger): Exp == Impl where <>= )abbrev domain PRIMARR PrimitiveArray +++ Author: Mark Botch +++ Description: ++ This provides a fast array type with no bound checking on elt's. ++ Minimum index is 0 in this type, cannot be changed + PrimitiveArray(S:Type): OneDimensionalArrayAggregate S == add Qmax ==> QVMAXINDEX$Lisp Qsize ==> QVSIZE$Lisp @@ -80047,8 +80211,10 @@ o )show Product <>= )abbrev domain PRODUCT Product +++ Author: Mark Botch ++ Description: ++ This domain implements cartesian product + Product (A:SetCategory,B:SetCategory) : C == T where C == SetCategory with @@ -80064,16 +80230,16 @@ Product (A:SetCategory,B:SetCategory) : C == T if A has OrderedSet and B has OrderedSet then OrderedSet makeprod : (A,B) -> % - ++ makeprod(a,b) computes the product of two functions + ++ makeprod(a,b) computes the product of two functions ++ ++X f:=(x:INT):INT +-> 3*x ++X g:=(x:INT):INT +-> x^3 ++X h(x:INT):Product(INT,INT) == makeprod(f x, g x) ++X h(3) selectfirst : % -> A - ++ selectfirst(x) \undocumented + ++ selectfirst(x) is not documented selectsecond : % -> B - ++ selectsecond(x) \undocumented + ++ selectsecond(x) is not documented T == add @@ -80195,7 +80361,8 @@ Product (A:SetCategory,B:SetCategory) : C == T ++ References: ++ ++ Description: -++ This domain provides modest support for quadratic forms. +++ This domain provides modest support for quadratic forms. + QuadraticForm(n, K): T == Impl where n: PositiveInteger K: Field @@ -80266,8 +80433,7 @@ QuadraticForm(n, K): T == Impl where ++ J. Sym. Comp., April, 1992 ++ Description: ++ \spadtype{QuasiAlgebraicSet} constructs a domain representing -++ quasi-algebraic sets, which -++ is the intersection of a Zariski +++ 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 @@ -80296,6 +80462,7 @@ QuadraticForm(n, K): T == Impl where ++ 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. + QuasiAlgebraicSet(R, Var,Expon,Dpoly) : C == T where R : GcdDomain @@ -80752,10 +80919,11 @@ o )show Quaternion ++ Also See: QuaternionCategory, DivisionRing ++ AMS Classifications: 11R52 ++ Keywords: quaternions, division ring, algebra -++ Description: \spadtype{Quaternion} implements quaternions over a -++ commutative ring. The main constructor function is \spadfun{quatern} -++ which takes 4 arguments: the real part, the i imaginary part, the j -++ imaginary part and the k imaginary part. +++ Description: +++ \spadtype{Quaternion} implements quaternions over a +++ commutative ring. The main constructor function is \spadfun{quatern} +++ which takes 4 arguments: the real part, the i imaginary part, the j +++ imaginary part and the k imaginary part. Quaternion(R:CommutativeRing): QuaternionCategory(R) == add Rep := Record(r:R,i:R,j:R,k:R) @@ -80804,7 +80972,10 @@ Quaternion(R:CommutativeRing): QuaternionCategory(R) == add <>= )abbrev domain QEQUAT QueryEquation +++ Author: Mark Botch +++ Description: ++ This domain implements simple database queries + QueryEquation(): Exports == Implementation where Exports == CoercibleTo(OutputForm) with equation: (Symbol,String) -> % @@ -81543,7 +81714,6 @@ o )show BagAggregate ++ Examples: ++ References: ++ Description: - ++ Linked List implementation of a Queue --% Dequeue and Heap data types @@ -81858,13 +82028,14 @@ Queue(S:SetCategory): QueueAggregate S with <>= )abbrev domain RADFF RadicalFunctionField -++ Function field defined by y**n = f(x) ++ Author: Manuel Bronstein ++ Date Created: 1987 ++ Date Last Updated: 27 July 1993 ++ Keywords: algebraic, curve, radical, function, field. -++ Description: Function field defined by y**n = f(x); ++ Examples: )r RADFF INPUT +++ Description: +++ Function field defined by y**n = f(x); + RadicalFunctionField(F, UP, UPUP, radicnd, n): Exports == Impl where F : UniqueFactorizationDomain UP : UnivariatePolynomialCategory F @@ -82454,8 +82625,8 @@ o )show RadixExpansion ++ Examples: ++ References: ++ Description: -++ This domain allows rational numbers to be presented as repeating -++ decimal expansions or more generally as repeating expansions in any base. +++ This domain allows rational numbers to be presented as repeating +++ decimal expansions or more generally as repeating expansions in any base. RadixExpansion(bb): Exports == Implementation where bb : Integer @@ -84015,6 +84186,7 @@ o )show RealClosure ++ arguments to the domain. It does not help much to write a category ++ since non trivial methods cannot be placed there either. ++ + RealClosure(TheField): PUB == PRIV where TheField : Join(OrderedRing, Field, RealConstant) @@ -84386,8 +84558,9 @@ RealClosure(TheField): PUB == PRIV where ++ Examples: ++ References: ++ Description: -++ \spadtype{RectangularMatrix} is a matrix domain where the number of rows -++ and the number of columns are parameters of the domain. +++ \spadtype{RectangularMatrix} is a matrix domain where the number of rows +++ and the number of columns are parameters of the domain. + RectangularMatrix(m,n,R): Exports == Implementation where m,n : NonNegativeInteger R : Ring @@ -84499,7 +84672,8 @@ RectangularMatrix(m,n,R): Exports == Implementation where ++ Basic Operations: deref, elt, ref, setelt, setref, = ++ Related Constructors: ++ Keywords: reference -++ Description: \spadtype{Reference} is for making a changeable instance +++ Description: +++ \spadtype{Reference} is for making a changeable instance ++ of something. Reference(S:Type): Type with @@ -84649,11 +84823,10 @@ Reference(S:Type): Type with ++ Date Created: 01/1999 ++ Date Last Updated: 23/01/1999 ++ Description: -++ A domain for regular chains (i.e. regular triangular sets) over -++ a Gcd-Domain and with a fix list of variables. -++ This is just a front-end for the \spadtype{RegularTriangularSet} -++ domain constructor. -++ Version: 1. +++ A domain for regular chains (i.e. regular triangular sets) over +++ a Gcd-Domain and with a fix list of variables. +++ This is just a front-end for the \spadtype{RegularTriangularSet} +++ domain constructor. RegularChain(R,ls): Exports == Implementation where R : GcdDomain @@ -84665,14 +84838,15 @@ RegularChain(R,ls): Exports == Implementation where Exports == RegularTriangularSetCategory(R,E,V,P) with zeroSetSplit: (List P, Boolean, Boolean) -> List $ - ++ \spad{zeroSetSplit(lp,clos?,info?)} returns a list \spad{lts} of regular - ++ chains such that the union of the closures of their regular zero sets - ++ equals the affine variety associated with \spad{lp}. Moreover, - ++ if \spad{clos?} is \spad{false} then the union of the regular zero - ++ set of the \spad{ts} (for \spad{ts} in \spad{lts}) equals this variety. + ++ \spad{zeroSetSplit(lp,clos?,info?)} returns a list \spad{lts} of + ++ regular chains such that the union of the closures of their regular + ++ zero sets equals the affine variety associated with \spad{lp}. + ++ Moreover, if \spad{clos?} is \spad{false} then the union of the + ++ regular zero set of the \spad{ts} (for \spad{ts} in \spad{lts}) + ++ equals this variety. ++ If \spad{info?} is \spad{true} then some information is ++ displayed during the computations. See - ++ \axiomOpFrom{zeroSetSplit}{RegularTriangularSet}. + ++ zeroSetSplit from RegularTriangularSet. Implementation == RegularTriangularSet(R,E,V,P) @@ -86171,15 +86345,13 @@ o )show RegularTriangularSet ++ Also See: ++ AMS Classifications: ++ Keywords: -++ Description: -++ This domain provides an implementation of regular chains. -++ Moreover, the operation \axiomOpFrom{zeroSetSplit}{RegularTriangularSetCategory} -++ is an implementation of a new algorithm for solving polynomial systems by -++ means of regular chains.\newline ++ References : ++ [1] M. MORENO MAZA "A new algorithm for computing triangular ++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. -++ Version: Version 11. +++ Description: +++ This domain provides an implementation of regular chains. +++ Moreover, the operation zeroSetSplit is an implementation of a new +++ algorithm for solving polynomial systems by means of regular chains. RegularTriangularSet(R,E,V,P) : Exports == Implementation where @@ -86210,7 +86382,7 @@ RegularTriangularSet(R,E,V,P) : Exports == Implementation where ++ is an internal subroutine, exported only for developement. zeroSetSplit: (LP, B, B) -> Split ++ \axiom{zeroSetSplit(lp,clos?,info?)} has the same specifications as - ++ \axiomOpFrom{zeroSetSplit}{RegularTriangularSetCategory}. + ++ zeroSetSplit from RegularTriangularSetCategory. ++ Moreover, if \axiom{clos?} then solves in the sense of the Zariski closure ++ else solves in the sense of the regular zeros. If \axiom{info?} then ++ do print messages during the computations. @@ -86596,7 +86768,8 @@ RegularTriangularSet(R,E,V,P) : Exports == Implementation where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: ResidueRing is the quotient of a polynomial ring by an ideal. +++ Description: +++ 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 @@ -86731,9 +86904,11 @@ ResidueRing(F,Expon,VarSet,FPol,LFPol) : Dom == Body ++ Keywords: ++ Examples: ++ References: -++ Description: A domain used to return the results from a call to the NAG +++ Description: +++ 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. + Result():Exports==Implementation where O ==> OutputForm @@ -86821,11 +86996,13 @@ Result():Exports==Implementation where <>= )abbrev domain RULE RewriteRule -++ Rules for the pattern matcher ++ Author: Manuel Bronstein ++ Date Created: 24 Oct 1988 ++ Date Last Updated: 26 October 1993 ++ Keywords: pattern, matching, rule. +++ Description: +++ Rules for the pattern matcher + RewriteRule(Base, R, F): Exports == Implementation where Base : SetCategory R : Join(Ring, PatternMatchable Base, OrderedSet, @@ -87036,6 +87213,7 @@ depending on several "real roots". ++ Description: ++ \axiomType{RightOpenIntervalRootCharacterization} provides work with ++ interval root coding. + RightOpenIntervalRootCharacterization(TheField,ThePolDom) : PUB == PRIV where TheField : Join(OrderedRing,Field) @@ -87872,15 +88050,15 @@ o )show RomanNumeral <>= )abbrev domain ROMAN RomanNumeral -++ Author: +++ Author: Mark Botch ++ Date Created: ++ Change History: -++ Basic Operations: -++ convert, roman ++ Related Constructors: ++ Keywords: roman numerals -++ Description: \spadtype{RomanNumeral} provides functions for converting -++ integers to roman numerals. +++ Description: +++ \spadtype{RomanNumeral} provides functions for converting +++ integers to roman numerals. + RomanNumeral(): IntegerNumberSystem with canonical ++ mathematical equality is data structure equality. @@ -88007,14 +88185,15 @@ RomanNumeral(): IntegerNumberSystem with ++ Description: ++ \axiomType{RoutinesTable} implements a database and associated tuning ++ mechanisms for a set of known NAG routines + RoutinesTable(): E == I where - F ==> Float - ST ==> String - LST ==> List String - Rec ==> Record(key:Symbol,entry:Any) - RList ==> List(Record(key:Symbol,entry:Any)) - IFL ==> List(Record(ifail:Integer,instruction:ST)) - Entry ==> Record(chapter:ST, type:ST, domainName: ST, + F ==> Float + ST ==> String + LST ==> List String + Rec ==> Record(key:Symbol,entry:Any) + RList ==> List(Record(key:Symbol,entry:Any)) + IFL ==> List(Record(ifail:Integer,instruction:ST)) + Entry ==> Record(chapter:ST, type:ST, domainName: ST, defaultMin:F, measure:F, failList:IFL, explList:LST) E ==> TableAggregate(Symbol,Any) with @@ -88399,11 +88578,13 @@ RoutinesTable(): E == I where <>= )abbrev domain RULECOLD RuleCalled +++ Author: Mark Botch ++ Description: ++ This domain implements named rules + RuleCalled(f:Symbol): SetCategory with - name: % -> Symbol - ++ name(x) returns the symbol + name: % -> Symbol + ++ name(x) returns the symbol == add name r == f coerce(r:%):OutputForm == f::OutputForm @@ -88439,13 +88620,14 @@ RuleCalled(f:Symbol): SetCategory with <>= )abbrev domain RULESET Ruleset -++ Sets of rules for the pattern matcher ++ Author: Manuel Bronstein ++ Date Created: 20 Mar 1990 ++ Date Last Updated: 29 Jun 1990 -++ Description: -++ A ruleset is a set of pattern matching rules grouped together. ++ Keywords: pattern, matching, rule. +++ Description: +++ Sets of rules for the pattern matcher. +++ A ruleset is a set of pattern matching rules grouped together. + Ruleset(Base, R, F): Exports == Implementation where Base : SetCategory R : Join(Ring, PatternMatchable Base, OrderedSet, @@ -88523,17 +88705,17 @@ Ruleset(Base, R, F): Exports == Implementation where ++ IBM Corporation, Publishing Systems Information Development, ++ Dept. G68, P.O. Box 1900, Boulder, Colorado, USA 80301-9191. ++ Description: -++ \spadtype{ScriptFormulaFormat} provides a coercion from -++ \spadtype{OutputForm} to IBM SCRIPT/VS Mathematical Formula Format. -++ The basic SCRIPT formula format object consists of three parts: a -++ prologue, a formula part and an epilogue. The functions -++ \spadfun{prologue}, \spadfun{formula} and \spadfun{epilogue} -++ extract these parts, respectively. The central parts of the expression -++ go into the formula 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 ":df." and ":edf." so that the -++ formula section will be printed in display math mode. +++ \spadtype{ScriptFormulaFormat} provides a coercion from +++ \spadtype{OutputForm} to IBM SCRIPT/VS Mathematical Formula Format. +++ The basic SCRIPT formula format object consists of three parts: a +++ prologue, a formula part and an epilogue. The functions +++ \spadfun{prologue}, \spadfun{formula} and \spadfun{epilogue} +++ extract these parts, respectively. The central parts of the expression +++ go into the formula 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 ":df." and ":edf." so that the +++ formula section will be printed in display math mode. ScriptFormulaFormat(): public == private where E ==> OutputForm @@ -89152,7 +89334,7 @@ o )show Segment ++ Examples: ++ References: ++ Description: -++ This type is used to specify a range of values from type \spad{S}. +++ This type is used to specify a range of values from type \spad{S}. Segment(S:Type): SegmentCategory(S) with if S has SetCategory then SetCategory @@ -89356,7 +89538,7 @@ o )show SegmentBinding <>= )abbrev domain SEGBIND SegmentBinding -++ Author: +++ Author: Mark Botch ++ Date Created: ++ Date Last Updated: June 4, 1991 ++ Basic Operations: @@ -89367,8 +89549,9 @@ o )show SegmentBinding ++ Examples: ++ References: ++ Description: -++ 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. +++ 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. + SegmentBinding(S:Type): Type with equation: (Symbol, Segment S) -> % ++ equation(v,a..b) creates a segment binding value with variable @@ -89799,12 +89982,14 @@ o )show Set ++ as a list in ascending order and ++ the extract operation returns the maximum entry. ++ Given two sets s and t where \spad{#s = m} and \spad{#t = n}, -++ the complexity of -++ \spad{s = t} is \spad{O(min(n,m))} -++ \spad{s < t} is \spad{O(max(n,m))} -++ \spad{union(s,t)}, \spad{intersect(s,t)}, \spad{minus(s,t)}, \spad{symmetricDifference(s,t)} is \spad{O(max(n,m))} -++ \spad{member(x,t)} is \spad{O(n log n)} -++ \spad{insert(x,t)} and \spad{remove(x,t)} is \spad{O(n)} +++ the complexity of\br +++ \tab{5}\spad{s = t} is \spad{O(min(n,m))}\br +++ \tab{5}\spad{s < t} is \spad{O(max(n,m))}\br +++ \tab{5}\spad{union(s,t)}, \spad{intersect(s,t)}, \spad{minus(s,t)},\br +++ \tab{10 \spad{symmetricDifference(s,t)} is \spad{O(max(n,m))}\br +++ \tab{5}\spad{member(x,t)} is \spad{O(n log n)}\br +++ \tab{5}\spad{insert(x,t)} and \spad{remove(x,t)} is \spad{O(n)} + Set(S:SetCategory): FiniteSetAggregate S == add Rep := FlexibleArray(S) # s == _#$Rep s @@ -89992,6 +90177,7 @@ Set(S:SetCategory): FiniteSetAggregate S == add ++ Description: ++ \spadtype{SetOfMIntegersInOneToN} implements the subsets of M integers ++ in the interval \spad{[1..n]} + SetOfMIntegersInOneToN(m, n): Exports == Implementation where PI ==> PositiveInteger N ==> NonNegativeInteger @@ -90256,11 +90442,10 @@ SetOfMIntegersInOneToN(m, n): Exports == Implementation where ++ References:Kolchin, E.R. "Differential Algebra and Algebraic Groups" ++ (Academic Press, 1973). ++ Description: -++ \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. -++ +++ \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. SequentialDifferentialPolynomial(R): Exports == Implementation where @@ -90327,16 +90512,16 @@ SequentialDifferentialPolynomial(R): ++ References:Kolchin, E.R. "Differential Algebra and Algebraic Groups" ++ (Academic Press, 1973). ++ Description: -++ \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 v, -++ there are only a finite number of derivatives u with u \spadfun{<} 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 u by the -++ lexicographic order on the pair -++ (\spadfun{variable}(u), \spadfun{order}(u)). +++ \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 v, +++ there are only a finite number of derivatives u with u \spadfun{<} 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 u by the +++ lexicographic order on the pair +++ (\spadfun{variable}(u), \spadfun{order}(u)). SequentialDifferentialVariable(S:OrderedSet):DifferentialVariableCategory(S) == add @@ -90395,12 +90580,12 @@ SequentialDifferentialVariable(S:OrderedSet):DifferentialVariableCategory(S) <>= )abbrev domain SEX SExpression -++ Domain for the standard Lisp values ++ Author: S.M.Watt ++ Date Created: July 1987 ++ Date Last Modified: 23 May 1991 ++ Description: -++ This domain allows the manipulation of the usual Lisp values; +++ This domain allows the manipulation of the usual Lisp values; + SExpression() == SExpressionOf(String, Symbol, Integer, DoubleFloat, OutputForm) @@ -90449,16 +90634,16 @@ SExpression() <>= )abbrev domain SEXOF SExpressionOf -++ Domain for Lisp values over arbitrary atomic types ++ Author: S.M.Watt ++ Date Created: July 1987 ++ Date Last Modified: 23 May 1991 ++ Description: -++ This domain allows the manipulation of Lisp values over -++ arbitrary atomic types. +++ This domain allows the manipulation of Lisp values over +++ arbitrary atomic types. -- Allows the names of the atomic types to be chosen. -- *** Warning *** Although the parameters are declared only to be Sets, -- *** Warning *** they must have the appropriate representations. + SExpressionOf(Str, Sym, Int, Flt, Expr): Decl == Body where Str, Sym, Int, Flt, Expr: SetCategory @@ -90616,11 +90801,12 @@ SExpressionOf(Str, Sym, Int, Flt, Expr): Decl == Body where <>= )abbrev domain SAE SimpleAlgebraicExtension -++ Algebraic extension of a ring by a single polynomial ++ Author: Barry Trager, Manuel Bronstein, Clifton Williamson ++ Date Created: 1986 ++ Date Last Updated: 9 May 1994 +++ Keywords: ring, algebraic, extension ++ Description: +++ Algebraic extension of a ring by a single polynomial. ++ Domain which represents simple algebraic extensions of arbitrary ++ rings. The first argument to the domain, R, is the underlying ring, ++ the second argument is a domain of univariate polynomials over K, @@ -90629,8 +90815,6 @@ SExpressionOf(Str, Sym, Int, Flt, Expr): Decl == Body where ++ of degree less than that of the minimal polynomial with coefficients ++ in R. The second argument is both the type of the third argument and ++ the underlying representation used by \spadtype{SAE} itself. -++ Keywords: ring, algebraic, extension -++ Example: )r SAE INPUT SimpleAlgebraicExtension(R:CommutativeRing, UP:UnivariatePolynomialCategory R, M:UP): MonogenicAlgebra(R, UP) == add @@ -90840,6 +91024,7 @@ SimpleAlgebraicExtension(R:CommutativeRing, ++ FORTRAN subprograms, making it possible to coerce objects of various ++ domains into a FORTRAN subprogram called \axiom{f}. ++ These can then be translated into legal FORTRAN code. + SimpleFortranProgram(R,FS): Exports == Implementation where R : OrderedSet FS : FunctionSpace(R) @@ -91196,8 +91381,8 @@ o )show SingleInteger ++ not, and, or, xor, Not, And, Or ++ Related Constructors: ++ Keywords: single integer -++ Description: SingleInteger is intended to support machine integer -++ arithmetic. +++ Description: +++ SingleInteger is intended to support machine integer arithmetic. -- MAXINT, BASE (machine integer constants) -- MODULUS, MULTIPLIER (random number generator constants) @@ -91228,25 +91413,25 @@ SingleInteger(): Join(IntegerNumberSystem,Logic,OpenMath) with -- bit operations "not": % -> % - ++ not(n) returns the bit-by-bit logical {\em not} of the single integer n. + ++ not(n) returns the bit-by-bit logical not of the single integer n. "~" : % -> % - ++ ~ n returns the bit-by-bit logical {\em not } of the single integer n. + ++ ~ n returns the bit-by-bit logical not of the single integer n. "/\": (%, %) -> % - ++ n /\ m returns the bit-by-bit logical {\em and} of + ++ n /\ m returns the bit-by-bit logical and of ++ the single integers n and m. "\/" : (%, %) -> % - ++ n \/ m returns the bit-by-bit logical {\em or} of + ++ n \/ m returns the bit-by-bit logical or of ++ the single integers n and m. "xor": (%, %) -> % - ++ xor(n,m) returns the bit-by-bit logical {\em xor} of + ++ xor(n,m) returns the bit-by-bit logical xor of ++ the single integers n and m. Not : % -> % - ++ Not(n) returns the bit-by-bit logical {\em not} of the single integer n. + ++ Not(n) returns the bit-by-bit logical not of the single integer n. And : (%,%) -> % - ++ And(n,m) returns the bit-by-bit logical {\em and} of + ++ And(n,m) returns the bit-by-bit logical and of ++ the single integers n and m. Or : (%,%) -> % - ++ Or(n,m) returns the bit-by-bit logical {\em or} of + ++ Or(n,m) returns the bit-by-bit logical or of ++ the single integers n and m. == add @@ -91410,8 +91595,11 @@ SingleInteger(): Join(IntegerNumberSystem,Logic,OpenMath) with <>= )abbrev domain SAOS SingletonAsOrderedSet +++ Author: Mark Botch +++ Description: ++ This trivial domain lets us build Univariate Polynomials -++ in an anonymous variable +++ in an anonymous variable + SingletonAsOrderedSet(): OrderedSet with create:() -> % convert:% -> Symbol @@ -91542,7 +91730,7 @@ SingletonAsOrderedSet(): OrderedSet with ++ Keywords: polynomial, multivariate ++ References: ++ Description: -++ This type is the basic representation of sparse recursive multivariate +++ 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, @@ -91622,7 +91810,7 @@ SparseMultivariatePolynomial(R: Ring,VarSet: OrderedSet): C == T where univariateKnown p == p case R => (leadingCoefficient p) :: SparseUnivariatePolynomial(R) - monomial( leadingCoefficient p,degree p.ts)+ univariateKnown(red p) + monomial( leadingCoefficient p,degree p.ts)+ univariateKnown(red p) univariate p == p case R =>(leadingCoefficient p) :: SparseUnivariatePolynomial(R) @@ -91725,12 +91913,12 @@ SparseMultivariatePolynomial(R: Ring,VarSet: OrderedSet): C == T where p1 + p2 == p1 case R and p2 case R => p1 +$R p2 p1 case R => [p2.v, p1::D + p2.ts]$VPoly - p2 case R => [p1.v, p1.ts + p2::D]$VPoly - p1.v = p2.v => + p2 case R => [p1.v, p1.ts + p2::D]$VPoly + p1.v = p2.v => mvar:=p1.v up:=p1.ts+p2.ts if ground? up then leadingCoefficient(up) else [mvar,up]$VPoly - p1.v < p2.v => + p1.v < p2.v => [p2.v, p1::D + p2.ts]$VPoly [p1.v, p1.ts + p2::D]$VPoly @@ -91760,7 +91948,7 @@ SparseMultivariatePolynomial(R: Ring,VarSet: OrderedSet): C == T where mvar:=p1.v up:=p1.ts*p2 if ground? up then leadingCoefficient(up) else [mvar,up]$VPoly - p1.v = p2.v => + p1.v = p2.v => mvar:=p1.v up:=p1.ts*p2.ts if ground? up then leadingCoefficient(up) else [mvar,up]$VPoly @@ -91908,28 +92096,28 @@ SparseMultivariatePolynomial(R: Ring,VarSet: OrderedSet): C == T where -- eventually need a better notion of gcd's over floats -- this essentially computes the gcds of the monomial contents gcdPolynomial(a:SUP $,b:SUP $):SUP $ == - ground? (a) => + ground? (a) => zero? a => b - gcd(leadingCoefficient a, content b)::SUP $ - ground?(b) => + gcd(leadingCoefficient a, content b)::SUP $ + ground?(b) => zero? b => b - gcd(leadingCoefficient b, content a)::SUP $ - conta := content a - mona:SUP $ := monomial(conta, minimumDegree a) + gcd(leadingCoefficient b, content a)::SUP $ + conta := content a + mona:SUP $ := monomial(conta, minimumDegree a) if mona ^= 1 then - a := (a exquo mona)::SUP $ - contb := content b - monb:SUP $ := monomial(contb, minimumDegree b) + a := (a exquo mona)::SUP $ + contb := content b + monb:SUP $ := monomial(contb, minimumDegree b) if monb ^= 1 then - b := (b exquo monb)::SUP $ - mong:SUP $ := monomial(gcd(conta, contb), + b := (b exquo monb)::SUP $ + mong:SUP $ := monomial(gcd(conta, contb), min(degree mona, degree monb)) degree(a) >= degree b => - not((a exquo b) case "failed") => - mong * b - mong - not((b exquo a) case "failed") => mong * a - mong + not((a exquo b) case "failed") => + mong * b + mong + not((b exquo a) case "failed") => mong * a + mong coerce(p):OutputForm == p case R => (p::R)::OutputForm @@ -91960,7 +92148,7 @@ SparseMultivariatePolynomial(R: Ring,VarSet: OrderedSet): C == T where setrest!(l,rest m) l empty? rest m => l - setrest!(l, mymerge(rest l, rest m)) + setrest!(l, mymerge(rest l, rest m)) l first l > first m => empty? rest l => @@ -92003,8 +92191,8 @@ SparseMultivariatePolynomial(R: Ring,VarSet: OrderedSet): C == T where multivariate(pts,p.v) eval(p,Lvar,Lpval) == - empty? rest Lvar => evalSortedVarlist(p,Lvar,Lpval) - sorted?((x1,x2) +-> x1 > x2, Lvar) => evalSortedVarlist(p,Lvar,Lpval) + empty? rest Lvar => evalSortedVarlist(p,Lvar,Lpval) + sorted?((x1,x2) +-> x1 > x2, Lvar) => evalSortedVarlist(p,Lvar,Lpval) nlvar := sort((x1,x2) +-> x1 > x2,Lvar) nlpval := Lvar = nlvar => Lpval @@ -92440,7 +92628,6 @@ o )display op coefficient <>= )abbrev domain SMTS SparseMultivariateTaylorSeries -++ This domain provides multivariate Taylor series ++ Authors: William Burge, Stephen Watt, Clifton Williamson ++ Date Created: 15 August 1988 ++ Date Last Updated: 18 May 1991 @@ -92452,11 +92639,12 @@ o )display op coefficient ++ Examples: ++ References: ++ Description: -++ 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 SMP. -++ The nth element of the stream is a form of degree n. SMTS is an -++ internal domain. +++ 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 SMP. +++ The nth element of the stream is a form of degree n. SMTS is an +++ internal domain. + SparseMultivariateTaylorSeries(Coef,Var,SMP):_ Exports == Implementation where Coef : Ring @@ -92933,8 +93121,8 @@ o )show SparseTable ++ Examples: ++ References: ++ Description: -++ A sparse table has a default entry, which is returned if no other -++ value has been explicitly stored for a key. +++ A sparse table has a default entry, which is returned if no other +++ value has been explicitly stored for a key. SparseTable(Key:SetCategory, Ent:SetCategory, dent:Ent) == GeneralSparseTable(Key, Ent, Table(Key, Ent), dent) @@ -93104,13 +93292,15 @@ SparseTable(Key:SetCategory, Ent:SetCategory, dent:Ent) == ++ Keywords: sparse, series ++ Examples: ++ References: -++ Description: Sparse Laurent series in one variable -++ \spadtype{SparseUnivariateLaurentSeries} is a domain representing Laurent -++ 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, -++ \spad{SparseUnivariateLaurentSeries(Integer,x,3)} represents Laurent -++ series in \spad{(x - 3)} with integer coefficients. +++ Description: +++ Sparse Laurent series in one variable +++ \spadtype{SparseUnivariateLaurentSeries} is a domain representing Laurent +++ 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, +++ \spad{SparseUnivariateLaurentSeries(Integer,x,3)} represents Laurent +++ series in \spad{(x - 3)} with integer coefficients. + SparseUnivariateLaurentSeries(Coef,var,cen): Exports == Implementation where Coef : Ring var : Symbol @@ -93440,7 +93630,7 @@ SparseUnivariateLaurentSeries(Coef,var,cen): Exports == Implementation where ++ 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. -++ Note: if the coefficient ring is a field, this domain forms a euclidean domain. +++ Note that if the coefficient ring is a field, this domain forms a euclidean domain. SparseUnivariatePolynomial(R:Ring): UnivariatePolynomialCategory(R) with outputForm : (%,OutputForm) -> OutputForm @@ -93484,7 +93674,7 @@ SparseUnivariatePolynomial(R:Ring): UnivariatePolynomialCategory(R) with -- break up exponent in qn * characteristic + rn -- exponentiating by the characteristic is fast rec := divide(n, characteristic()$R) - qn:= rec.quotient + qn:= rec.quotient rn:= rec.remainder repeat if rn = 1 then y := y * p @@ -93492,8 +93682,8 @@ SparseUnivariatePolynomial(R:Ring): UnivariatePolynomialCategory(R) with zero? qn => return y -- raise to the characteristic power p:= [[t.k * characteristic()$R , primeFrobenius(t.c)$R ]$Term for t in p] - rec := divide(qn, characteristic()$R) - qn:= rec.quotient + rec := divide(qn, characteristic()$R) + qn:= rec.quotient rn:= rec.remainder y @@ -93933,6 +94123,10 @@ unfortunately. <>= )abbrev domain SUPEXPR SparseUnivariatePolynomialExpressions +++ Author: Mark Botch +++ Description: +++ This domain has no description + SparseUnivariatePolynomialExpressions(R: Ring): Exports == Implementation where Exports == UnivariatePolynomialCategory R with @@ -94101,13 +94295,15 @@ SparseUnivariatePolynomialExpressions(R: Ring): Exports == Implementation where ++ Keywords: sparse, series ++ Examples: ++ References: -++ Description: Sparse Puiseux series in one variable -++ \spadtype{SparseUnivariatePuiseuxSeries} is a domain representing Puiseux -++ 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, -++ \spad{SparseUnivariatePuiseuxSeries(Integer,x,3)} represents Puiseux -++ series in \spad{(x - 3)} with \spadtype{Integer} coefficients. +++ Description: +++ Sparse Puiseux series in one variable +++ \spadtype{SparseUnivariatePuiseuxSeries} is a domain representing Puiseux +++ 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, +++ \spad{SparseUnivariatePuiseuxSeries(Integer,x,3)} represents Puiseux +++ series in \spad{(x - 3)} with \spadtype{Integer} coefficients. + SparseUnivariatePuiseuxSeries(Coef,var,cen): Exports == Implementation where Coef : Ring var : Symbol @@ -94248,9 +94444,10 @@ SparseUnivariatePuiseuxSeries(Coef,var,cen): Exports == Implementation where ++ Date Created: 19 October 1993 ++ Date Last Updated: 1 February 1994 ++ Description: -++ 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}. +++ 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}. + SparseUnivariateSkewPolynomial(R:Ring, sigma:Automorphism R, delta: R -> R): UnivariateSkewPolynomialCategory R with outputForm: (%, OutputForm) -> OutputForm @@ -94386,13 +94583,15 @@ SparseUnivariateSkewPolynomial(R:Ring, sigma:Automorphism R, delta: R -> R): ++ Keywords: Taylor series, sparse power series ++ Examples: ++ References: -++ Description: Sparse Taylor series in one variable -++ \spadtype{SparseUnivariateTaylorSeries} 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{SparseUnivariateTaylorSeries}(Integer,x,3) represents Taylor -++ series in \spad{(x - 3)} with \spadtype{Integer} coefficients. +++ Description: +++ Sparse Taylor series in one variable +++ \spadtype{SparseUnivariateTaylorSeries} 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{SparseUnivariateTaylorSeries}(Integer,x,3) represents Taylor +++ series in \spad{(x - 3)} with \spadtype{Integer} coefficients. + SparseUnivariateTaylorSeries(Coef,var,cen): Exports == Implementation where Coef : Ring var : Symbol @@ -94852,7 +95051,7 @@ SparseUnivariateTaylorSeries(Coef,var,cen): Exports == Implementation where <>= )abbrev domain SHDP SplitHomogeneousDirectProduct -++ Author: +++ Author: Mark Botch ++ Date Created: ++ Date Last Updated: ++ Basic Functions: @@ -94862,7 +95061,7 @@ SparseUnivariateTaylorSeries(Coef,var,cen): Exports == Implementation where ++ Keywords: ++ References: ++ Description: -++ This type represents the finite direct or cartesian product of an +++ 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 dim1 parameter specifies the ++ length of the first block. The ordering is lexicographic between @@ -94893,10 +95092,10 @@ SplitHomogeneousDirectProduct(dimtot,dim1,S) : T == C where false (v1:% < v2:%):Boolean == - lessThanRlex(v1,v2,1,dim1) => true - for i in 1..dim1 repeat - if qelt(v1,i) ^= qelt(v2,i) then return false - lessThanRlex(v1,v2,dim1+1,dimtot) + lessThanRlex(v1,v2,1,dim1) => true + for i in 1..dim1 repeat + if qelt(v1,i) ^= qelt(v2,i) then return false + lessThanRlex(v1,v2,dim1+1,dimtot) @ <>= @@ -94947,17 +95146,17 @@ SplitHomogeneousDirectProduct(dimtot,dim1,S) : T == C where ++ References: ++ References: ++ Description: -++ 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 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). +++ 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 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). SplittingNode(V,C) : Exports == Implementation where @@ -95168,27 +95367,27 @@ SplittingNode(V,C) : Exports == Implementation where ++ d'extensions simples et resolution des systemes d'equations ++ algebriques" These, Universite P.etM. Curie, Paris, 1997. ++ Description: -++ This domain exports a modest implementation of splitting -++ trees. Spliiting 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 is a splitting tree \axiom{a} when -++ \axiom{status(value(a))} is \axiom{true}. Thus, -++ if for the splitting tree \axiom{a} the flag -++ \axiom{status(value(a))} is \axiom{true}, then -++ \axiom{status(value(d))} is \axiom{true} for any -++ subtree \axiom{d} of \axiom{a}. This property -++ of splitting trees is called the termination -++ condition. If no vertex in a splitting tree \axiom{a} -++ is equal to another, \axiom{a} is said to satisfy -++ the no-duplicates condition. The splitting -++ tree \axiom{a} will satisfy this condition -++ if nodes are added to \axiom{a} by mean of -++ \axiom{splitNodeOf!} and if \axiom{construct} -++ is only used to create the root of \axiom{a} -++ with no children. +++ This domain exports a modest implementation of splitting +++ trees. Spliiting 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 is a splitting tree \axiom{a} when +++ \axiom{status(value(a))} is \axiom{true}. Thus, +++ if for the splitting tree \axiom{a} the flag +++ \axiom{status(value(a))} is \axiom{true}, then +++ \axiom{status(value(d))} is \axiom{true} for any +++ subtree \axiom{d} of \axiom{a}. This property +++ of splitting trees is called the termination +++ condition. If no vertex in a splitting tree \axiom{a} +++ is equal to another, \axiom{a} is said to satisfy +++ the no-duplicates condition. The splitting +++ tree \axiom{a} will satisfy this condition +++ if nodes are added to \axiom{a} by mean of +++ \axiom{splitNodeOf!} and if \axiom{construct} +++ is only used to create the root of \axiom{a} +++ with no children. SplittingTree(V,C) : Exports == Implementation where @@ -96049,15 +96248,14 @@ o )show SquareFreeRegularTriangularSet ++ Also See: ++ AMS Classifications: ++ Keywords: -++ Description: -++ This domain provides an implementation of square-free regular chains. -++ Moreover, the operation \axiomOpFrom{zeroSetSplit}{SquareFreeRegularTriangularSetCategory} -++ is an implementation of a new algorithm for solving polynomial systems by -++ means of regular chains.\newline ++ References : ++ [1] M. MORENO MAZA "A new algorithm for computing triangular ++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. -++ Version: 2 +++ Description: +++ This domain provides an implementation of square-free regular chains. +++ Moreover, the operation zeroSetSplit +++ is an implementation of a new algorithm for solving polynomial systems by +++ means of regular chains. SquareFreeRegularTriangularSet(R,E,V,P) : Exports == Implementation where @@ -96088,9 +96286,9 @@ SquareFreeRegularTriangularSet(R,E,V,P) : Exports == Implementation where ++ is an internal subroutine, exported only for developement. zeroSetSplit: (LP, B, B) -> Split ++ \axiom{zeroSetSplit(lp,clos?,info?)} has the same specifications as - ++ \axiomOpFrom{zeroSetSplit}{RegularTriangularSetCategory} + ++ zeroSetSplit from RegularTriangularSetCategory ++ from \spadtype{RegularTriangularSetCategory} - ++ Moreover, if \axiom{clos?} then solves in the sense of the Zariski closure + ++ Moreover, if clos? then solves in the sense of the Zariski closure ++ else solves in the sense of the regular zeros. If \axiom{info?} then ++ do print messages during the computations. zeroSetSplit: (LP, B, B, B, B) -> Split @@ -96686,8 +96884,9 @@ o )show SquareMatrix ++ Examples: ++ References: ++ Description: -++ \spadtype{SquareMatrix} is a matrix domain of square matrices, where the -++ number of rows (= number of columns) is a parameter of the type. +++ \spadtype{SquareMatrix} is a matrix domain of square matrices, where the +++ number of rows (= number of columns) is a parameter of the type. + SquareMatrix(ndim,R): Exports == Implementation where ndim : NonNegativeInteger R : Ring @@ -97460,7 +97659,6 @@ o )show BagAggregate ++ Examples: ++ References: ++ Description: - ++ Linked List implementation of a Stack --% Dequeue and Heap data types @@ -99185,11 +99383,11 @@ o )show String <>= )abbrev domain STRING String +++ Author: Mark Botch ++ Description: -++ This is the domain of character strings. -MINSTRINGINDEX ==> 1 -- as of 3/14/90. +++ This is the domain of character strings. Strings are 1 based. -String(): StringCategory == IndexedString(MINSTRINGINDEX) add +String(): StringCategory == IndexedString(1) add string n == STRINGIMAGE(n)$Lisp OMwrite(x: %): String == @@ -99391,8 +99589,9 @@ o )show StringTable ++ Examples: ++ References: ++ Description: -++ This domain provides tables where the keys are strings. -++ A specialized hash function for strings is used. +++ This domain provides tables where the keys are strings. +++ A specialized hash function for strings is used. + StringTable(Entry: SetCategory) == HashTable(String, Entry, "CVEC") @@ -99497,8 +99696,10 @@ point. <>= )abbrev domain SUBSPACE SubSpace +++ Author: Mark Botch ++ Description: -++ This domain \undocumented +++ This domain is not documented + SubSpace(n:PI,R:Ring) : Exports == Implementation where I ==> Integer PI ==> PositiveInteger @@ -99513,27 +99714,27 @@ SubSpace(n:PI,R:Ring) : Exports == Implementation where Exports ==> SetCategory with leaf? : % -> B - ++ leaf?(x) \undocumented + ++ leaf?(x) is not documented root? : % -> B - ++ root?(x) \undocumented + ++ root?(x) is not documented internal? : % -> B - ++ internal?(x) \undocumented + ++ internal?(x) is not documented new : () -> % - ++ new() \undocumented + ++ new() is not documented subspace : () -> % - ++ subspace() \undocumented + ++ subspace() is not documented birth : % -> % -- returns a pointer to the baby - ++ birth(x) \undocumented + ++ birth(x) is not documented child : (%,NNI) -> % - ++ child(x,n) \undocumented + ++ child(x,n) is not documented children : % -> List % - ++ children(x) \undocumented + ++ children(x) is not documented numberOfChildren: % -> NNI - ++ numberOfChildren(x) \undocumented + ++ numberOfChildren(x) is not documented shallowCopy : % -> % - ++ shallowCopy(x) \undocumented + ++ shallowCopy(x) is not documented deepCopy : % -> % - ++ deepCopy(x) \undocumented + ++ deepCopy(x) is not documented merge : (%,%) -> % ++ merge(s1,s2) the subspaces s1 and s2 into a single subspace. merge : List % -> % @@ -99945,6 +100146,7 @@ SubSpace(n:PI,R:Ring) : Exports == Implementation where <>= )abbrev domain COMPPROP SubSpaceComponentProperty +++ Author: Mark Botch ++ Description: ++ This domain implements some global properties of subspaces. @@ -99959,17 +100161,17 @@ SubSpaceComponentProperty() : Exports == Implementation where Exports ==> SetCategory with new : () -> % - ++ new() \undocumented + ++ new() is not documented closed? : % -> B - ++ closed?(x) \undocumented + ++ closed?(x) is not documented solid? : % -> B - ++ solid?(x) \undocumented + ++ solid?(x) is not documented close : (%,B) -> B - ++ close(x,b) \undocumented + ++ close(x,b) is not documented solid : (%,B) -> B - ++ solid(x,b) \undocumented + ++ solid(x,b) is not documented copy : % -> % - ++ copy(x) \undocumented + ++ copy(x) is not documented Implementation ==> add Rep := Record(closed:B, solid:B) @@ -100016,19 +100218,21 @@ SubSpaceComponentProperty() : Exports == Implementation where <>= )abbrev domain SUCH SuchThat +++ Author: Mark Botch ++ Description: ++ This domain implements "such that" forms + SuchThat(S1, S2): Cat == Capsule where E ==> OutputForm S1, S2: SetCategory Cat == SetCategory with construct: (S1, S2) -> % - ++ construct(s,t) makes a form s:t + ++ construct(s,t) makes a form s:t lhs: % -> S1 - ++ lhs(f) returns the left side of f + ++ lhs(f) returns the left side of f rhs: % -> S2 - ++ rhs(f) returns the right side of f + ++ rhs(f) returns the right side of f Capsule == add Rep := Record(obj: S1, cond: S2) @@ -100079,8 +100283,7 @@ SuchThat(S1, S2): Cat == Capsule where ++ Author: Mike Dewar ++ Date Created: April 1991 -++ Date Last Updated: March 1994 -++ 30.6.94 Added coercion from Symbol MCD +++ Date Last Updated: March 1994 30.6.94 Added coercion from Symbol MCD ++ Basic Operations: ++ Related Constructors: FortranProgram, FortranCode, FortranTypes ++ Also See: @@ -100090,13 +100293,14 @@ SuchThat(S1, S2): Cat == Capsule where ++ Description: ++ This domain builds representations of boolean expressions for use with ++ the \axiomType{FortranCode} domain. + Switch():public == private where EXPR ==> Union(I:Expression Integer,F:Expression Float, CF:Expression Complex Float,switch:%) public == CoercibleTo OutputForm with coerce : Symbol -> $ - ++ coerce(s) \undocumented{} + ++ coerce(s) is not documented LT : (EXPR,EXPR) -> $ ++ LT(x,y) returns the \axiomType{Switch} expression representing \spad{x $ @@ -100589,9 +100793,10 @@ o )show Symbol ++ Author: Stephen Watt ++ Date Created: 1986 ++ Date Last Updated: 7 Mar 1991, 29 Apr. 1994 (FDLL) -++ Description: -++ Basic and scripted symbols. ++ Keywords: symbol. +++ Description: +++ Basic and scripted symbols. + Symbol(): Exports == Implementation where L ==> List OutputForm Scripts ==> Record(sub:L,sup:L,presup:L,presub:L,args:L) @@ -100936,7 +101141,9 @@ Symbol(): Exports == Implementation where ++ Keywords: ++ Examples: ++ References: -++ Description: Create and manipulate a symbol table for generated FORTRAN code +++ Description: +++ Create and manipulate a symbol table for generated FORTRAN code + SymbolTable() : exports == implementation where T ==> Union(S:Symbol,P:Polynomial Integer) @@ -100970,7 +101177,7 @@ SymbolTable() : exports == implementation where typeLists : $ -> L TL ++ typeLists(tab) returns a list of lists of types of objects in tab newTypeLists : $ -> SEX - ++ newTypeLists(x) \undocumented + ++ newTypeLists(x) is not documented printTypes: $ -> Void ++ printTypes(tab) produces FORTRAN type declarations from tab, on the ++ current FORTRAN output stream @@ -101172,8 +101379,10 @@ SymbolTable() : exports == implementation where <>= )abbrev domain SYMPOLY SymmetricPolynomial +++ Author: Mark Botch ++ Description: ++ This domain implements symmetric polynomial + SymmetricPolynomial(R:Ring) == PolynomialRing(R,Partition) add Term:= Record(k:Partition,c:R) Rep:= List Term @@ -101599,11 +101808,11 @@ o )show Table ++ Examples: ++ References: ++ Description: -++ 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} +++ 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} Table(Key: SetCategory, Entry: SetCategory):Exports == Implementation where Exports ==> TableAggregate(Key, Entry) with @@ -101646,9 +101855,8 @@ Table(Key: SetCategory, Entry: SetCategory):Exports == Implementation where ++ Description: ++ The tableau domain is for printing Young tableaux, and ++ coercions to and from List List S where S is a set. + Tableau(S:SetCategory):Exports == Implementation where - ++ The tableau domain is for printing Young tableaux, and - ++ coercions to and from List List S where S is a set. L ==> List I ==> Integer NNI ==> NonNegativeInteger @@ -101788,8 +101996,9 @@ Tableau(S:SetCategory):Exports == Implementation where ++ Examples: ++ References: ++ Description: -++ \spadtype{TaylorSeries} is a general multivariate Taylor series domain -++ over the ring Coef and with variables of type Symbol. +++ \spadtype{TaylorSeries} is a general multivariate Taylor series domain +++ over the ring Coef and with variables of type Symbol. + TaylorSeries(Coef): Exports == Implementation where Coef : Ring L ==> List @@ -102080,17 +102289,17 @@ o )show TexFormat ++ Keywords: TeX, LaTeX, output, format ++ References: \TeX{} is a trademark of the American Mathematical Society. ++ Description: -++ \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 ``\verb+\[+'' and ``\verb+\]+'', respectively, so that -++ the TeX section will be printed in LaTeX display math mode. +++ \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 ``\verb+\[+'' and ``\verb+\]+'', respectively, so that +++ the TeX section will be printed in LaTeX display math mode. TexFormat(): public == private where E ==> OutputForm @@ -102863,8 +103072,8 @@ o )show TextFile ++ Keywords: ++ References: ++ Description: -++ This domain provides an implementation of text files. Text is stored -++ in these files using the native character set of the computer. +++ This domain provides an implementation of text files. Text is stored +++ in these files using the native character set of the computer. TextFile: Cat == Def where StreamName ==> Union(FileName, "console") @@ -102984,9 +103193,11 @@ TextFile: Cat == Def where ++ Keywords: ++ Examples: ++ References: -++ Description: Creates and manipulates one global symbol table for FORTRAN +++ Description: +++ Creates and manipulates one global symbol table for FORTRAN ++ code generation, containing details of types, dimensions, and argument ++ lists. + TheSymbolTable() : Exports == Implementation where S ==> Symbol @@ -103241,6 +103452,7 @@ TheSymbolTable() : Exports == Implementation where ++ References: ++ Description: ++ This domain represents three dimensional matrices over a general object type + ThreeDimensionalMatrix(R) : Exports == Implementation where R : SetCategory @@ -103274,7 +103486,7 @@ ThreeDimensionalMatrix(R) : Exports == Implementation where ++ (PrimitiveArray PrimitiveArray PrimitiveArray R) ++ to the domain coerce : $ -> (PA PA PA R) - ++ coerce(x) moves from the domain to the representation type + ++ coerce(x) moves from the domain to the representation type matrixConcat3D : (Symbol,$,$) -> $ ++ matrixConcat3D(s,x,y) concatenates two 3-D matrices along a specified axis matrixDimensions : $ -> Vector NNI @@ -103543,20 +103755,22 @@ ThreeDimensionalMatrix(R) : Exports == Implementation where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: ThreeDimensionalViewport creates viewports to display graphs -VIEW ==> VIEWPORTSERVER$Lisp -sendI ==> SOCK_-SEND_-INT -sendSF ==> SOCK_-SEND_-FLOAT -sendSTR ==> SOCK_-SEND_-STRING -getI ==> SOCK_-GET_-INT -getSF ==> SOCK_-GET_-FLOAT +++ Description: +++ ThreeDimensionalViewport creates viewports to display graphs -typeVIEW3D ==> 1$I -typeVIEWTube ==> 4 +ThreeDimensionalViewport(): Exports == Implementation where + VIEW ==> VIEWPORTSERVER$Lisp + sendI ==> SOCK_-SEND_-INT + sendSF ==> SOCK_-SEND_-FLOAT + sendSTR ==> SOCK_-SEND_-STRING + getI ==> SOCK_-GET_-INT + getSF ==> SOCK_-GET_-FLOAT -makeVIEW3D ==> (-1)$SingleInteger + typeVIEW3D ==> 1$I + typeVIEWTube ==> 4 + + makeVIEW3D ==> (-1)$SingleInteger -ThreeDimensionalViewport(): Exports == Implementation where I ==> Integer PI ==> PositiveInteger NNI ==> NonNegativeInteger @@ -103748,14 +103962,14 @@ ThreeDimensionalViewport(): Exports == Implementation where ++ \spadtype{ThreeDimensionalViewport}. The new viewpoint position ++ is not displayed until the function \spadfun{makeViewport3D} is ++ executed again for v. - viewpoint : (%) -> V + viewpoint : (%) -> V ++ viewpoint(v) returns the current viewpoint setting of the given ++ viewport, v. This function is useful in the situation where the ++ user has created a viewport, proceeded to interact with it via ++ the control panel and desires to save the values of the viewpoint ++ as the default settings for another viewport to be created using ++ the system. - viewpoint : (%,V) -> Void + viewpoint : (%,V) -> Void ++ viewpoint(v,viewpt) sets the viewpoint for the viewport. The ++ viewport record consists of the latitudal and longitudal angles, ++ the zoom factor, the x,y and z scales, and the x and y displacements. @@ -104201,21 +104415,21 @@ ThreeDimensionalViewport(): Exports == Implementation where viewpoint (viewport:%):V == (key(viewport) ^= 0$I) => - sendI(VIEW,typeVIEW3D)$Lisp - sendI(VIEW,queryVIEWPOINT)$Lisp - checkViewport viewport => - deltaX_sf : SF := getSF(VIEW)$Lisp - deltaY_sf : SF := getSF(VIEW)$Lisp - scale_sf : SF := getSF(VIEW)$Lisp - scaleX_sf : SF := getSF(VIEW)$Lisp - scaleY_sf : SF := getSF(VIEW)$Lisp - scaleZ_sf : SF := getSF(VIEW)$Lisp - theta_sf : SF := getSF(VIEW)$Lisp - phi_sf : SF := getSF(VIEW)$Lisp + sendI(VIEW,typeVIEW3D)$Lisp + sendI(VIEW,queryVIEWPOINT)$Lisp + checkViewport viewport => + deltaX_sf : SF := getSF(VIEW)$Lisp + deltaY_sf : SF := getSF(VIEW)$Lisp + scale_sf : SF := getSF(VIEW)$Lisp + scaleX_sf : SF := getSF(VIEW)$Lisp + scaleY_sf : SF := getSF(VIEW)$Lisp + scaleZ_sf : SF := getSF(VIEW)$Lisp + theta_sf : SF := getSF(VIEW)$Lisp + phi_sf : SF := getSF(VIEW)$Lisp getI(VIEW)$Lisp -- acknowledge - viewport.viewpoint := - [ theta_sf, phi_sf, scale_sf, scaleX_sf, scaleY_sf, scaleZ_sf, - deltaX_sf, deltaY_sf ] + viewport.viewpoint := + [ theta_sf, phi_sf, scale_sf, scaleX_sf, scaleY_sf, scaleZ_sf, + deltaX_sf, deltaY_sf ] viewport.viewpoint viewpoint (viewport:%, viewpt:V):Void == @@ -104528,19 +104742,16 @@ ThreeDimensionalViewport(): Exports == Implementation where <>= )abbrev domain SPACE3 ThreeSpace -++ Author: +++ Author: Mark Botch ++ Date Created: ++ Date Last Updated: -++ Basic Operations: create3Space, numberOfComponents, numberOfComposites, -++ merge, composite, components, copy, enterPointData, modifyPointData, point, -++ point?, curve, curve?, closedCurve, closedCurve?, polygon, polygon? mesh, -++ mesh?, lp, lllip, lllp, llprop, lprop, objects, check, subspace, coerce ++ Related Constructors: ++ Also See: ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: The domain ThreeSpace is used for creating three dimensional +++ Description: +++ The domain ThreeSpace is used for creating three dimensional ++ objects using functions for defining points, curves, polygons, constructs ++ and the subspaces containing them. @@ -104948,9 +105159,11 @@ ThreeSpace(R:Ring):Exports == Implementation where ++ Keywords: ++ Examples: ++ References: -++ Description: \spadtype{Tree(S)} is a basic domains of tree structures. -++ Each tree is either empty or else is a {\it node} consisting of a value and +++ Description: +++ \spadtype{Tree(S)} is a basic domains of tree structures. +++ Each tree is either empty or else is a node consisting of a value and ++ a list of (sub)trees. + Tree(S: SetCategory): T==C where T== RecursiveAggregate(S) with finiteAggregate @@ -105300,8 +105513,9 @@ Tree(S: SetCategory): T==C where ++ Keywords: ++ Examples: ++ Description: -++ Package for constructing tubes around 3-dimensional parametric curves. +++ Package for constructing tubes around 3-dimensional parametric curves. ++ Domain of tubes around 3-dimensional parametric curves. + TubePlot(Curve): Exports == Implementation where Curve : PlottableSpaceCurveCategory B ==> Boolean @@ -105378,8 +105592,11 @@ TubePlot(Curve): Exports == Implementation where <>= )abbrev domain TUPLE Tuple +++ Author: Mark Botch +++ Description: ++ This domain is used to interface with the interpreter's notion ++ of comma-delimited sequences of values. + Tuple(S:Type): CoercibleTo(PrimitiveArray S) with coerce: PrimitiveArray S -> % ++ coerce(a) makes a tuple from primitive array a @@ -105928,9 +106145,12 @@ o )show TwoDimensionalArray <>= )abbrev domain ARRAY2 TwoDimensionalArray +++ Author: Mark Botch +++ Description: +++ A TwoDimensionalArray is a two dimensional array with +++ 1-based indexing for both rows and columns. + TwoDimensionalArray(R):Exports == Implementation where - ++ A TwoDimensionalArray is a two dimensional array with - ++ 1-based indexing for both rows and columns. R : Type Row ==> OneDimensionalArray R Col ==> OneDimensionalArray R @@ -106242,7 +106462,9 @@ o )show TwoDimensionalViewport ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: TwoDimensionalViewport creates viewports to display graphs. +++ Description: +++ TwoDimensionalViewport creates viewports to display graphs. + TwoDimensionalViewport ():Exports == Implementation where VIEW ==> VIEWPORTSERVER$Lisp @@ -106987,6 +107209,10 @@ TwoDimensionalViewport ():Exports == Implementation where <>= )abbrev domain UFPS UnivariateFormalPowerSeries +++ Author: Mark Botch +++ Description: +++ This domain has no description + UnivariateFormalPowerSeries(Coef: Ring) == UnivariateTaylorSeries(Coef, 'x, 0$Coef) @@ -107158,13 +107384,15 @@ UnivariateFormalPowerSeries(Coef: Ring) == ++ Keywords: series, Laurent ++ Examples: ++ References: -++ Description: Dense Laurent series in one variable -++ \spadtype{UnivariateLaurentSeries} is a domain representing Laurent -++ 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, -++ \spad{UnivariateLaurentSeries(Integer,x,3)} represents Laurent series in -++ \spad{(x - 3)} with integer coefficients. +++ Description: +++ Dense Laurent series in one variable +++ \spadtype{UnivariateLaurentSeries} is a domain representing Laurent +++ 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, +++ \spad{UnivariateLaurentSeries(Integer,x,3)} represents Laurent series in +++ \spad{(x - 3)} with integer coefficients. + UnivariateLaurentSeries(Coef,var,cen): Exports == Implementation where Coef : Ring var : Symbol @@ -107368,11 +107596,12 @@ UnivariateLaurentSeries(Coef,var,cen): Exports == Implementation where ++ Examples: ++ References: ++ Description: -++ 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 n is -++ an arbitrary integer and \spad{f(x)} is a Taylor series. This pair -++ represents the Laurent series \spad{x**n * f(x)}. +++ 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 n is +++ an arbitrary integer and \spad{f(x)} is a Taylor series. This pair +++ represents the Laurent series \spad{x**n * f(x)}. + UnivariateLaurentSeriesConstructor(Coef,UTS):_ Exports == Implementation where Coef : Ring @@ -107603,10 +107832,10 @@ UnivariateLaurentSeriesConstructor(Coef,UTS):_ --Frederic Lehobey x exquo y == x := removeZeroes(1000,x) - y := removeZeroes(1000,y) - zero? coefficient(y, d := degree y) => "failed" - (uts := (getUTS x) exquo (getUTS y)) case "failed" => "failed" - laurent(degree x-d,uts :: UTS) + y := removeZeroes(1000,y) + zero? coefficient(y, d := degree y) => "failed" + (uts := (getUTS x) exquo (getUTS y)) case "failed" => "failed" + laurent(degree x-d,uts :: UTS) if Coef has coerce: Symbol -> Coef then if Coef has "**": (Coef,I) -> Coef then @@ -108569,7 +108798,7 @@ o )show UnivariatePolynomial <>= )abbrev domain UP UnivariatePolynomial -++ Author: +++ Author: Mark Botch ++ Date Created: ++ Date Last Updated: ++ Basic Functions: Ring, monomial, coefficient, reductum, differentiate, @@ -108584,7 +108813,8 @@ o )show UnivariatePolynomial ++ over arbitrary (not necessarily commutative) coefficient rings. ++ The representation is sparse ++ in the sense that only non-zero terms are represented. -++ Note: if the coefficient ring is a field, then this domain forms a euclidean domain. +++ Note that if the coefficient ring is a field, then this domain +++ forms a euclidean domain. UnivariatePolynomial(x:Symbol, R:Ring): UnivariatePolynomialCategory(R) with @@ -108731,13 +108961,15 @@ UnivariatePolynomial(x:Symbol, R:Ring): ++ Keywords: series, Puiseux ++ Examples: ++ References: -++ Description: Dense Puiseux series in one variable -++ \spadtype{UnivariatePuiseuxSeries} is a domain representing Puiseux -++ 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, -++ \spad{UnivariatePuiseuxSeries(Integer,x,3)} represents Puiseux series in -++ \spad{(x - 3)} with \spadtype{Integer} coefficients. +++ Description: +++ Dense Puiseux series in one variable +++ \spadtype{UnivariatePuiseuxSeries} is a domain representing Puiseux +++ 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, +++ \spad{UnivariatePuiseuxSeries(Integer,x,3)} represents Puiseux series in +++ \spad{(x - 3)} with \spadtype{Integer} coefficients. + UnivariatePuiseuxSeries(Coef,var,cen): Exports == Implementation where Coef : Ring var : Symbol @@ -109012,11 +109244,11 @@ UnivariatePuiseuxSeries(Coef,var,cen): Exports == Implementation where ++ Examples: ++ References: ++ Description: -++ 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 r is -++ a positive rational number and \spad{f(x)} is a Laurent series. -++ This pair represents the Puiseux series \spad{f(x^r)}. +++ 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 r is +++ a positive rational number and \spad{f(x)} is a Laurent series. +++ This pair represents the Puiseux series \spad{f(x^r)}. UnivariatePuiseuxSeriesConstructor(Coef,ULS):_ Exports == Implementation where @@ -109430,14 +109662,15 @@ UnivariatePuiseuxSeriesConstructor(Coef,ULS):_ ++ Examples: ++ References: ++ Description: -++ 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 g(x) is a univariate Puiseux series -++ and f(x) is a univariate Puiseux series with no terms of non-negative -++ degree. +++ 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 g(x) is a univariate Puiseux series +++ and f(x) is a univariate Puiseux series with no terms of non-negative +++ degree. + UnivariatePuiseuxSeriesWithExponentialSingularity(R,FE,var,cen):_ Exports == Implementation where R : Join(OrderedSet,RetractableTo Integer,_ @@ -110446,9 +110679,10 @@ o )show SquareMatrix ++ Date Created: 19 October 1993 ++ Date Last Updated: 1 February 1994 ++ Description: -++ 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}. +++ 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}. + UnivariateSkewPolynomial(x:Symbol,R:Ring,sigma:Automorphism R,delta: R -> R): UnivariateSkewPolynomialCategory R with coerce: Variable x -> % @@ -110581,7 +110815,8 @@ UnivariateSkewPolynomial(x:Symbol,R:Ring,sigma:Automorphism R,delta: R -> R): ++ Keywords: dense, Taylor series ++ Examples: ++ References: -++ Description: Dense Taylor series in one variable +++ Description: +++ 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 @@ -110590,6 +110825,7 @@ UnivariateSkewPolynomial(x:Symbol,R:Ring,sigma:Automorphism R,delta: R -> R): ++ \spadtype{UnivariateTaylorSeries}(Integer,x,3) represents ++ Taylor series in ++ \spad{(x - 3)} with \spadtype{Integer} coefficients. + UnivariateTaylorSeries(Coef,var,cen): Exports == Implementation where Coef : Ring var : Symbol @@ -110813,7 +111049,7 @@ UnivariateTaylorSeries(Coef,var,cen): Exports == Implementation where error "integrate: center is a function of variable of integration" if Coef has TranscendentalFunctionCategory and _ - Coef has PrimitiveFunctionCategory and _ + Coef has PrimitiveFunctionCategory and _ Coef has AlgebraicallyClosedFunctionSpace Integer then integrateWithOneAnswer: (Coef,Symbol) -> Coef @@ -111024,8 +111260,8 @@ o )show UniversalSegment ++ Examples: ++ References: ++ Description: -++ This domain provides segments which may be half open. -++ That is, ranges of the form \spad{a..} or \spad{a..b}. +++ This domain provides segments which may be half open. +++ That is, ranges of the form \spad{a..} or \spad{a..b}. UniversalSegment(S: Type): SegmentCategory(S) with SEGMENT: S -> % @@ -111105,13 +111341,13 @@ UniversalSegment(S: Type): SegmentCategory(S) with false coerce(s: %): OutputForm == - seg := - e := (lo s)::OutputForm - hasHi s => SEGMENT(e, (hi s)::OutputForm) - SEGMENT e - inc := incr s - inc = 1 => seg - infix(" by "::OutputForm, seg, inc::OutputForm) + seg := + e := (lo s)::OutputForm + hasHi s => SEGMENT(e, (hi s)::OutputForm) + SEGMENT e + inc := incr s + inc = 1 => seg + infix(" by "::OutputForm, seg, inc::OutputForm) if S has OrderedRing then expand(s:%) == expand([s]) @@ -111162,13 +111398,15 @@ UniversalSegment(S: Type): SegmentCategory(S) with <>= )abbrev domain VARIABLE Variable +++ Author: Mark Botch ++ Description: ++ This domain implements variables + Variable(sym:Symbol): Join(SetCategory, CoercibleTo Symbol) with coerce : % -> Symbol - ++ coerce(x) returns the symbol + ++ coerce(x) returns the symbol variable: () -> Symbol - ++ variable() returns the symbol + ++ variable() returns the symbol == add coerce(x:%):Symbol == sym coerce(x:%):OutputForm == sym::OutputForm @@ -111462,7 +111700,7 @@ o )show Vector <>= )abbrev domain VECTOR Vector -++ Author: +++ Author: Mark Botch ++ Date Created: ++ Date Last Updated: ++ Basic Functions: @@ -111618,10 +111856,10 @@ o )show Void ++ Examples: ++ References: ++ Description: -++ This type is used when no value is needed, 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. +++ This type is used when no value is needed, 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. Void: with void: () -> % @@ -111699,15 +111937,17 @@ WeightedPolynomials(R:Ring,VarSet: OrderedSet, E:OrderedAbelianMonoidSup, Ring with if R has CommutativeRing then Algebra(R) coerce: $ -> P - ++ convert back into a "P", ignoring weights + ++ convert back into a "P", ignoring weights if R has Field then "/": ($,$) -> Union($,"failed") - ++ x/y division (only works if minimum weight - ++ of divisor is zero, and if R is a Field) + ++ x/y division (only works if minimum weight + ++ of divisor is zero, and if R is a Field) coerce: P -> $ - ++ coerce(p) coerces p into Weighted form, applying weights and ignoring terms + ++ coerce(p) coerces p into Weighted form, + ++ applying weights and ignoring terms changeWeightLevel: NonNegativeInteger -> Void - ++ changeWeightLevel(n) changes the weight level to the new value given: - ++ NB: previously calculated terms are not affected + ++ changeWeightLevel(n) changes the weight level to + ++ the new value given: + ++ NB: previously calculated terms are not affected == add --representations @@ -112196,22 +112436,22 @@ o )show WuWenTsunTriangularSet ++ Also See: ++ AMS Classifications: ++ Keywords: -++ Description: A domain constructor of the category \axiomType{GeneralTriangularSet}. +++ References : +++ [1] W. T. WU "A Zero Structure Theorem for polynomial equations solving" +++ MM Research Preprints, 1987. +++ [2] D. M. WANG "An implementation of the characteristic set method in Maple" +++ Proc. DISCO'92. Bath, England. +++ Description: +++ A domain constructor of the category \axiomType{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 \axiomOpFrom{construct}{WuWenTsunTriangularSet} operation +++ not be auto-reduced or consistent. The construct operation ++ does not check the previous requirement. Triangular sets are stored ++ as sorted lists w.r.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 -++ References : -++ [1] W. T. WU "A Zero Structure Theorem for polynomial equations solving" -++ MM Research Preprints, 1987. -++ [2] D. M. WANG "An implementation of the characteristic set method in Maple" -++ Proc. DISCO'92. Bath, England. -++ Version: 3 +++ mainly proposed by Dong Ming Wang. WuWenTsunTriangularSet(R,E,V,P) : Exports == Implementation where @@ -112514,11 +112754,10 @@ equivalent for the ++ Keywords: ++ References: ++ Description: -++ This type supports distributed multivariate polynomials +++ This type supports distributed multivariate polynomials ++ whose variables do not commute. ++ The coefficient ring may be non-commutative too. ++ However, coefficients and variables commute. -++ Author: Michel Petitot (petitot@lifl.fr) XDistributedPolynomial(vl:OrderedSet,R:Ring): XDPcat == XDPdef where @@ -113530,7 +113769,7 @@ o )show XPBWPolynomial ++ 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.fr). +++ relations. XPBWPolynomial(VarSet:OrderedSet,R:CommutativeRing): XDPcat == XDPdef where @@ -114068,13 +114307,10 @@ o )show XPolynomial ++ Keywords: ++ References: ++ Description: -++ This type supports multivariate polynomials -++ whose set of variables is \spadtype{Symbol}. -++ The representation is recursive. +++ 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. -++ Author: Michel Petitot (petitot@lifl.fr) +++ do not commute. However, coefficients and variables commute. XPolynomial(R:Ring) == XRecursivePolynomial(Symbol, R) @@ -114536,7 +114772,6 @@ o )show XPolynomialRing ++ belonging to an arbitrary \spadtype{OrderedMonoid}. ++ This type is used, for instance, by the \spadtype{XDistributedPolynomial} ++ domain constructor where the Monoid is free. -++ Author: Michel Petitot (petitot@lifl.fr) XPolynomialRing(R:Ring,E:OrderedMonoid): T == C where TERM ==> Record(k: E, c: R) @@ -114756,12 +114991,9 @@ equivalents for the {\bf SparseMultivariatePolynomial} constructor. ++ Keywords: ++ References: ++ Description: -++ 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. -++ Author: Michel Petitot (petitot@lifl.fr) +++ 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. XRecursivePolynomial(VarSet:OrderedSet,R:Ring): Xcat == Xdef where I ==> Integer diff --git a/books/bookvol10.4.pamphlet b/books/bookvol10.4.pamphlet index 8da962b..d2f5d74 100644 --- a/books/bookvol10.4.pamphlet +++ b/books/bookvol10.4.pamphlet @@ -290,9 +290,9 @@ in the bootstrap set. Thus, ++ Author: Manuel Bronstein ++ Date Created: 21 March 1988 ++ Date Last Updated: 11 November 1993 -++ Description: -++ This package provides algebraic functions over an integral domain. ++ Keywords: algebraic, function. +++ Description: +++ This package provides algebraic functions over an integral domain. AlgebraicFunction(R, F): Exports == Implementation where R: Join(OrderedSet, IntegralDomain) @@ -550,11 +550,12 @@ AlgebraicFunction(R, F): Exports == Implementation where <>= )abbrev package INTHERAL AlgebraicHermiteIntegration -++ Hermite integration, algebraic case ++ Author: Manuel Bronstein ++ Date Created: 1987 ++ Date Last Updated: 25 July 1990 -++ Description: algebraic Hermite redution. +++ Description: +++ Algebraic Hermite reduction. + AlgebraicHermiteIntegration(F,UP,UPUP,R):Exports == Implementation where F : Field UP : UnivariatePolynomialCategory F @@ -643,13 +644,13 @@ AlgebraicHermiteIntegration(F,UP,UPUP,R):Exports == Implementation where <>= )abbrev package INTALG AlgebraicIntegrate -++ Integration of an algebraic function ++ Author: Manuel Bronstein ++ Date Created: 1987 ++ Date Last Updated: 19 May 1993 ++ Description: ++ This package provides functions for integrating a function ++ on an algebraic curve. + AlgebraicIntegrate(R0, F, UP, UPUP, R): Exports == Implementation where R0 : Join(OrderedSet, IntegralDomain, RetractableTo Integer) F : Join(AlgebraicallyClosedField, FunctionSpace R0) @@ -961,13 +962,13 @@ AlgebraicIntegrate(R0, F, UP, UPUP, R): Exports == Implementation where <>= )abbrev package INTAF AlgebraicIntegration -++ Mixed algebraic integration; ++ Author: Manuel Bronstein ++ Date Created: 12 October 1988 ++ Date Last Updated: 4 June 1988 ++ Description: ++ This package provides functions for the integration of ++ algebraic integrands over transcendental functions; + AlgebraicIntegration(R, F): Exports == Implementation where R : Join(OrderedSet, IntegralDomain) F : Join(AlgebraicallyClosedField, FunctionSpace R) @@ -1063,19 +1064,20 @@ AlgebraicIntegration(R, F): Exports == Implementation where ++ Author: Manuel Bronstein ++ Date Created: 28 Mar 1988 ++ Date Last Updated: 5 August 1993 +++ Keywords: algebraic, manipulation. ++ Description: ++ AlgebraicManipulations provides functions to simplify and expand ++ expressions involving algebraic operators. -++ Keywords: algebraic, manipulation. + AlgebraicManipulations(R, F): Exports == Implementation where R : IntegralDomain F : Join(Field, ExpressionSpace) with numer : $ -> SparseMultivariatePolynomial(R, Kernel $) - ++ numer(x) \undocumented + ++ numer(x) \undocumented denom : $ -> SparseMultivariatePolynomial(R, Kernel $) - ++ denom(x) \undocumented + ++ denom(x) \undocumented coerce : SparseMultivariatePolynomial(R, Kernel $) -> $ - ++ coerce(x) \undocumented + ++ coerce(x) \undocumented N ==> NonNegativeInteger Z ==> Integer @@ -1389,8 +1391,9 @@ AlgebraicMultFact(OV,E,P) : C == T ++ Lectures Notes in Biomathematics 36, ++ Springer-Verlag, Heidelberg, 1980 ++ Description: -++ AlgebraPackage assembles a variety of useful functions for -++ general algebras. +++ AlgebraPackage assembles a variety of useful functions for +++ general algebras. + AlgebraPackage(R:IntegralDomain, A: FramedNonAssociativeAlgebra(R)): _ public == private where @@ -1426,10 +1429,8 @@ AlgebraPackage(R:IntegralDomain, A: FramedNonAssociativeAlgebra(R)): _ ++ 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. + ++ Note that if \spad{A} has a unit, + ++ then doubleRank, weakBiRank, and biRank coincide. basisOfCommutingElements: () -> List A ++ basisOfCommutingElements() returns a basis of the space of ++ all x of \spad{A} satisfying \spad{0 = commutator(x,a)} for all @@ -1465,12 +1466,12 @@ AlgebraPackage(R:IntegralDomain, A: FramedNonAssociativeAlgebra(R)): _ basisOfLeftNucloid:()-> List Matrix R ++ basisOfLeftNucloid() returns a basis of the space of ++ endomorphisms of \spad{A} as right module. - ++ Note: left nucloid coincides with left nucleus + ++ Note that left nucloid coincides with left nucleus ++ if \spad{A} has a unit. basisOfRightNucloid:()-> List Matrix R ++ basisOfRightNucloid() returns a basis of the space of ++ endomorphisms of \spad{A} as left module. - ++ Note: right nucloid coincides with right nucleus + ++ Note that right nucloid coincides with right nucleus ++ if \spad{A} has a unit. basisOfCentroid:()-> List Matrix R ++ basisOfCentroid() returns a basis of the centroid, i.e. the @@ -1851,7 +1852,6 @@ AlgebraPackage(R:IntegralDomain, A: FramedNonAssociativeAlgebra(R)): _ <>= )abbrev package ALGFACT AlgFactor -++ Factorization of UP AN; ++ Author: Manuel Bronstein ++ Date Created: ??? ++ Date Last Updated: ??? @@ -1986,32 +1986,32 @@ AlgFactor(UP): Exports == Implementation where ++ of functions for the \axiom{category} ++ \axiomType{NumericalIntegrationCategory} ++ with \axiom{measure}, and \axiom{integrate}. -EDF ==> Expression DoubleFloat -DF ==> DoubleFloat -EF ==> Expression Float -F ==> Float -INT ==> Integer -SOCDF ==> Segment OrderedCompletion DoubleFloat -OCDF ==> OrderedCompletion DoubleFloat -SBOCF ==> SegmentBinding OrderedCompletion Float -LSOCF ==> List Segment OrderedCompletion Float -SOCF ==> Segment OrderedCompletion Float -OCF ==> OrderedCompletion Float -LS ==> List Symbol -S ==> Symbol -LST ==> List String -ST ==> String -RT ==> RoutinesTable -NIA ==> Record(var:S, fn:EDF, range:SOCDF, abserr:DF, relerr:DF) -MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) -IFL ==> List(Record(ifail:Integer,instruction:String)) -Entry ==> Record(chapter:String, type:String, domainName: String, - defaultMin:F, measure:F, failList:IFL, explList:List String) -Measure ==> Record(measure:F, name:ST, explanations:LST, extra:Result) - - -AnnaNumericalIntegrationPackage(): with +AnnaNumericalIntegrationPackage(): EE == II where + + EDF ==> Expression DoubleFloat + DF ==> DoubleFloat + EF ==> Expression Float + F ==> Float + INT ==> Integer + SOCDF ==> Segment OrderedCompletion DoubleFloat + OCDF ==> OrderedCompletion DoubleFloat + SBOCF ==> SegmentBinding OrderedCompletion Float + LSOCF ==> List Segment OrderedCompletion Float + SOCF ==> Segment OrderedCompletion Float + OCF ==> OrderedCompletion Float + LS ==> List Symbol + S ==> Symbol + LST ==> List String + ST ==> String + RT ==> RoutinesTable + NIA ==> Record(var:S, fn:EDF, range:SOCDF, abserr:DF, relerr:DF) + MDNIA ==> Record(fn:EDF,range:List SOCDF,abserr:DF,relerr:DF) + IFL ==> List(Record(ifail:Integer,instruction:String)) + Entry ==> Record(chapter:String, type:String, domainName: String, + defaultMin:F, measure:F, failList:IFL, explList:List String) + Measure ==> Record(measure:F, name:ST, explanations:LST, extra:Result) + EE ==> with integrate: (EF,SOCF,F,F,RT) -> Result ++ integrate(exp, a..b, epsrel, routines) is a top level ANNA function ++ to integrate an expression, {\tt exp}, over a given range {\tt a} @@ -2183,7 +2183,7 @@ AnnaNumericalIntegrationPackage(): with ++ i.e. have the best \axiom{measure}. ++ ++ It then performs the integration of the given expression - ++ on that \axiom{domain}.\newline + ++ on that \axiom{domain}. ++ ++ Default values for the absolute and relative error are used. ++ @@ -2200,13 +2200,13 @@ AnnaNumericalIntegrationPackage(): with ++ i.e. have the best \axiom{measure}. ++ ++ It then performs the integration of the given expression - ++ on that \axiom{domain}.\newline + ++ on that \axiom{domain}. ++ ++ Default values for the absolute and relative error are used. ++ ++ It is an error if the last argument is not {\tt numerical}. - == add + II ==> add zeroMeasure: Measure -> Result scriptedVariables?: MDNIA -> Boolean @@ -2503,33 +2503,36 @@ AnnaNumericalIntegrationPackage(): with ++ \axiomType{AnnaNumericalOptimizationPackage} is a \axiom{package} of ++ functions for the \axiomType{NumericalOptimizationCategory} ++ with \axiom{measure} and \axiom{optimize}. -EDF ==> Expression DoubleFloat -LEDF ==> List Expression DoubleFloat -LDF ==> List DoubleFloat -MDF ==> Matrix DoubleFloat -DF ==> DoubleFloat -LOCDF ==> List OrderedCompletion DoubleFloat -OCDF ==> OrderedCompletion DoubleFloat -LOCF ==> List OrderedCompletion Float -OCF ==> OrderedCompletion Float -LEF ==> List Expression Float -EF ==> Expression Float -LF ==> List Float -F ==> Float -LS ==> List Symbol -LST ==> List String -INT ==> Integer -NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) -LSA ==> Record(lfn:LEDF, init:LDF) -IFL ==> List(Record(ifail:Integer,instruction:String)) -Entry ==> Record(chapter:String, type:String, domainName: String, + +AnnaNumericalOptimizationPackage(): EE == II where + + EDF ==> Expression DoubleFloat + LEDF ==> List Expression DoubleFloat + LDF ==> List DoubleFloat + MDF ==> Matrix DoubleFloat + DF ==> DoubleFloat + LOCDF ==> List OrderedCompletion DoubleFloat + OCDF ==> OrderedCompletion DoubleFloat + LOCF ==> List OrderedCompletion Float + OCF ==> OrderedCompletion Float + LEF ==> List Expression Float + EF ==> Expression Float + LF ==> List Float + F ==> Float + LS ==> List Symbol + LST ==> List String + INT ==> Integer + NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) + LSA ==> Record(lfn:LEDF, init:LDF) + IFL ==> List(Record(ifail:Integer,instruction:String)) + Entry ==> Record(chapter:String, type:String, domainName: String, defaultMin:F, measure:F, failList:IFL, explList:LST) -Measure ==> Record(measure:F,name:String, explanations:List String) -Measure2 ==> Record(measure:F,explanations:String) -RT ==> RoutinesTable -UNOALSA ==> Union(noa:NOA,lsa:LSA) + Measure ==> Record(measure:F,name:String, explanations:List String) + Measure2 ==> Record(measure:F,explanations:String) + RT ==> RoutinesTable + UNOALSA ==> Union(noa:NOA,lsa:LSA) -AnnaNumericalOptimizationPackage(): with + EE ==> with measure:NumericalOptimizationProblem -> Measure ++ measure(prob) is a top level ANNA function for identifying the most ++ appropriate numerical routine from those in the routines table @@ -2678,7 +2681,7 @@ AnnaNumericalOptimizationPackage(): with ++ \axiom{measure} and then optimize the function on that \axiom{domain}. ++ It then checks the goodness of fit of the least squares model. - == add + II ==> add preAnalysis:RT -> RT zeroMeasure:Measure -> Result @@ -2911,37 +2914,40 @@ AnnaNumericalOptimizationPackage(): with ++ Basic Operations: solve, measure ++ Description: ++ \axiomType{AnnaOrdinaryDifferentialEquationPackage} is a \axiom{package} -++ of functions for the \axiom{category} \axiomType{OrdinaryDifferentialEquationsSolverCategory} +++ of functions for the \axiom{category} +++ \axiomType{OrdinaryDifferentialEquationsSolverCategory} ++ with \axiom{measure}, and \axiom{solve}. -++ -EDF ==> Expression DoubleFloat -LDF ==> List DoubleFloat -MDF ==> Matrix DoubleFloat -DF ==> DoubleFloat -FI ==> Fraction Integer -EFI ==> Expression Fraction Integer -SOCDF ==> Segment OrderedCompletion DoubleFloat -VEDF ==> Vector Expression DoubleFloat -VEF ==> Vector Expression Float -EF ==> Expression Float -LF ==> List Float -F ==> Float -VDF ==> Vector DoubleFloat -VMF ==> Vector MachineFloat -MF ==> MachineFloat -LS ==> List Symbol -ST ==> String -LST ==> List String -INT ==> Integer -RT ==> RoutinesTable -ODEA ==> Record(xinit:DF,xend:DF,fn:VEDF,yinit:LDF,intvals:LDF,_ + +AnnaOrdinaryDifferentialEquationPackage(): EE == II where + + EDF ==> Expression DoubleFloat + LDF ==> List DoubleFloat + MDF ==> Matrix DoubleFloat + DF ==> DoubleFloat + FI ==> Fraction Integer + EFI ==> Expression Fraction Integer + SOCDF ==> Segment OrderedCompletion DoubleFloat + VEDF ==> Vector Expression DoubleFloat + VEF ==> Vector Expression Float + EF ==> Expression Float + LF ==> List Float + F ==> Float + VDF ==> Vector DoubleFloat + VMF ==> Vector MachineFloat + MF ==> MachineFloat + LS ==> List Symbol + ST ==> String + LST ==> List String + INT ==> Integer + RT ==> RoutinesTable + ODEA ==> Record(xinit:DF,xend:DF,fn:VEDF,yinit:LDF,intvals:LDF,_ g:EDF,abserr:DF,relerr:DF) -IFL ==> List(Record(ifail:Integer,instruction:String)) -Entry ==> Record(chapter:String, type:String, domainName: String, - defaultMin:F, measure:F, failList:IFL, explList:LST) -Measure ==> Record(measure:F,name:String, explanations:List String) + IFL ==> List(Record(ifail:Integer,instruction:String)) + Entry ==> Record(chapter:String, type:String, domainName: String, + defaultMin:F, measure:F, failList:IFL, explList:LST) + Measure ==> Record(measure:F,name:String, explanations:List String) -AnnaOrdinaryDifferentialEquationPackage(): with + EE ==> with solve:(NumericalODEProblem) -> Result ++ solve(odeProblem) is a top level ANNA function to solve numerically a ++ system of ordinary differential equations i.e. equations for the @@ -3154,7 +3160,7 @@ AnnaOrdinaryDifferentialEquationPackage(): with ++ by checking various attributes of the system of ODEs and calculating ++ a measure of compatibility of each routine to these attributes. - == add + II ==> add import ODEA,NumericalODEProblem @@ -3329,39 +3335,41 @@ AnnaOrdinaryDifferentialEquationPackage(): with ++ Date Created: June 1996 ++ Date Last Updated: December 1997 ++ Basic Operations: -++ Description: AnnaPartialDifferentialEquationPackage is an uncompleted +++ Description: +++ AnnaPartialDifferentialEquationPackage is an uncompleted ++ package for the interface to NAG PDE routines. It has been realised that ++ a new approach to solving PDEs will need to be created. -++ -LEDF ==> List Expression DoubleFloat -EDF ==> Expression DoubleFloat -LDF ==> List DoubleFloat -MDF ==> Matrix DoubleFloat -DF ==> DoubleFloat -LEF ==> List Expression Float -EF ==> Expression Float -MEF ==> Matrix Expression Float -LF ==> List Float -F ==> Float -LS ==> List Symbol -ST ==> String -LST ==> List String -INT ==> Integer -NNI ==> NonNegativeInteger -RT ==> RoutinesTable -PDEC ==> Record(start:DF, finish:DF, grid:NNI, boundaryType:INT, - dStart:MDF, dFinish:MDF) -PDEB ==> Record(pde:LEDF, constraints:List PDEC, - f:List LEDF, st:ST, tol:DF) -IFL ==> List(Record(ifail:INT,instruction:ST)) -Entry ==> Record(chapter:ST, type:ST, domainName: ST, - defaultMin:F, measure:F, failList:IFL, explList:LST) -Measure ==> Record(measure:F,name:ST, explanations:LST) -AnnaPartialDifferentialEquationPackage(): with +AnnaPartialDifferentialEquationPackage(): EE == II where + LEDF ==> List Expression DoubleFloat + EDF ==> Expression DoubleFloat + LDF ==> List DoubleFloat + MDF ==> Matrix DoubleFloat + DF ==> DoubleFloat + LEF ==> List Expression Float + EF ==> Expression Float + MEF ==> Matrix Expression Float + LF ==> List Float + F ==> Float + LS ==> List Symbol + ST ==> String + LST ==> List String + INT ==> Integer + NNI ==> NonNegativeInteger + RT ==> RoutinesTable + PDEC ==> Record(start:DF, finish:DF, grid:NNI, boundaryType:INT, + dStart:MDF, dFinish:MDF) + PDEB ==> Record(pde:LEDF, constraints:List PDEC, + f:List LEDF, st:ST, tol:DF) + IFL ==> List(Record(ifail:INT,instruction:ST)) + Entry ==> Record(chapter:ST, type:ST, domainName: ST, + defaultMin:F, measure:F, failList:IFL, explList:LST) + Measure ==> Record(measure:F,name:ST, explanations:LST) + + EE ==> with solve:(NumericalPDEProblem) -> Result - ++ solve(PDEProblem) is a top level ANNA function to solve numerically a system - ++ of partial differential equations. + ++ solve(PDEProblem) is a top level ANNA function to solve numerically + ++ a system of partial differential equations. ++ ++ The method used to perform the numerical ++ process will be one of the routines contained in the NAG numerical @@ -3459,7 +3467,7 @@ AnnaPartialDifferentialEquationPackage(): with ++ a measure of compatibility of each routine to these attributes. - == add + II ==> add import PDEB, d03AgentsPackage, ExpertSystemToolsPackage, NumericalPDEProblem @@ -3605,10 +3613,10 @@ AnnaPartialDifferentialEquationPackage(): with ++ AMS Classification: ++ Keywords: ++ Description: -++ \spadtype{AnyFunctions1} implements several utility functions for -++ working with \spadtype{Any}. These functions are used to go back -++ and forth between objects of \spadtype{Any} and objects of other -++ types. +++ \spadtype{AnyFunctions1} implements several utility functions for +++ working with \spadtype{Any}. These functions are used to go back +++ and forth between objects of \spadtype{Any} and objects of other +++ types. AnyFunctions1(S:Type): with coerce : S -> Any @@ -3847,8 +3855,9 @@ The summary function prints a short list of useful console commands. ++ Author: Timothy Daly, Martin Rubey ++ Date Created: 3 March 2009 ++ Date Last Updated: 3 March 2009 -++ Description: This package contains useful functions that -++ expose Axiom system internals +++ Description: +++ This package contains useful functions that expose Axiom system internals + ApplicationProgramInterface(): Exports == Implementation where Exports ==> with getDomains : Symbol -> Set Symbol @@ -3897,10 +3906,11 @@ ApplicationProgramInterface(): Exports == Implementation where ++ Author: Manuel Bronstein ++ Date Created: 20 Mar 1990 ++ Date Last Updated: 5 Jul 1990 -++ Description: -++ This package apply rewrite rules to expressions, calling -++ the pattern matcher. ++ Keywords: pattern, matching, rule. +++ Description: +++ This package apply rewrite rules to expressions, calling +++ the pattern matcher. + ApplyRules(Base, R, F): Exports == Implementation where Base : SetCategory R : Join(Ring, PatternMatchable Base, OrderedSet, @@ -4030,8 +4040,9 @@ ApplyRules(Base, R, F): Exports == Implementation where ++ Date Created: 7 December 1993 ++ Date Last Updated: 1 February 1994 ++ Description: -++ \spad{ApplyUnivariateSkewPolynomial} (internal) allows univariate -++ skew polynomials to be applied to appropriate modules. +++ \spad{ApplyUnivariateSkewPolynomial} (internal) allows univariate +++ skew polynomials to be applied to appropriate modules. + ApplyUnivariateSkewPolynomial(R:Ring, M: LeftModule R, P: UnivariateSkewPolynomialCategory R): with apply: (P, M -> M, M) -> M @@ -4074,6 +4085,7 @@ ApplyUnivariateSkewPolynomial(R:Ring, M: LeftModule R, ++ Description: ++ \spadtype{AssociatedEquations} provides functions to compute the ++ associated equations needed for factoring operators + AssociatedEquations(R, L):Exports == Implementation where R: IntegralDomain L: LinearOrdinaryDifferentialOperatorCategory R @@ -4192,10 +4204,12 @@ AssociatedEquations(R, L):Exports == Implementation where )abbrev package PMPRED AttachPredicates ++ Predicates for pattern-matching ++ Author: Manuel Bronstein -++ Description: Attaching predicates to symbols for pattern matching. ++ Date Created: 21 Mar 1989 ++ Date Last Updated: 23 May 1990 ++ Keywords: pattern, matching. +++ Description: +++ Attaching predicates to symbols for pattern matching. + AttachPredicates(D:Type): Exports == Implementation where FE ==> Expression Integer @@ -4236,6 +4250,11 @@ AttachPredicates(D:Type): Exports == Implementation where <>= )abbrev package AXSERV AxiomServer +++ Author: Arthur Ralfs, Timothy Daly, Alfredo Portes +++ Description: +++ This package provides a functions to support a web server for the +++ new Axiom Browser functions. + AxiomServer: public == private where public == with @@ -4939,7 +4958,9 @@ input. ++ Author: Manuel Bronstein ++ Date Created: 1 March 1991 ++ Date Last Updated: 11 October 1991 -++ Description: This package provides balanced factorisations of polynomials. +++ Description: +++ This package provides balanced factorisations of polynomials. + BalancedFactorisation(R, UP): Exports == Implementation where R : Join(GcdDomain, CharacteristicZero) UP : UnivariatePolynomialCategory R @@ -4999,14 +5020,14 @@ BalancedFactorisation(R, UP): Exports == Implementation where <>= )abbrev package BOP1 BasicOperatorFunctions1 -++ Tools to set/get common properties of operators ++ Author: Manuel Bronstein ++ Date Created: 28 Mar 1988 ++ Date Last Updated: 15 May 1990 -++ Description: -++ This package exports functions to set some commonly used properties -++ of operators, including properties which contain functions. ++ Keywords: operator. +++ Description: +++ This package exports functions to set some commonly used properties +++ of operators, including properties which contain functions. + BasicOperatorFunctions1(A:SetCategory): Exports == Implementation where OP ==> BasicOperator EVAL ==> "%eval" @@ -5321,7 +5342,9 @@ o )d op makeViewport2D )abbrev package BEZIER Bezier ++ Author: Timothy Daly ++ Date Created: 14 April 2009 -++ Description: Provide linear, quadratic, and cubic spline bezier curves +++ Description: +++ Provide linear, quadratic, and cubic spline bezier curves + Bezier(R:Ring): with linearBezier: (x:List R,y:List R) -> Mapping(List R,R) ++ A linear Bezier curve is a simple interpolation between the @@ -5403,8 +5426,8 @@ Bezier(R:Ring): with ++ Reference: Knuth, The Art of Computer Programming, 2nd edition, ++ Vol. 2, p. 619, problem 12. ++ Description: -++ \spadtype{BezoutMatrix} contains functions for computing resultants and -++ discriminants using Bezout matrices. +++ \spadtype{BezoutMatrix} contains functions for computing resultants and +++ discriminants using Bezout matrices. BezoutMatrix(R,UP,M,Row,Col): Exports == Implementation where R : Ring @@ -5560,8 +5583,9 @@ BezoutMatrix(R,UP,M,Row,Col): Exports == Implementation where ++ Date Created: 11 March 1991 ++ Date Last Updated: 18 November 1991 ++ Description: -++ \spadtype{BoundIntegerRoots} provides functions to -++ find lower bounds on the integer roots of a polynomial. +++ \spadtype{BoundIntegerRoots} provides functions to +++ find lower bounds on the integer roots of a polynomial. + BoundIntegerRoots(F, UP): Exports == Implementation where F : Join(Field, RetractableTo Fraction Integer) UP : UnivariatePolynomialCategory F @@ -5672,6 +5696,8 @@ BoundIntegerRoots(F, UP): Exports == Implementation where ++ [2] James Davenport, On Brillhart Irreducibility. To appear. ++ [3] John Brillhart, On the Euler and Bernoulli polynomials, ++ J. Reine Angew. Math., v. 234, (1969), pp. 45-64 +++ Description: +++ This package has no description BrillhartTests(UP): Exports == Implementation where N ==> NonNegativeInteger @@ -5793,8 +5819,8 @@ BrillhartTests(UP): Exports == Implementation where ++ Examples: ++ References: ++ Description: -++ This package provides functions to enable conversion of tensors -++ given conversion of the components. +++ This package provides functions to enable conversion of tensors +++ given conversion of the components. CartesianTensorFunctions2(minix, dim, S, T): CTPcat == CTPdef where minix: Integer @@ -5838,12 +5864,12 @@ CartesianTensorFunctions2(minix, dim, S, T): CTPcat == CTPdef where <>= )abbrev package CHVAR ChangeOfVariable -++ Sends a point to infinity ++ Author: Manuel Bronstein ++ Date Created: 1988 ++ Date Last Updated: 22 Feb 1990 ++ Description: -++ Tools to send a point to infinity on an algebraic curve. +++ Tools to send a point to infinity on an algebraic curve. + ChangeOfVariable(F, UP, UPUP): Exports == Implementation where F : UniqueFactorizationDomain UP : UnivariatePolynomialCategory F @@ -5994,12 +6020,13 @@ ChangeOfVariable(F, UP, UPUP): Exports == Implementation where ++ Description: ++ This package implements characteristicPolynomials for monogenic algebras ++ using resultants + CharacteristicPolynomialInMonogenicalAlgebra(R : CommutativeRing, PolR : UnivariatePolynomialCategory(R), E : MonogenicAlgebra(R, PolR)): with characteristicPolynomial : E -> PolR - ++ characteristicPolynomial(e) returns the characteristic polynomial - ++ of e using resultants + ++ characteristicPolynomial(e) returns the characteristic polynomial + ++ of e using resultants == add Pol ==> SparseUnivariatePolynomial @@ -6098,6 +6125,7 @@ CharacteristicPolynomialPackage(R:CommutativeRing):C == T where ++ Examples: ++ References: ++ Description: +++ This package has no description ChineseRemainderToolsForIntegralBases(K,R,UP): Exports == Implementation where K : FiniteFieldCategory @@ -6119,7 +6147,7 @@ ChineseRemainderToolsForIntegralBases(K,R,UP): Exports == Implementation where Exports ==> with factorList: (K,NNI,NNI,NNI) -> L SUP K - ++ factorList(k,n,m,j) \undocumented + ++ factorList(k,n,m,j) \undocumented listConjugateBases: (Result,NNI,NNI) -> List Result ++ listConjugateBases(bas,q,n) returns the list @@ -6128,7 +6156,7 @@ ChineseRemainderToolsForIntegralBases(K,R,UP): Exports == Implementation where ++ appearing in the basis \spad{bas} to the \spad{q}th power. chineseRemainder: (List UP, List Result, NNI) -> Result - ++ chineseRemainder(lu,lr,n) \undocumented + ++ chineseRemainder(lu,lr,n) \undocumented Implementation ==> add import ModularHermitianRowReduction(R) @@ -6281,18 +6309,16 @@ ChineseRemainderToolsForIntegralBases(K,R,UP): Exports == Implementation where <>= )abbrev package CVMP CoerceVectorMatrixPackage -++ Authors: J. Grabmeier +++ Author: J. Grabmeier ++ Date Created: 26 June 1991 ++ Date Last Updated: 26 June 1991 -++ Basic Operations: coerceP, coerce ++ Related Constructors: GenericNonAssociativeAlgebra -++ Also See: -++ AMS Classifications: ++ Keywords: ++ Reference: ++ Description: -++ CoerceVectorMatrixPackage: an unexposed, technical package -++ for data conversions +++ CoerceVectorMatrixPackage is an unexposed, technical package +++ for data conversions + CoerceVectorMatrixPackage(R : CommutativeRing): public == private where M2P ==> MatrixCategoryFunctions2(R, Vector R, Vector R, Matrix R, _ Polynomial R, Vector Polynomial R, Vector Polynomial R, Matrix Polynomial R) @@ -6616,14 +6642,12 @@ we return zero for convenience. <>= )abbrev package COMBF CombinatorialFunction -++ Provides the usual combinatorial functions ++ Author: Manuel Bronstein, Martin Rubey ++ Date Created: 2 Aug 1988 +++ Keywords: combinatorial, function, factorial. ++ Date Last Updated: 30 October 2005 ++ Description: -++ Provides combinatorial functions over an integral domain. -++ Keywords: combinatorial, function, factorial. -++ Examples: )r COMBF INPUT +++ Provides combinatorial functions over an integral domain. CombinatorialFunction(R, F): Exports == Implementation where R: Join(OrderedSet, IntegralDomain) @@ -7086,14 +7110,15 @@ CombinatorialFunction(R, F): Exports == Implementation where <>= )abbrev package CDEN CommonDenominator ---% CommonDenominator ++ Author: Manuel Bronstein ++ Date Created: 2 May 1988 ++ Date Last Updated: 22 Nov 1989 -++ Description: CommonDenominator provides functions to compute the +++ Keywords: gcd, quotient, common, denominator. +++ Description: +++ CommonDenominator provides functions to compute the ++ common denominator of a finite linear aggregate of elements of ++ the quotient field of an integral domain. -++ Keywords: gcd, quotient, common, denominator. + CommonDenominator(R, Q, A): Exports == Implementation where R: IntegralDomain Q: QuotientFieldCategory R @@ -7145,15 +7170,15 @@ CommonDenominator(R, Q, A): Exports == Implementation where <>= )abbrev package COMMONOP CommonOperators -++ Provides commonly used operators ++ Author: Manuel Bronstein ++ Date Created: 25 Mar 1988 ++ Date Last Updated: 2 December 1994 +++ Keywords: operator. ++ Description: ++ This package exports the elementary operators, with some semantics ++ already attached to them. The semantics that is attached here is not ++ dependent on the set in which the operators will be applied. -++ Keywords: operator. + CommonOperators(): Exports == Implementation where OP ==> BasicOperator O ==> OutputForm @@ -7427,6 +7452,9 @@ CommuteUnivariatePolynomialCategory(R, UP, UPUP): Exports == Impl where ++ AMS Classifications: ++ Keywords: complex, polynomial factorization, factor ++ References: +++ Description: +++ This package has no description + ComplexFactorization(RR,PR) : C == T where RR : EuclideanDomain -- R is Z or Q PR : UnivariatePolynomialCategory Complex RR @@ -7530,8 +7558,9 @@ ComplexFactorization(RR,PR) : C == T where ++ Keywords: ++ References: ++ Description: -++ This package extends maps from underlying rings to maps between -++ complex over those rings. +++ This package extends maps from underlying rings to maps between +++ complex over those rings. + ComplexFunctions2(R:CommutativeRing, S:CommutativeRing): with map: (R -> S, Complex R) -> Complex S ++ map(f,u) maps f onto real and imaginary parts of u. @@ -7567,6 +7596,7 @@ ComplexFunctions2(R:CommutativeRing, S:CommutativeRing): with ++ Description: ++ This package provides the generalized euclidean algorithm which is ++ needed as the basic step for factoring polynomials. + ComplexIntegerSolveLinearPolynomialEquation(R,CR): C == T where CP ==> SparseUnivariatePolynomial CR @@ -7630,13 +7660,14 @@ ComplexIntegerSolveLinearPolynomialEquation(R,CR): C == T ++ References: ++ Description: ++ This package supports converting complex expressions to patterns + ComplexPattern(R, S, CS) : C == T where R: SetCategory S: Join(ConvertibleTo Pattern R, CommutativeRing) CS: ComplexCategory S C == with convert: CS -> Pattern R - ++ convert(cs) converts the complex expression cs to a pattern + ++ convert(cs) converts the complex expression cs to a pattern T == add @@ -7674,6 +7705,7 @@ ComplexPattern(R, S, CS) : C == T where ++ References: ++ Description: ++ This package supports matching patterns involving complex expressions + ComplexPatternMatch(R, S, CS) : C == T where R: SetCategory S: Join(PatternMatchable R, CommutativeRing) @@ -7697,16 +7729,16 @@ ComplexPatternMatch(R, S, CS) : C == T where makeComplex(p:PS):CS == up := univariate p - degree up > 1 => error "not linear in %i" - icoef:=leadingCoefficient(up) + degree up > 1 => error "not linear in %i" + icoef:=leadingCoefficient(up) rcoef:=leadingCoefficient(reductum p) - complex(rcoef,icoef) + complex(rcoef,icoef) makePoly(cs:CS):PS == real(cs)*ivar + imag(cs)::PS if PS has PatternMatchable(R) then patternMatch(cs, pat, result) == - zero? imag cs => + zero? imag cs => patternMatch(real cs, pat, result) map(makeComplex, patternMatch(makePoly cs, pat, map(makePoly, result))) @@ -7753,19 +7785,20 @@ ComplexPatternMatch(R, S, CS) : C == T where ++ A. Schoenhage: The fundamental theorem of algebra in terms of computational ++ complexity, preliminary report, Univ. Tuebingen, 1982 ++ Description: -++ \spadtype{ComplexRootFindingPackage} provides functions to -++ find all roots of a polynomial p over the complex number by -++ using Plesken's idea to calculate in the polynomial ring -++ modulo f and employing the Chinese Remainder Theorem. -++ In this first version, the precision (see \spadfunFrom{digits}{Float}) -++ is not increased when this is necessary to -++ avoid rounding errors. Hence it is the user's responsibility to -++ increase the precision if necessary. -++ Note also, if this package is called with e.g. \spadtype{Fraction Integer}, -++ the precise calculations could require a lot of time. -++ Also note that evaluating the zeros is not necessarily a good check -++ whether the result is correct: already evaluation can cause -++ rounding errors. +++ \spadtype{ComplexRootFindingPackage} provides functions to +++ find all roots of a polynomial p over the complex number by +++ using Plesken's idea to calculate in the polynomial ring +++ modulo f and employing the Chinese Remainder Theorem. +++ In this first version, the precision (see digits) +++ is not increased when this is necessary to +++ avoid rounding errors. Hence it is the user's responsibility to +++ increase the precision if necessary. +++ Note also, if this package is called with e.g. \spadtype{Fraction Integer}, +++ the precise calculations could require a lot of time. +++ Also note that evaluating the zeros is not necessarily a good check +++ whether the result is correct: already evaluation can cause +++ rounding errors. + ComplexRootFindingPackage(R, UP): public == private where -- R : Join(Field, OrderedRing, CharacteristicZero) -- Float not in CharacteristicZero !| @@ -7785,21 +7818,20 @@ ComplexRootFindingPackage(R, UP): public == private where complexZeros : UP -> L C ++ complexZeros(p) tries to determine all complex zeros ++ of the polynomial p with accuracy given by the package - ++ constant {\em globalEps} which you may change by - ++ {\em setErrorBound}. + ++ constant globalEps which you may change by setErrorBound. complexZeros : (UP, R) -> L C ++ complexZeros(p, eps) tries to determine all complex zeros - ++ of the polynomial p with accuracy given by {\em eps}. + ++ of the polynomial p with accuracy given by eps. divisorCascade : (UP,UP, Boolean) -> L FAE - ++ divisorCascade(p,tp) assumes that degree of polynomial {\em tp} + ++ divisorCascade(p,tp) assumes that degree of polynomial tp ++ is smaller than degree of polynomial p, both monic. ++ A sequence of divisions are calculated ++ using the remainder, made monic, as divisor ++ for the the next division. The result contains also the error of the ++ factorizations, i.e. the norm of the remainder polynomial. - ++ If {\em info} is {\em true}, then information messages are issued. + ++ If info is true, then information messages are issued. divisorCascade : (UP,UP) -> L FAE - ++ divisorCascade(p,tp) assumes that degree of polynomial {\em tp} + ++ divisorCascade(p,tp) assumes that degree of polynomial tp ++ is smaller than degree of polynomial p, both monic. ++ A sequence of divisions is calculated ++ using the remainder, made monic, as divisor @@ -7807,43 +7839,43 @@ ComplexRootFindingPackage(R, UP): public == private where ++ factorizations, i.e. the norm of the remainder polynomial. factor: (UP,R,Boolean) -> FR UP ++ factor(p, eps, info) tries to factor p into linear factors - ++ with error atmost {\em eps}. An overall error bound - ++ {\em eps0} is determined and iterated tree-like calls - ++ to {\em pleskenSplit} are used to get the factorization. - ++ If {\em info} is {\em true}, then information messages are given. + ++ with error atmost eps. An overall error bound + ++ eps0 is determined and iterated tree-like calls + ++ to pleskenSplit are used to get the factorization. + ++ If info is true, then information messages are given. factor: (UP,R) -> FR UP ++ factor(p, eps) tries to factor p into linear factors - ++ with error atmost {\em eps}. An overall error bound - ++ {\em eps0} is determined and iterated tree-like calls - ++ to {\em pleskenSplit} are used to get the factorization. + ++ with error atmost eps. An overall error bound + ++ eps0 is determined and iterated tree-like calls + ++ to pleskenSplit are used to get the factorization. factor: UP -> FR UP ++ factor(p) tries to factor p into linear factors - ++ with error atmost {\em globalEps}, the internal error bound, - ++ which can be set by {\em setErrorBound}. An overall error bound - ++ {\em eps0} is determined and iterated tree-like calls - ++ to {\em pleskenSplit} are used to get the factorization. + ++ with error atmost globalEps, the internal error bound, + ++ which can be set by setErrorBound. An overall error bound + ++ eps0 is determined and iterated tree-like calls + ++ to pleskenSplit are used to get the factorization. graeffe : UP -> UP ++ graeffe p determines q such that \spad{q(-z**2) = p(z)*p(-z)}. ++ Note that the roots of q are the squares of the roots of p. norm : UP -> R ++ norm(p) determines sum of absolute values of coefficients - ++ Note: this function depends on \spadfunFrom{abs}{Complex}. + ++ Note that this function depends on abs. pleskenSplit: (UP, R, Boolean) -> FR UP - ++ pleskenSplit(poly,eps,info) determines a start polynomial {\em start} + ++ pleskenSplit(poly,eps,info) determines a start polynomial start ++ by using "startPolynomial then it increases the exponent - ++ n of {\em start ** n mod poly} to get an approximate factor of - ++ {\em poly}, in general of degree "degree poly -1". Then a divisor + ++ n of start ** n mod poly to get an approximate factor of + ++ poly, in general of degree "degree poly -1". Then a divisor ++ cascade is calculated and the best splitting is chosen, as soon ++ as the error is small enough. --++ In a later version we plan --++ to use the whole information to get a split into more than 2 --++ factors. - ++ If {\em info} is {\em true}, then information messages are issued. + ++ If info is true, then information messages are issued. pleskenSplit: (UP, R) -> FR UP - ++ pleskenSplit(poly, eps) determines a start polynomial {\em start}\ + ++ pleskenSplit(poly, eps) determines a start polynomial start ++ by using "startPolynomial then it increases the exponent - ++ n of {\em start ** n mod poly} to get an approximate factor of - ++ {\em poly}, in general of degree "degree poly -1". Then a divisor + ++ n of start ** n mod poly to get an approximate factor of + ++ poly, in general of degree "degree poly -1". Then a divisor ++ cascade is calculated and the best splitting is chosen, as soon ++ as the error is small enough. --++ In a later version we plan @@ -7855,25 +7887,24 @@ ComplexRootFindingPackage(R, UP): public == private where ++ number of 0-roots. rootRadius: (UP,R) -> R ++ rootRadius(p,errQuot) calculates the root radius of p with a - ++ maximal error quotient of {\em errQuot}. + ++ maximal error quotient of errQuot. rootRadius: UP -> R ++ rootRadius(p) calculates the root radius of p with a - ++ maximal error quotient of {\em 1+globalEps}, where - ++ {\em globalEps} is the internal error bound, which can be - ++ set by {\em setErrorBound}. + ++ maximal error quotient of 1+globalEps, where + ++ globalEps is the internal error bound, which can be + ++ set by setErrorBound. schwerpunkt: UP -> C ++ schwerpunkt(p) determines the 'Schwerpunkt' of the roots of the ++ polynomial p of degree n, i.e. the center of gravity, which is - ++ {\em coeffient of \spad{x**(n-1)}} divided by - ++ {\em n times coefficient of \spad{x**n}}. + ++ coeffient of \spad{x**(n-1)} divided by + ++ n times coefficient of \spad{x**n}. setErrorBound : R -> R ++ setErrorBound(eps) changes the internal error bound, - -- by default being {\em 10 ** (-20)} to eps, if R is - ++ by default being {\em 10 ** (-3)} to eps, if R is + -- by default being 10 ** (-20) to eps, if R is + ++ by default being 10 ** (-3) to eps, if R is ++ a member in the category \spadtype{QuotientFieldCategory Integer}. - ++ The internal {\em globalDigits} is set to - -- {\em ceiling(1/r)**2*10} being {\em 10**41} by default. - ++ {\em ceiling(1/r)**2*10} being {\em 10**7} by default. + ++ The internal globalDigits is set to + ++ \em ceiling(1/r)**2*10 being 10**7 by default. startPolynomial: UP -> Record(start: UP, factors: FR UP) ++ startPolynomial(p) uses the ideas of Schoenhage's ++ variant of Graeffe's method to construct circles which separate @@ -7882,7 +7913,7 @@ ComplexRootFindingPackage(R, UP): public == private where ++ of norm smaller and greater or equal to 1. In case the ++ roots are found during internal calculations. ++ The corresponding factors - ++ are in {\em factors} which are otherwise 1. + ++ are in factors which are otherwise 1. private ==> add @@ -7925,8 +7956,8 @@ ComplexRootFindingPackage(R, UP): public == private where -- takes factorization with smaller error nthRoot : (R, NNI) -> R -- nthRoot(r,n) determines an approximation to the n-th - -- root of r, if \spadtype{R} has {\em ?**?: (R,Fraction Integer)->R} - -- we use this, otherwise we use {\em approxNthRoot} via + -- root of r, if \spadtype{R} has ?**?: (R,Fraction Integer)->R + -- we use this, otherwise we use approxNthRoot via -- \spadtype{Integer} shift: (UP,C) -> UP -- shift(p,c) changes p(x) into p(x+c), thereby modifying the @@ -8352,7 +8383,7 @@ ComplexRootFindingPackage(R, UP): public == private where ++ Keywords: ++ References: ++ Description: -++ This package provides functions complexZeros +++ This package provides functions complexZeros ++ for finding the complex zeros ++ of univariate polynomials with complex rational number coefficients. ++ The results are to any user specified precision and are returned @@ -8360,16 +8391,11 @@ ComplexRootFindingPackage(R, UP): public == private where ++ depending on the type of the second argument which specifies the ++ precision. --- Packages for the computation of complex roots of --- univariate polynomials with rational or gaussian coefficients. - --- Simplified version, the old original based on Gebauer's solver is --- in ocmplxrt spad -RN ==> Fraction Integer -I ==> Integer -NF ==> Float ComplexRootPackage(UP,Par) : T == C where + RN ==> Fraction Integer + I ==> Integer + NF ==> Float UP : UnivariatePolynomialCategory Complex Integer Par : Join(Field, OrderedRing) -- will be Float or RN CP ==> Complex Par @@ -8424,14 +8450,14 @@ ComplexRootPackage(UP,Par) : T == C where <>= )abbrev package CTRIGMNP ComplexTrigonometricManipulations -++ Real and Imaginary parts of complex functions ++ Author: Manuel Bronstein ++ Date Created: 11 June 1993 ++ Date Last Updated: 14 June 1993 -++ Description: -++ \spadtype{ComplexTrigonometricManipulations} provides function that -++ compute the real and imaginary parts of complex functions. ++ Keywords: complex, function, manipulation. +++ Description: +++ \spadtype{ComplexTrigonometricManipulations} provides function that +++ compute the real and imaginary parts of complex functions. + ComplexTrigonometricManipulations(R, F): Exports == Implementation where R : Join(IntegralDomain, OrderedSet, RetractableTo Integer) F : Join(AlgebraicallyClosedField, TranscendentalFunctionCategory, @@ -8549,7 +8575,10 @@ ComplexTrigonometricManipulations(R, F): Exports == Implementation where ++ Author: Manuel Bronstein ++ Date Created: 18 March 1991 ++ Date Last Updated: 3 February 1994 -++ Description: Solution of linear ordinary differential equations, constant coefficient case. +++ Description: +++ Solution of linear ordinary differential equations, +++ constant coefficient case. + ConstantLODE(R, F, L): Exports == Implementation where R: Join(OrderedSet, EuclideanDomain, RetractableTo Integer, LinearlyExplicitRingOver Integer, CharacteristicZero) @@ -8660,15 +8689,13 @@ ConstantLODE(R, F, L): Exports == Implementation where ++ Author: Jim Wen ++ Date Created: 12 March 1990 ++ Date Last Updated: 19 June 1990, Clifton J. Williamson -++ Basic Operations: cartesian, polar, cylindrical, spherical, parabolic, elliptic, -++ parabolicCylindrical, paraboloidal, ellipticCylindrical, prolateSpheroidal, -++ oblateSpheroidal, bipolar, bipolarCylindrical, toroidal, conical ++ Related Constructors: ++ Also See: ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: CoordinateSystems provides coordinate transformation functions +++ Description: +++ CoordinateSystems provides coordinate transformation functions ++ for plotting. Functions in this package return conversion functions ++ which take points expressed in other coordinate systems and return points ++ with the corresponding Cartesian coordinates. @@ -8687,11 +8714,13 @@ CoordinateSystems(R): Exports == Implementation where ++ to \spad{x = r * cos(theta)} , \spad{y = r * sin(theta)}. cylindrical: Pt -> Pt ++ cylindrical(pt) transforms pt from polar coordinates to Cartesian - ++ coordinates: the function produced will map the point \spad{(r,theta,z)} + ++ coordinates: the function produced will map the point + ++ \spad{(r,theta,z)} ++ to \spad{x = r * cos(theta)}, \spad{y = r * sin(theta)}, \spad{z}. spherical: Pt -> Pt ++ spherical(pt) transforms pt from spherical coordinates to Cartesian - ++ coordinates: the function produced will map the point \spad{(r,theta,phi)} + ++ coordinates: the function produced will map the point + ++ \spad{(r,theta,phi)} ++ to \spad{x = r*sin(phi)*cos(theta)}, \spad{y = r*sin(phi)*sin(theta)}, ++ \spad{z = r*cos(phi)}. parabolic: Pt -> Pt @@ -8866,23 +8895,24 @@ CoordinateSystems(R): Exports == Implementation where <>= )abbrev package CRAPACK CRApackage - -++ This package \undocumented{} +++ Description: +++ This package has no documentation + CRApackage(R:EuclideanDomain): Exports == Implementation where Exports == with modTree: (R,List R) -> List R - ++ modTree(r,l) \undocumented{} + ++ modTree(r,l) \undocumented{} chineseRemainder: (List R, List R) -> R - ++ chineseRemainder(lv,lm) returns a value \axiom{v} such that, if - ++ x is \axiom{lv.i} modulo \axiom{lm.i} for all \axiom{i}, then - ++ x is \axiom{v} modulo \axiom{lm(1)*lm(2)*...*lm(n)}. + ++ chineseRemainder(lv,lm) returns a value \axiom{v} such that, if + ++ x is \axiom{lv.i} modulo \axiom{lm.i} for all \axiom{i}, then + ++ x is \axiom{v} modulo \axiom{lm(1)*lm(2)*...*lm(n)}. chineseRemainder: (List List R, List R) -> List R - ++ chineseRemainder(llv,lm) returns a list of values, each of which - ++ corresponds to the Chinese remainder of the associated element of - ++ \axiom{llv} and axiom{lm}. This is more efficient than applying - ++ chineseRemainder several times. + ++ chineseRemainder(llv,lm) returns a list of values, each of which + ++ corresponds to the Chinese remainder of the associated element of + ++ \axiom{llv} and axiom{lm}. This is more efficient than applying + ++ chineseRemainder several times. multiEuclideanTree: (List R, R) -> List R - ++ multiEuclideanTree(l,r) \undocumented{} + ++ multiEuclideanTree(l,r) \undocumented{} Implementation == add BB:=BalancedBinaryTree(R) @@ -9878,7 +9908,6 @@ o )show CycleIndicators <>= )abbrev package CYCLES CycleIndicators -++ Polya-Redfield enumeration by cycle indices. ++ Author: William H. Burge ++ Date Created: 1986 ++ Date Last Updated: 11 Feb 1992 @@ -9889,7 +9918,9 @@ o )show CycleIndicators ++ G.Polya, 'Kombinatorische Anzahlbestimmungen fur Gruppen, ++ Graphen und chemische Verbindungen', Acta Math. 68 ++ (1937) 145-254. -++ Description: Enumeration by cycle indices. +++ Description: +++ Polya-Redfield enumeration by cycle indices. + CycleIndicators: Exports == Implementation where I ==> Integer L ==> List @@ -10118,13 +10149,13 @@ CycleIndicators: Exports == Implementation where <>= )abbrev package CSTTOOLS CyclicStreamTools -++ Functions for dealing with cyclic streams ++ Author: Clifton J. Williamson ++ Date Created: 5 December 1989 ++ Date Last Updated: 5 December 1989 ++ Keywords: stream, cyclic ++ Description: ++ This package provides tools for working with cyclic streams. + CyclicStreamTools(S,ST): Exports == Implementation where S : Type ST : LazyStreamAggregate S @@ -10203,7 +10234,9 @@ CyclicStreamTools(S,ST): Exports == Implementation where <>= )abbrev package CYCLOTOM CyclotomicPolynomialPackage -++ This package \undocumented{} +++ Description: +++ This package has no description + CyclotomicPolynomialPackage: public == private where SUP ==> SparseUnivariatePolynomial(Integer) LSUP ==> List(SUP) @@ -10213,11 +10246,11 @@ CyclotomicPolynomialPackage: public == private where public == with cyclotomicDecomposition: Integer -> LSUP - ++ cyclotomicDecomposition(n) \undocumented{} + ++ cyclotomicDecomposition(n) \undocumented{} cyclotomic: Integer -> SUP - ++ cyclotomic(n) \undocumented{} + ++ cyclotomic(n) \undocumented{} cyclotomicFactorization: Integer -> FR - ++ cyclotomicFactorization(n) \undocumented{} + ++ cyclotomicFactorization(n) \undocumented{} private == add cyclotomic(n:Integer): SUP == @@ -10277,13 +10310,13 @@ CyclotomicPolynomialPackage: public == private where <>= )abbrev package DFINTTLS DefiniteIntegrationTools -++ Tools for definite integration ++ Author: Manuel Bronstein ++ Date Created: 15 April 1992 ++ Date Last Updated: 24 February 1993 ++ Description: -++ \spadtype{DefiniteIntegrationTools} provides common tools used -++ by the definite integration of both rational and elementary functions. +++ \spadtype{DefiniteIntegrationTools} provides common tools used +++ by the definite integration of both rational and elementary functions. + DefiniteIntegrationTools(R, F): Exports == Implementation where R : Join(GcdDomain, OrderedSet, RetractableTo Integer, LinearlyExplicitRingOver Integer) @@ -10545,7 +10578,9 @@ DefiniteIntegrationTools(R, F): Exports == Implementation where <>= )abbrev package DEGRED DegreeReductionPackage -++ This package \undocumented{} +++ Description: +++ This package has no description + DegreeReductionPackage(R1, R2): Cat == Capsule where R1: Ring R2: Join(IntegralDomain,OrderedSet) @@ -10557,9 +10592,9 @@ DegreeReductionPackage(R1, R2): Cat == Capsule where Cat == with reduce: UP R1 -> Record(pol: UP R1, deg: PI) - ++ reduce(p) \undocumented{} + ++ reduce(p) \undocumented{} expand: (RE, PI) -> List RE - ++ expand(f,n) \undocumented{} + ++ expand(f,n) \undocumented{} Capsule == add @@ -10618,20 +10653,20 @@ DegreeReductionPackage(R1, R2): Cat == Capsule where ++ M. Clausen, A. Fortenbacher: Efficient Solution of ++ Linear Diophantine Equations. in JSC (1989) 8, 201-216 ++ Description: -++ any solution of a homogeneous linear Diophantine equation -++ can be represented as a sum of minimal solutions, which -++ form a "basis" (a minimal solution cannot be represented -++ as a nontrivial sum of solutions) -++ in the case of an inhomogeneous linear Diophantine equation, -++ each solution is the sum of a inhomogeneous solution and -++ any number of homogeneous solutions -++ therefore, it suffices to compute two sets: -++ 1. all minimal inhomogeneous solutions -++ 2. all minimal homogeneous solutions -++ the algorithm implemented is a completion procedure, which -++ enumerates all solutions in a recursive depth-first-search -++ it can be seen as finding monotone paths in a graph -++ for more details see Reference +++ Any solution of a homogeneous linear Diophantine equation +++ can be represented as a sum of minimal solutions, which +++ form a "basis" (a minimal solution cannot be represented +++ as a nontrivial sum of solutions) +++ in the case of an inhomogeneous linear Diophantine equation, +++ each solution is the sum of a inhomogeneous solution and +++ any number of homogeneous solutions +++ therefore, it suffices to compute two sets:\br +++ \tab{5}1. all minimal inhomogeneous solutions\br +++ \tab{5}2. all minimal homogeneous solutions\br +++ the algorithm implemented is a completion procedure, which +++ enumerates all solutions in a recursive depth-first-search +++ it can be seen as finding monotone paths in a graph +++ for more details see Reference DiophantineSolutionPackage(): Cat == Capsule where @@ -10810,9 +10845,9 @@ DiophantineSolutionPackage(): Cat == Capsule where ++ Keywords: ++ References: ++ Description: -++ This package provides operations which all take as arguments -++ direct products of elements of some type \spad{A} and functions from \spad{A} to another -++ type B. The operations all iterate over their vector argument +++ This package provides operations which all take as arguments direct +++ products of elements of some type \spad{A} and functions from \spad{A} +++ to another type B. The operations all iterate over their vector argument ++ and either return a value of type B or a direct product over B. DirectProductFunctions2(dim, A, B): Exports == Implementation where @@ -10874,20 +10909,20 @@ DirectProductFunctions2(dim, A, B): Exports == Implementation where ++ J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM. ++ AXIOM Technical Report Series, ATR/5 NP2522. ++ Description: -++ DiscreteLogarithmPackage implements help functions for discrete logarithms -++ in monoids using small cyclic groups. +++ DiscreteLogarithmPackage implements help functions for discrete logarithms +++ in monoids using small cyclic groups. DiscreteLogarithmPackage(M): public == private where M : Join(Monoid,Finite) with "**": (M,Integer) -> M - ++ x ** n returns x raised to the integer power n + ++ x ** n returns x raised to the integer power n public ==> with shanksDiscLogAlgorithm:(M,M,NonNegativeInteger)-> _ Union(NonNegativeInteger,"failed") ++ shanksDiscLogAlgorithm(b,a,p) computes s with \spad{b**s = a} for ++ assuming that \spad{a} and b are elements in a 'small' cyclic group of ++ order p by Shank's algorithm. - ++ Note: this is a subroutine of the function \spadfun{discreteLog}. + ++ Note that this is a subroutine of the function \spadfun{discreteLog}. I ==> Integer PI ==> PositiveInteger NNI ==> NonNegativeInteger @@ -10973,7 +11008,8 @@ DiscreteLogarithmPackage(M): public == private where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: DisplayPackage allows one to print strings in a nice manner, +++ Description: +++ DisplayPackage allows one to print strings in a nice manner, ++ including highlighting substrings. DisplayPackage: public == private where @@ -11115,11 +11151,11 @@ DisplayPackage: public == private where ++ Keywords: ++ References: ++ Description: -++ Package for the factorization of a univariate polynomial with -++ coefficients in a finite field. The algorithm used is the -++ "distinct degree" algorithm of Cantor-Zassenhaus, modified -++ to use trace instead of the norm and a table for computing -++ Frobenius as suggested by Naudin and Quitte . +++ Package for the factorization of a univariate polynomial with +++ coefficients in a finite field. The algorithm used is the +++ "distinct degree" algorithm of Cantor-Zassenhaus, modified +++ to use trace instead of the norm and a table for computing +++ Frobenius as suggested by Naudin and Quitte . DistinctDegreeFactorize(F,FP): C == T where @@ -11146,16 +11182,16 @@ DistinctDegreeFactorize(F,FP): C == T ++ If argument sqfrflag is true, the polynomial is assumed square free. separateDegrees : FP -> List fact ++ separateDegrees(p) splits the square free polynomial p into - ++ factors each of which is a product of irreducibles of the same degree. + ++ factors each of which is a product of irreducibles of the + ++ same degree. separateFactors : List fact -> List FP - ++ separateFactors(lfact) takes the list produced by - ++ \spadfunFrom{separateDegrees}{DistinctDegreeFactorization} + ++ separateFactors(lfact) takes the list produced by separateDegrees ++ and produces the complete list of factors. exptMod : (FP,NNI,FP) -> FP ++ exptMod(u,k,v) raises the polynomial u to the kth power ++ modulo the polynomial v. trace2PowMod : (FP,NNI,FP) -> FP - ++ trace2PowMod(u,k,v) produces the sum of \spad{u**(2**i)} for i running + ++ trace2PowMod(u,k,v) produces the sum of u**(2**i) for i running ++ from 1 to k all computed modulo the polynomial v. tracePowMod : (FP,NNI,FP) -> FP ++ tracePowMod(u,k,v) produces the sum of \spad{u**(q**i)} @@ -11404,8 +11440,8 @@ DistinctDegreeFactorize(F,FP): C == T ++ Examples: ++ References: ++ Description: -++ This package provides special functions for double precision -++ real and complex floating point. +++ This package provides special functions for double precision +++ real and complex floating point. DoubleFloatSpecialFunctions(): Exports == Impl where NNI ==> NonNegativeInteger @@ -11423,7 +11459,7 @@ DoubleFloatSpecialFunctions(): Exports == Impl where ++ \spad{Gamma(x) = integrate(t^(x-1)*exp(-t), t=0..%infinity)}. E1: R -> OPR - ++ E1(x) is the Exponential Integral function + ++ E1(x) is the Exponential Integral function ++ The current implementation is a piecewise approximation ++ involving one poly from -4..4 and a second poly for x > 4 @@ -11506,7 +11542,7 @@ DoubleFloatSpecialFunctions(): Exports == Impl where ++ \spad{Y(v,x)}. ++ This function satisfies the differential equation: ++ \spad{x^2 w''(x) + x w'(x) + (x^2-v^2)w(x) = 0}. - ++ Note: The default implementation uses the relation + ++ Note that the default implementation uses the relation ++ \spad{Y(v,x) = (J(v,x) cos(v*%pi) - J(-v,x))/sin(v*%pi)} ++ so is not valid for integer values of v. besselY: (C, C) -> C @@ -11514,7 +11550,7 @@ DoubleFloatSpecialFunctions(): Exports == Impl where ++ \spad{Y(v,x)}. ++ This function satisfies the differential equation: ++ \spad{x^2 w''(x) + x w'(x) + (x^2-v^2)w(x) = 0}. - ++ Note: The default implementation uses the relation + ++ Note that the default implementation uses the relation ++ \spad{Y(v,x) = (J(v,x) cos(v*%pi) - J(-v,x))/sin(v*%pi)} ++ so is not valid for integer values of v. @@ -11534,7 +11570,7 @@ DoubleFloatSpecialFunctions(): Exports == Impl where ++ \spad{K(v,x)}. ++ This function satisfies the differential equation: ++ \spad{x^2 w''(x) + x w'(x) - (x^2+v^2)w(x) = 0}. - ++ Note: The default implementation uses the relation + ++ Note that the default implementation uses the relation ++ \spad{K(v,x) = %pi/2*(I(-v,x) - I(v,x))/sin(v*%pi)}. ++ so is not valid for integer values of v. besselK: (C, C) -> C @@ -11542,7 +11578,7 @@ DoubleFloatSpecialFunctions(): Exports == Impl where ++ \spad{K(v,x)}. ++ This function satisfies the differential equation: ++ \spad{x^2 w''(x) + x w'(x) - (x^2+v^2)w(x) = 0}. - ++ Note: The default implementation uses the relation + ++ Note that the default implementation uses the relation ++ \spad{K(v,x) = %pi/2*(I(-v,x) - I(v,x))/sin(v*%pi)} ++ so is not valid for integer values of v. @@ -13514,13 +13550,13 @@ $\infty$ & -1.000 & 0.100000000 0000000000 00000000001 E 01\\ <>= )abbrev package DBLRESP DoubleResultantPackage -++ Residue resultant ++ Author: Manuel Bronstein ++ Date Created: 1987 ++ Date Last Updated: 12 July 1990 ++ Description: ++ This package provides functions for computing the residues ++ of a function on an algebraic curve. + DoubleResultantPackage(F, UP, UPUP, R): Exports == Implementation where F : Field UP : UnivariatePolynomialCategory F @@ -13586,18 +13622,19 @@ DoubleResultantPackage(F, UP, UPUP, R): Exports == Implementation where <>= )abbrev package DRAWCX DrawComplex -++ Description: \axiomType{DrawComplex} provides some facilities +++ Description: +++ \axiomType{DrawComplex} provides some facilities ++ for drawing complex functions. -C ==> Complex DoubleFloat -S ==> Segment DoubleFloat -PC ==> Record(rr:SF, th:SF) -INT ==> Integer -SF ==> DoubleFloat -NNI ==> NonNegativeInteger -VIEW3D ==> ThreeDimensionalViewport -ARRAY2 ==> TwoDimensionalArray - + DrawComplex(): Exports == Implementation where + C ==> Complex DoubleFloat + S ==> Segment DoubleFloat + PC ==> Record(rr:SF, th:SF) + INT ==> Integer + SF ==> DoubleFloat + NNI ==> NonNegativeInteger + VIEW3D ==> ThreeDimensionalViewport + ARRAY2 ==> TwoDimensionalArray Exports == with drawComplex: (C -> C,S,S,Boolean) -> VIEW3D ++ drawComplex(f,rRange,iRange,arrows?) @@ -13605,7 +13642,7 @@ DrawComplex(): Exports == Implementation where ++ It uses the complex norm as the height and the complex ++ argument as the color. ++ It will optionally draw arrows on the surface indicating the direction - ++ of the complex value.\newline + ++ of the complex value. ++ Sample call: ++ \spad{f z == exp(1/z)} ++ \spad{drawComplex(f, 0.3..3, 0..2*%pi, false)} @@ -13621,7 +13658,7 @@ DrawComplex(): Exports == Implementation where ++ drawComplexVectorField(f,rRange,iRange) ++ draws a complex vector field using arrows on the \spad{x--y} plane. ++ These vector fields should be viewed from the top by pressing the - ++ "XY" translate button on the 3-d viewport control panel.\newline + ++ "XY" translate button on the 3-d viewport control panel. ++ Sample call: ++ \spad{f z == sin z} ++ \spad{drawComplexVectorField(f, -2..2, -2..2)} @@ -13783,14 +13820,15 @@ DrawComplex(): Exports == Implementation where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: Hack for the draw interface. DrawNumericHack provides +++ Description: +++ Hack for the draw interface. DrawNumericHack provides ++ a "coercion" from something of the form \spad{x = a..b} where \spad{a} ++ and b are ++ formal expressions to a binding of the form \spad{x = c..d} where c and d ++ are the numerical values of \spad{a} and b. This "coercion" fails if ++ \spad{a} and b contains symbolic variables, but is meant for expressions ++ involving %pi. -++ NOTE: This is meant for internal use only. +++ Note that this package is meant for internal use only. DrawNumericHack(R:Join(OrderedSet,IntegralDomain,ConvertibleTo Float)): with coerce: SegmentBinding Expression R -> SegmentBinding Float @@ -13834,9 +13872,11 @@ DrawNumericHack(R:Join(OrderedSet,IntegralDomain,ConvertibleTo Float)): <>= )abbrev package DROPT0 DrawOptionFunctions0 +++ Description: +++ This package has no description -- The functions here are not in DrawOptions since they are not -- visible to the interpreter. -++ This package \undocumented{} + DrawOptionFunctions0(): Exports == Implementation where RANGE ==> List Segment Float UNIT ==> List Float @@ -14015,7 +14055,9 @@ DrawOptionFunctions0(): Exports == Implementation where <>= )abbrev package DROPT1 DrawOptionFunctions1 -++ This package \undocumented{} +++ Description: +++ This package has no description + DrawOptionFunctions1(S:Type): Exports == Implementation where RANGE ==> List Segment Float UNIT ==> List Float @@ -14079,46 +14121,45 @@ DrawOptionFunctions1(S:Type): Exports == Implementation where ++ \axiomFun{functionIsContinuousAtEndPoints} to check for continuity at ++ the end points of the range. - d01AgentsPackage(): E == I where - EF2 ==> ExpressionFunctions2 - EFI ==> Expression Fraction Integer - FI ==> Fraction Integer - LEDF ==> List Expression DoubleFloat - KEDF ==> Kernel Expression DoubleFloat - EEDF ==> Equation Expression DoubleFloat - EDF ==> Expression DoubleFloat - PDF ==> Polynomial DoubleFloat - LDF ==> List DoubleFloat - SDF ==> Stream DoubleFloat - DF ==> DoubleFloat - F ==> Float - ST ==> String - LST ==> List String - SI ==> SingleInteger - SOCDF ==> Segment OrderedCompletion DoubleFloat - OCDF ==> OrderedCompletion DoubleFloat - OCEDF ==> OrderedCompletion Expression DoubleFloat + EF2 ==> ExpressionFunctions2 + EFI ==> Expression Fraction Integer + FI ==> Fraction Integer + LEDF ==> List Expression DoubleFloat + KEDF ==> Kernel Expression DoubleFloat + EEDF ==> Equation Expression DoubleFloat + EDF ==> Expression DoubleFloat + PDF ==> Polynomial DoubleFloat + LDF ==> List DoubleFloat + SDF ==> Stream DoubleFloat + DF ==> DoubleFloat + F ==> Float + ST ==> String + LST ==> List String + SI ==> SingleInteger + SOCDF ==> Segment OrderedCompletion DoubleFloat + OCDF ==> OrderedCompletion DoubleFloat + OCEDF ==> OrderedCompletion Expression DoubleFloat EOCEFI ==> Equation OrderedCompletion Expression Fraction Integer OCEFI ==> OrderedCompletion Expression Fraction Integer OCFI ==> OrderedCompletion Fraction Integer - NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) - INT ==> Integer - CTYPE ==> Union(continuous: "Continuous at the end points", + NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) + INT ==> Integer + CTYPE ==> Union(continuous: "Continuous at the end points", lowerSingular: "There is a singularity at the lower end point", upperSingular: "There is a singularity at the upper end point", bothSingular: "There are singularities at both end points", notEvaluated: "End point continuity not yet evaluated") - RTYPE ==> Union(finite: "The range is finite", + RTYPE ==> Union(finite: "The range is finite", lowerInfinite: "The bottom of range is infinite", upperInfinite: "The top of range is infinite", bothInfinite: "Both top and bottom points are infinite", notEvaluated: "Range not yet evaluated") - STYPE ==> Union(str:SDF, + STYPE ==> Union(str:SDF, notEvaluated:"Internal singularities not yet evaluated") - ATT ==> Record(endPointContinuity:CTYPE, + ATT ==> Record(endPointContinuity:CTYPE, singularitiesStream:STYPE,range:RTYPE) - ROA ==> Record(key:NIA,entry:ATT) + ROA ==> Record(key:NIA,entry:ATT) E ==> with @@ -14372,22 +14413,23 @@ d01AgentsPackage(): E == I where ++ function. The types of weights investigated are those giving rise to ++ end-point singularities of the algebraico-logarithmic type, and ++ trigonometric weights. + d01WeightsPackage(): E == I where - LEDF ==> List Expression DoubleFloat - KEDF ==> Kernel Expression DoubleFloat - LKEDF ==> List Kernel Expression DoubleFloat - EDF ==> Expression DoubleFloat - PDF ==> Polynomial DoubleFloat - FI ==> Fraction Integer - LDF ==> List DoubleFloat - DF ==> DoubleFloat - SOCDF ==> Segment OrderedCompletion DoubleFloat - OCDF ==> OrderedCompletion DoubleFloat - NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) - INT ==> Integer - BOP ==> BasicOperator - URBODF ==> Union(Record(op:BasicOperator,w:DF),"failed") - LURBODF ==> List(Union(Record(op:BasicOperator,w:DF), "failed")) + LEDF ==> List Expression DoubleFloat + KEDF ==> Kernel Expression DoubleFloat + LKEDF ==> List Kernel Expression DoubleFloat + EDF ==> Expression DoubleFloat + PDF ==> Polynomial DoubleFloat + FI ==> Fraction Integer + LDF ==> List DoubleFloat + DF ==> DoubleFloat + SOCDF ==> Segment OrderedCompletion DoubleFloat + OCDF ==> OrderedCompletion DoubleFloat + NIA ==> Record(var:Symbol,fn:EDF,range:SOCDF,abserr:DF,relerr:DF) + INT ==> Integer + BOP ==> BasicOperator + URBODF ==> Union(Record(op:BasicOperator,w:DF),"failed") + LURBODF ==> List(Union(Record(op:BasicOperator,w:DF), "failed")) E ==> with exprHasWeightCosWXorSinWX:NIA -> URBODF @@ -14649,31 +14691,32 @@ d01WeightsPackage(): E == I where ++ Description: ++ \axiom{d02AgentsPackage} contains a set of computational agents ++ for use with Ordinary Differential Equation solvers. + d02AgentsPackage(): E == I where - LEDF ==> List Expression DoubleFloat - LEEDF ==> List Equation Expression DoubleFloat - EEDF ==> Equation Expression DoubleFloat - VEDF ==> Vector Expression DoubleFloat - MEDF ==> Matrix Expression DoubleFloat - MDF ==> Matrix DoubleFloat - EDF ==> Expression DoubleFloat - DF ==> DoubleFloat - F ==> Float - INT ==> Integer - CDF ==> Complex DoubleFloat - LDF ==> List DoubleFloat - LF ==> List Float - S ==> Symbol - LS ==> List Symbol - MFI ==> Matrix Fraction Integer - LFI ==> List Fraction Integer - FI ==> Fraction Integer - ODEA ==> Record(xinit:DF,xend:DF,fn:VEDF,yinit:LDF,intvals:LDF,g:EDF,abserr:DF,relerr:DF) - ON ==> Record(additions:INT,multiplications:INT,exponentiations:INT,functionCalls:INT) - RVE ==> Record(val:EDF,exponent:INT) - RSS ==> Record(stiffnessFactor:F,stabilityFactor:F) - ATT ==> Record(stiffness:F,stability:F,expense:F,accuracy:F,intermediateResults:F) - ROA ==> Record(key:ODEA,entry:ATT) + LEDF ==> List Expression DoubleFloat + LEEDF ==> List Equation Expression DoubleFloat + EEDF ==> Equation Expression DoubleFloat + VEDF ==> Vector Expression DoubleFloat + MEDF ==> Matrix Expression DoubleFloat + MDF ==> Matrix DoubleFloat + EDF ==> Expression DoubleFloat + DF ==> DoubleFloat + F ==> Float + INT ==> Integer + CDF ==> Complex DoubleFloat + LDF ==> List DoubleFloat + LF ==> List Float + S ==> Symbol + LS ==> List Symbol + MFI ==> Matrix Fraction Integer + LFI ==> List Fraction Integer + FI ==> Fraction Integer + ODEA ==> Record(xinit:DF,xend:DF,fn:VEDF,yinit:LDF,intvals:LDF,g:EDF,abserr:DF,relerr:DF) + ON ==> Record(additions:INT,multiplications:INT,exponentiations:INT,functionCalls:INT) + RVE ==> Record(val:EDF,exponent:INT) + RSS ==> Record(stiffnessFactor:F,stabilityFactor:F) + ATT ==> Record(stiffness:F,stability:F,expense:F,accuracy:F,intermediateResults:F) + ROA ==> Record(key:ODEA,entry:ATT) E ==> with combineFeatureCompatibility: (F,F) -> F @@ -14715,10 +14758,10 @@ d02AgentsPackage(): E == I where ++ expenseOfEvaluationIF(o) returns the intensity value of the ++ cost of evaluating the input ODE. This is in terms of the number ++ of ``operational units''. It returns a value in the range - ++ [0,1].\newline\indent{20} - ++ 400 ``operation units'' -> 0.75 \newline - ++ 200 ``operation units'' -> 0.5 \newline - ++ 83 ``operation units'' -> 0.25 \newline\indent{15} + ++ [0,1].\indent{20} + ++ 400 ``operation units'' -> 0.75 + ++ 200 ``operation units'' -> 0.5 + ++ 83 ``operation units'' -> 0.25 \indent{15} ++ exponentiation = 4 units , function calls = 10 units. accuracyIF:ODEA -> F ++ accuracyIF(o) returns the intensity value of the accuracy @@ -14957,26 +15000,27 @@ d02AgentsPackage(): E == I where ++ Description: ++ \axiom{d03AgentsPackage} contains a set of computational agents ++ for use with Partial Differential Equation solvers. -LEDF ==> List Expression DoubleFloat -EDF ==> Expression DoubleFloat -MDF ==> Matrix DoubleFloat -DF ==> DoubleFloat -F ==> Float -INT ==> Integer -NNI ==> NonNegativeInteger -EEDF ==> Equation Expression DoubleFloat -LEEDF ==> List Equation Expression DoubleFloat -LDF ==> List DoubleFloat -LOCDF ==> List OrderedCompletion DoubleFloat -OCDF ==> OrderedCompletion DoubleFloat -LS ==> List Symbol -PDEC ==> Record(start:DF, finish:DF, grid:NNI, boundaryType:INT, - dStart:MDF, dFinish:MDF) -PDEB ==> Record(pde:LEDF, constraints:List PDEC, - f:List LEDF, st:String, tol:DF) -NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) d03AgentsPackage(): E == I where + LEDF ==> List Expression DoubleFloat + EDF ==> Expression DoubleFloat + MDF ==> Matrix DoubleFloat + DF ==> DoubleFloat + F ==> Float + INT ==> Integer + NNI ==> NonNegativeInteger + EEDF ==> Equation Expression DoubleFloat + LEEDF ==> List Equation Expression DoubleFloat + LDF ==> List DoubleFloat + LOCDF ==> List OrderedCompletion DoubleFloat + OCDF ==> OrderedCompletion DoubleFloat + LS ==> List Symbol + PDEC ==> Record(start:DF, finish:DF, grid:NNI, boundaryType:INT, + dStart:MDF, dFinish:MDF) + PDEB ==> Record(pde:LEDF, constraints:List PDEC, + f:List LEDF, st:String, tol:DF) + NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) + E ==> with varList:(Symbol,NonNegativeInteger) -> LS ++ varList(s,n) \undocumented{} @@ -15084,6 +15128,7 @@ d03AgentsPackage(): E == I where ++ polynomial. -- Functions for the numeric computation of eigenvalues and eigenvectors -- are in numeigen spad. + EigenPackage(R) : C == T where R : GcdDomain @@ -15931,7 +15976,9 @@ o )show ElementaryFunction ++ Date Last Updated: 10 April 1995 ++ Keywords: elementary, function, logarithm, exponential. ++ Examples: )r EF INPUT -++ Description: Provides elementary functions over an integral domain. +++ Description: +++ Provides elementary functions over an integral domain. + ElementaryFunction(R, F): Exports == Implementation where R: Join(OrderedSet, IntegralDomain) F: Join(FunctionSpace R, RadicalCategory) @@ -15945,124 +15992,124 @@ ElementaryFunction(R, F): Exports == Implementation where Exports ==> with exp : F -> F - ++ exp(x) applies the exponential operator to x + ++ exp(x) applies the exponential operator to x log : F -> F - ++ log(x) applies the logarithm operator to x + ++ log(x) applies the logarithm operator to x sin : F -> F - ++ sin(x) applies the sine operator to x + ++ sin(x) applies the sine operator to x cos : F -> F - ++ cos(x) applies the cosine operator to x + ++ cos(x) applies the cosine operator to x tan : F -> F - ++ tan(x) applies the tangent operator to x + ++ tan(x) applies the tangent operator to x cot : F -> F - ++ cot(x) applies the cotangent operator to x + ++ cot(x) applies the cotangent operator to x sec : F -> F - ++ sec(x) applies the secant operator to x + ++ sec(x) applies the secant operator to x csc : F -> F - ++ csc(x) applies the cosecant operator to x + ++ csc(x) applies the cosecant operator to x asin : F -> F - ++ asin(x) applies the inverse sine operator to x + ++ asin(x) applies the inverse sine operator to x acos : F -> F - ++ acos(x) applies the inverse cosine operator to x + ++ acos(x) applies the inverse cosine operator to x atan : F -> F - ++ atan(x) applies the inverse tangent operator to x + ++ atan(x) applies the inverse tangent operator to x acot : F -> F - ++ acot(x) applies the inverse cotangent operator to x + ++ acot(x) applies the inverse cotangent operator to x asec : F -> F - ++ asec(x) applies the inverse secant operator to x + ++ asec(x) applies the inverse secant operator to x acsc : F -> F - ++ acsc(x) applies the inverse cosecant operator to x + ++ acsc(x) applies the inverse cosecant operator to x sinh : F -> F - ++ sinh(x) applies the hyperbolic sine operator to x + ++ sinh(x) applies the hyperbolic sine operator to x cosh : F -> F - ++ cosh(x) applies the hyperbolic cosine operator to x + ++ cosh(x) applies the hyperbolic cosine operator to x tanh : F -> F - ++ tanh(x) applies the hyperbolic tangent operator to x + ++ tanh(x) applies the hyperbolic tangent operator to x coth : F -> F - ++ coth(x) applies the hyperbolic cotangent operator to x + ++ coth(x) applies the hyperbolic cotangent operator to x sech : F -> F - ++ sech(x) applies the hyperbolic secant operator to x + ++ sech(x) applies the hyperbolic secant operator to x csch : F -> F - ++ csch(x) applies the hyperbolic cosecant operator to x + ++ csch(x) applies the hyperbolic cosecant operator to x asinh : F -> F - ++ asinh(x) applies the inverse hyperbolic sine operator to x + ++ asinh(x) applies the inverse hyperbolic sine operator to x acosh : F -> F - ++ acosh(x) applies the inverse hyperbolic cosine operator to x + ++ acosh(x) applies the inverse hyperbolic cosine operator to x atanh : F -> F - ++ atanh(x) applies the inverse hyperbolic tangent operator to x + ++ atanh(x) applies the inverse hyperbolic tangent operator to x acoth : F -> F - ++ acoth(x) applies the inverse hyperbolic cotangent operator to x + ++ acoth(x) applies the inverse hyperbolic cotangent operator to x asech : F -> F - ++ asech(x) applies the inverse hyperbolic secant operator to x + ++ asech(x) applies the inverse hyperbolic secant operator to x acsch : F -> F - ++ acsch(x) applies the inverse hyperbolic cosecant operator to x + ++ acsch(x) applies the inverse hyperbolic cosecant operator to x pi : () -> F - ++ pi() returns the pi operator + ++ pi() returns the pi operator belong? : OP -> Boolean - ++ belong?(p) returns true if operator p is elementary + ++ belong?(p) returns true if operator p is elementary operator: OP -> OP - ++ operator(p) returns an elementary operator with the same symbol as p + ++ operator(p) returns an elementary operator with the same symbol as p -- the following should be local, but are conditional iisqrt2 : () -> F - ++ iisqrt2() should be local but conditional + ++ iisqrt2() should be local but conditional iisqrt3 : () -> F - ++ iisqrt3() should be local but conditional + ++ iisqrt3() should be local but conditional iiexp : F -> F - ++ iiexp(x) should be local but conditional + ++ iiexp(x) should be local but conditional iilog : F -> F - ++ iilog(x) should be local but conditional + ++ iilog(x) should be local but conditional iisin : F -> F - ++ iisin(x) should be local but conditional + ++ iisin(x) should be local but conditional iicos : F -> F - ++ iicos(x) should be local but conditional + ++ iicos(x) should be local but conditional iitan : F -> F - ++ iitan(x) should be local but conditional + ++ iitan(x) should be local but conditional iicot : F -> F - ++ iicot(x) should be local but conditional + ++ iicot(x) should be local but conditional iisec : F -> F - ++ iisec(x) should be local but conditional + ++ iisec(x) should be local but conditional iicsc : F -> F - ++ iicsc(x) should be local but conditional + ++ iicsc(x) should be local but conditional iiasin : F -> F - ++ iiasin(x) should be local but conditional + ++ iiasin(x) should be local but conditional iiacos : F -> F - ++ iiacos(x) should be local but conditional + ++ iiacos(x) should be local but conditional iiatan : F -> F - ++ iiatan(x) should be local but conditional + ++ iiatan(x) should be local but conditional iiacot : F -> F - ++ iiacot(x) should be local but conditional + ++ iiacot(x) should be local but conditional iiasec : F -> F - ++ iiasec(x) should be local but conditional + ++ iiasec(x) should be local but conditional iiacsc : F -> F - ++ iiacsc(x) should be local but conditional + ++ iiacsc(x) should be local but conditional iisinh : F -> F - ++ iisinh(x) should be local but conditional + ++ iisinh(x) should be local but conditional iicosh : F -> F - ++ iicosh(x) should be local but conditional + ++ iicosh(x) should be local but conditional iitanh : F -> F - ++ iitanh(x) should be local but conditional + ++ iitanh(x) should be local but conditional iicoth : F -> F - ++ iicoth(x) should be local but conditional + ++ iicoth(x) should be local but conditional iisech : F -> F - ++ iisech(x) should be local but conditional + ++ iisech(x) should be local but conditional iicsch : F -> F - ++ iicsch(x) should be local but conditional + ++ iicsch(x) should be local but conditional iiasinh : F -> F - ++ iiasinh(x) should be local but conditional + ++ iiasinh(x) should be local but conditional iiacosh : F -> F - ++ iiacosh(x) should be local but conditional + ++ iiacosh(x) should be local but conditional iiatanh : F -> F - ++ iiatanh(x) should be local but conditional + ++ iiatanh(x) should be local but conditional iiacoth : F -> F - ++ iiacoth(x) should be local but conditional + ++ iiacoth(x) should be local but conditional iiasech : F -> F - ++ iiasech(x) should be local but conditional + ++ iiasech(x) should be local but conditional iiacsch : F -> F - ++ iiacsch(x) should be local but conditional + ++ iiacsch(x) should be local but conditional specialTrigs:(F, L Record(func:F,pole:B)) -> Union(F, "failed") - ++ specialTrigs(x,l) should be local but conditional + ++ specialTrigs(x,l) should be local but conditional localReal?: F -> Boolean - ++ localReal?(x) should be local but conditional + ++ localReal?(x) should be local but conditional Implementation ==> add ipi : List F -> F @@ -16801,14 +16848,14 @@ ElementaryFunction(R, F): Exports == Implementation where <>= )abbrev package DEFINTEF ElementaryFunctionDefiniteIntegration -++ Definite integration of elementary functions. ++ Author: Manuel Bronstein ++ Date Created: 14 April 1992 ++ Date Last Updated: 2 February 1993 ++ Description: -++ \spadtype{ElementaryFunctionDefiniteIntegration} -++ provides functions to compute definite -++ integrals of elementary functions. +++ \spadtype{ElementaryFunctionDefiniteIntegration} +++ provides functions to compute definite +++ integrals of elementary functions. + ElementaryFunctionDefiniteIntegration(R, F): Exports == Implementation where R : Join(EuclideanDomain, OrderedSet, CharacteristicZero, RetractableTo Integer, LinearlyExplicitRingOver Integer) @@ -17030,11 +17077,12 @@ ElementaryFunctionDefiniteIntegration(R, F): Exports == Implementation where ++ Author: Manuel Bronstein ++ Date Created: 3 February 1994 ++ Date Last Updated: 9 March 1994 +++ Keywords: differential equation, ODE ++ Description: ++ \spad{ElementaryFunctionLODESolver} provides the top-level ++ functions for finding closed form solutions of linear ordinary ++ differential equations and initial value problems. -++ Keywords: differential equation, ODE + ElementaryFunctionLODESolver(R, F, L): Exports == Implementation where R: Join(OrderedSet, EuclideanDomain, RetractableTo Integer, LinearlyExplicitRingOver Integer, CharacteristicZero) @@ -17300,11 +17348,12 @@ ElementaryFunctionLODESolver(R, F, L): Exports == Implementation where ++ Author: Manuel Bronstein ++ Date Created: 18 March 1991 ++ Date Last Updated: 8 March 1994 +++ Keywords: differential equation, ODE ++ Description: ++ \spad{ElementaryFunctionODESolver} provides the top-level ++ functions for finding closed form solutions of ordinary ++ differential equations and initial value problems. -++ Keywords: differential equation, ODE + ElementaryFunctionODESolver(R, F): Exports == Implementation where R: Join(OrderedSet, EuclideanDomain, RetractableTo Integer, LinearlyExplicitRingOver Integer, CharacteristicZero) @@ -17584,8 +17633,9 @@ ElementaryFunctionODESolver(R, F): Exports == Implementation where ++ Examples: ++ References: ++ Description: -++ This package provides functions to determine the sign of an -++ elementary function around a point or infinity. +++ This package provides functions to determine the sign of an +++ elementary function around a point or infinity. + ElementaryFunctionSign(R,F): Exports == Implementation where R : Join(IntegralDomain,OrderedSet,RetractableTo Integer,_ LinearlyExplicitRingOver Integer,GcdDomain) @@ -17786,17 +17836,17 @@ ElementaryFunctionSign(R,F): Exports == Implementation where <>= )abbrev package EFSTRUC ElementaryFunctionStructurePackage -++ Risch structure theorem ++ Author: Manuel Bronstein ++ Date Created: 1987 ++ Date Last Updated: 16 August 1995 -++ Description: -++ ElementaryFunctionStructurePackage provides functions to test the -++ algebraic independence of various elementary functions, using the -++ Risch structure theorem (real and complex versions). -++ It also provides transformations on elementary functions -++ which are not considered simplifications. ++ Keywords: elementary, function, structure. +++ Description: +++ ElementaryFunctionStructurePackage provides functions to test the +++ algebraic independence of various elementary functions, using the +++ Risch structure theorem (real and complex versions). +++ It also provides transformations on elementary functions +++ which are not considered simplifications. + ElementaryFunctionStructurePackage(R,F): Exports == Implementation where R : Join(IntegralDomain, OrderedSet, RetractableTo Integer, LinearlyExplicitRingOver Integer) @@ -18251,22 +18301,23 @@ ElementaryFunctionStructurePackage(R,F): Exports == Implementation where <>= )abbrev package EFULS ElementaryFunctionsUnivariateLaurentSeries -++ This package provides elementary functions on Laurent series. ++ Author: Clifton J. Williamson ++ Date Created: 6 February 1990 ++ Date Last Updated: 25 February 1990 ++ Keywords: elementary function, Laurent series ++ Examples: ++ References: +++ Description: +++ 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. + ElementaryFunctionsUnivariateLaurentSeries(Coef,UTS,ULS):_ Exports == Implementation where - ++ 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. Coef : Algebra Fraction Integer UTS : UnivariateTaylorSeriesCategory Coef ULS : UnivariateLaurentSeriesConstructorCategory(Coef,UTS) @@ -18665,22 +18716,21 @@ ElementaryFunctionsUnivariateLaurentSeries(Coef,UTS,ULS):_ <>= )abbrev package EFUPXS ElementaryFunctionsUnivariatePuiseuxSeries -++ This package provides elementary functions on Puiseux series. ++ Author: Clifton J. Williamson ++ Date Created: 20 February 1990 ++ Date Last Updated: 20 February 1990 -++ Keywords: elementary function, Laurent series -++ Examples: ++ References: +++ Description: +++ 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. + ElementaryFunctionsUnivariatePuiseuxSeries(Coef,ULS,UPXS,EFULS):_ Exports == Implementation where - ++ 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. Coef : Algebra Fraction Integer ULS : UnivariateLaurentSeriesCategory Coef UPXS : UnivariatePuiseuxSeriesConstructorCategory(Coef,ULS) @@ -18945,16 +18995,15 @@ ElementaryFunctionsUnivariatePuiseuxSeries(Coef,ULS,UPXS,EFULS):_ <>= )abbrev package INTEF ElementaryIntegration -++ Integration of elementary functions ++ Author: Manuel Bronstein ++ Date Created: 1 February 1988 ++ Date Last Updated: 24 October 1995 +++ Keywords: elementary, function, integration. ++ Description: ++ This package provides functions for integration, limited integration, ++ extended integration and the risch differential equation for -++ elemntary functions. -++ Keywords: elementary, function, integration. -++ Examples: )r INTEF INPUT +++ elementary functions. + ElementaryIntegration(R, F): Exports == Implementation where R : Join(GcdDomain, OrderedSet, CharacteristicZero, RetractableTo Integer, LinearlyExplicitRingOver Integer) @@ -19365,11 +19414,13 @@ See the above discussion for why this causes an infinite loop. <>= )abbrev package RDEEF ElementaryRischDE -++ Risch differential equation, elementary case. ++ Author: Manuel Bronstein ++ Date Created: 1 February 1988 ++ Date Last Updated: 2 November 1995 ++ Keywords: elementary, function, integration. +++ Description: +++ Risch differential equation, elementary case. + ElementaryRischDE(R, F): Exports == Implementation where R : Join(GcdDomain, OrderedSet, CharacteristicZero, RetractableTo Integer, LinearlyExplicitRingOver Integer) @@ -19754,11 +19805,13 @@ ElementaryRischDE(R, F): Exports == Implementation where <>= )abbrev package RDEEFS ElementaryRischDESystem -++ Risch differential equation, elementary case. ++ Author: Manuel Bronstein ++ Date Created: 12 August 1992 ++ Date Last Updated: 17 August 1992 ++ Keywords: elementary, function, integration. +++ Description: +++ Risch differential equation, elementary case. + ElementaryRischDESystem(R, F): Exports == Implementation where R : Join(GcdDomain, OrderedSet, CharacteristicZero, RetractableTo Integer, LinearlyExplicitRingOver Integer) @@ -19867,15 +19920,15 @@ ElementaryRischDESystem(R, F): Exports == Implementation where <>= )abbrev package ELFUTS EllipticFunctionsUnivariateTaylorSeries -++ Elliptic functions expanded as Taylor series ++ Author: Bill Burge, Clifton J. Williamson ++ Date Created: 1986 ++ Date Last Updated: 17 February 1992 ++ Keywords: elliptic function, Taylor series ++ Examples: ++ References: -++ Description: The elliptic functions sn, sc and dn are expanded as -++ Taylor series. +++ Description: +++ The elliptic functions sn, sc and dn are expanded as Taylor series. + EllipticFunctionsUnivariateTaylorSeries(Coef,UTS): Exports == Implementation where Coef : Field @@ -19947,10 +20000,11 @@ EllipticFunctionsUnivariateTaylorSeries(Coef,UTS): ++ Examples: ++ References: ++ Description: -++ This package provides operations for mapping the sides of equations. +++ This package provides operations for mapping the sides of equations. + EquationFunctions2(S: Type, R: Type): with map: (S ->R ,Equation S) -> Equation R - ++ map(f,eq) returns an equation where f is applied to the sides of eq + ++ map(f,eq) returns an equation where f is applied to the sides of eq == add map(fn, eqn) == equation(fn lhs eqn, fn rhs eqn) @@ -19986,30 +20040,30 @@ EquationFunctions2(S: Type, R: Type): with ++ string or a list of strings, as above. When you use the one ++ argument version in an interpreter function, the system will ++ automatically insert the name of the function as the new first -++ argument. Thus in the user interpreter function -++ \spad{f x == if x < 0 then error "negative argument" else x} -++ the call to error will actually be of the form -++ \spad{error("f","negative argument")} +++ argument. Thus in the user interpreter function\br +++ \tab{5}\spad{f x == if x < 0 then error "negative argument" else x}\br +++ the call to error will actually be of the form\br +++ \tab{5}\spad{error("f","negative argument")}\br ++ because the interpreter will have created a new first argument. ++ ++ Formatting codes: error messages may contain the following ++ formatting codes (they should either start or end a string or -++ else have blanks around them): -++ \spad{%l} start a new line -++ \spad{%b} start printing in a bold font (where available) -++ \spad{%d} stop printing in a bold font (where available) -++ \spad{ %ceon} start centering message lines -++ \spad{%ceoff} stop centering message lines -++ \spad{%rjon} start displaying lines "ragged left" -++ \spad{%rjoff} stop displaying lines "ragged left" -++ \spad{%i} indent following lines 3 additional spaces -++ \spad{%u} unindent following lines 3 additional spaces -++ \spad{%xN} insert N blanks (eg, \spad{%x10} inserts 10 blanks) +++ else have blanks around them):\br +++ \spad{%l}\tab{6}start a new line\br +++ \spad{%b}\tab{6}start printing in a bold font (where available)\br +++ \spad{%d}\tab{6}stop printing in a bold font (where available)\br +++ \spad{%ceon}\tab{3}start centering message lines\br +++ \spad{%ceoff}\tab{2}stop centering message lines\br +++ \spad{%rjon}\tab{3}start displaying lines "ragged left"\br +++ \spad{%rjoff}\tab{2}stop displaying lines "ragged left"\br +++ \spad{%i}\tab{6}indent following lines 3 additional spaces\br +++ \spad{%u}\tab{6}unindent following lines 3 additional spaces\br +++ \spad{%xN}\tab{5}insert N blanks (eg, \spad{%x10} inserts 10 blanks) ++ -++ Examples: -++ 1. \spad{error "Whoops, you made a %l %ceon %b big %d %ceoff %l mistake!"} -++ 2. \spad{error ["Whoops, you made a","%l %ceon %b","big", -++ "%d %ceoff %l","mistake!"]} +++ Examples:\br +++ 1.\spad{error "Whoops, you made a %l %ceon %b big %d %ceoff %l mistake!"}\br +++ 2.\spad{error ["Whoops, you made a","%l %ceon %b","big",\br +++ \tab{10}"%d %ceoff %l","mistake!"]} ErrorFunctions() : Exports == Implementation where Exports ==> with @@ -21204,7 +21258,8 @@ o )show GroebnerPackage ++ AMS Classifications: ++ Keywords: groebner basis, polynomial ideal, euclidean domain ++ References: -++ Description: \spadtype{EuclideanGroebnerBasisPackage} computes groebner +++ Description: +++ \spadtype{EuclideanGroebnerBasisPackage} computes groebner ++ bases for polynomial ideals over euclidean domains. ++ The basic computation provides ++ a distinguished set of generators for these ideals. @@ -21212,7 +21267,7 @@ o )show GroebnerPackage ++ \spadfun{euclideanNormalForm} returns zero on ideal members. The string ++ "info" and "redcrit" can be given as additional args to provide ++ incremental information during the computation. If "info" is given, -++ a computational summary is given for each s-polynomial. If "redcrit" +++ a computational summary is given for each s-polynomial. If "redcrit" ++ is given, the reduced critical pairs are printed. The term ordering ++ is determined by the polynomial type used. Suggested types include ++ \spadtype{DistributedMultivariatePolynomial}, @@ -21761,9 +21816,10 @@ EuclideanGroebnerBasisPackage(Dom, Expon, VarSet, Dpol): T == C where ++ Keywords: ++ Examples: ++ References: -++ Description: This package is to be used in conjuction with -++ the CycleIndicators package. It provides an evaluation -++ function for SymmetricPolynomials. +++ Description: +++ This package is to be used in conjuction with the CycleIndicators package. +++ It provides an evaluation function for SymmetricPolynomials. + EvaluateCycleIndicators(F):T==C where F:Algebra Fraction Integer I==>Integer @@ -21827,8 +21883,8 @@ EvaluateCycleIndicators(F):T==C where ++ Basic Operations: problemPoints, singularitiesOf, zerosOf ++ Related Constructors: ++ Description: -++ ExpertSystemContinuityPackage is a package of functions for the use of domains -++ belonging to the category \axiomType{NumericalIntegration}. +++ ExpertSystemContinuityPackage is a package of functions for the use of +++ domains belonging to the category \axiomType{NumericalIntegration}. ExpertSystemContinuityPackage(): E == I where EF2 ==> ExpressionFunctions2 @@ -22193,56 +22249,57 @@ ExpertSystemContinuityPackage1(A:DF,B:DF): E == I where ++ Description: ++ \axiom{ExpertSystemToolsPackage} contains some useful functions for use ++ by the computational agents of numerical solvers. + ExpertSystemToolsPackage():E == I where - LEDF ==> List Expression DoubleFloat - KEDF ==> Kernel Expression DoubleFloat - LKEDF ==> List Kernel Expression DoubleFloat - VEDF ==> Vector Expression DoubleFloat - VEF ==> Vector Expression Float - VMF ==> Vector MachineFloat - EF2 ==> ExpressionFunctions2 - EFI ==> Expression Fraction Integer - MDF ==> Matrix DoubleFloat - LDF ==> List DoubleFloat - PDF ==> Polynomial DoubleFloat - EDF ==> Expression DoubleFloat - EF ==> Expression Float - SDF ==> Stream DoubleFloat - DF ==> DoubleFloat - F ==> Float - MF ==> MachineFloat - INT ==> Integer - NNI ==> NonNegativeInteger - LS ==> List Symbol - ST ==> String - LST ==> List String - SS ==> Stream String - FI ==> Fraction Integer - R ==> Ring - OR ==> OrderedRing - ON ==> Record(additions:INT,multiplications:INT,exponentiations:INT,functionCalls:INT) - RVE ==> Record(val:EDF,exponent:INT) - BO ==> BasicOperator - OCF ==> OrderedCompletion Float - OCDF ==> OrderedCompletion DoubleFloat - SOCF ==> Segment OrderedCompletion Float - SOCDF ==> Segment OrderedCompletion DoubleFloat - Measure ==> Record(measure:F, name:String, explanations:List String) - Measure2 ==> Record(measure:F, name:String, explanations:List String, extra:Result) - CTYPE ==> Union(continuous: "Continuous at the end points", + LEDF ==> List Expression DoubleFloat + KEDF ==> Kernel Expression DoubleFloat + LKEDF ==> List Kernel Expression DoubleFloat + VEDF ==> Vector Expression DoubleFloat + VEF ==> Vector Expression Float + VMF ==> Vector MachineFloat + EF2 ==> ExpressionFunctions2 + EFI ==> Expression Fraction Integer + MDF ==> Matrix DoubleFloat + LDF ==> List DoubleFloat + PDF ==> Polynomial DoubleFloat + EDF ==> Expression DoubleFloat + EF ==> Expression Float + SDF ==> Stream DoubleFloat + DF ==> DoubleFloat + F ==> Float + MF ==> MachineFloat + INT ==> Integer + NNI ==> NonNegativeInteger + LS ==> List Symbol + ST ==> String + LST ==> List String + SS ==> Stream String + FI ==> Fraction Integer + R ==> Ring + OR ==> OrderedRing + ON ==> Record(additions:INT,multiplications:INT,exponentiations:INT,functionCalls:INT) + RVE ==> Record(val:EDF,exponent:INT) + BO ==> BasicOperator + OCF ==> OrderedCompletion Float + OCDF ==> OrderedCompletion DoubleFloat + SOCF ==> Segment OrderedCompletion Float + SOCDF ==> Segment OrderedCompletion DoubleFloat + Measure ==> Record(measure:F, name:String, explanations:List String) + Measure2 ==> Record(measure:F, name:String, explanations:List String, extra:Result) + CTYPE ==> Union(continuous: "Continuous at the end points", lowerSingular: "There is a singularity at the lower end point", upperSingular: "There is a singularity at the upper end point", bothSingular: "There are singularities at both end points", notEvaluated: "End point continuity not yet evaluated") - RTYPE ==> Union(finite: "The range is finite", + RTYPE ==> Union(finite: "The range is finite", lowerInfinite: "The bottom of range is infinite", upperInfinite: "The top of range is infinite", bothInfinite: "Both top and bottom points are infinite", notEvaluated: "Range not yet evaluated") - STYPE ==> Union(str:SDF, + STYPE ==> Union(str:SDF, notEvaluated:"Internal singularities not yet evaluated") - ATT ==> Record(endPointContinuity:CTYPE,singularitiesStream:STYPE,range:RTYPE) - IFV ==> Record(stiffness:F,stability:F,expense:F,accuracy:F,intermediateResults:F) + ATT ==> Record(endPointContinuity:CTYPE,singularitiesStream:STYPE,range:RTYPE) + IFV ==> Record(stiffness:F,stability:F,expense:F,accuracy:F,intermediateResults:F) E ==> with @@ -22579,8 +22636,9 @@ ExpertSystemToolsPackage():E == I where ++ Description: ++ \axiom{ExpertSystemToolsPackage1} contains some useful functions for use ++ by the computational agents of Ordinary Differential Equation solvers. + ExpertSystemToolsPackage1(R1:OR): E == I where - OR ==> OrderedRing + OR ==> OrderedRing E ==> with neglist:List R1 -> List R1 ++ neglist(l) returns only the negative elements of the list \spad{l} @@ -22612,8 +22670,9 @@ ExpertSystemToolsPackage1(R1:OR): E == I where ++ Description: ++ \axiom{ExpertSystemToolsPackage2} contains some useful functions for use ++ by the computational agents of Ordinary Differential Equation solvers. + ExpertSystemToolsPackage2(R1:R,R2:R): E == I where - R ==> Ring + R ==> Ring E ==> with map:(R1->R2,Matrix R1) -> Matrix R2 ++ map(f,m) applies a mapping f:R1 -> R2 onto a matrix @@ -22643,9 +22702,11 @@ ExpertSystemToolsPackage2(R1:R,R2:R): E == I where )abbrev package EXPR2 ExpressionFunctions2 ++ Lifting of maps to Expressions ++ Author: Manuel Bronstein -++ Description: Lifting of maps to Expressions. ++ Date Created: 16 Jan 1989 ++ Date Last Updated: 22 Jan 1990 +++ Description: +++ Lifting of maps to Expressions. + ExpressionFunctions2(R:OrderedSet, S:OrderedSet): Exports == Implementation where K ==> Kernel R @@ -22708,6 +22769,9 @@ works. This is probably due to missing ``/'' in UFPS. <>= )abbrev package EXPRSOL ExpressionSolve +++ Description: +++ This package has no description + ExpressionSolve(R, F, UTSF, UTSSUPF): Exports == Implementation where R: Join(OrderedSet, IntegralDomain, ConvertibleTo InputForm) F: FunctionSpace R @@ -22800,15 +22864,15 @@ coefficient ring, since it will complain otherwise. <>= )abbrev package ES1 ExpressionSpaceFunctions1 -++ Lifting of maps from expression spaces to kernels over them ++ Author: Manuel Bronstein ++ Date Created: 23 March 1988 ++ Date Last Updated: 19 April 1991 ++ Description: -++ This package allows a map from any expression space into any object -++ to be lifted to a kernel over the expression set, using a given -++ property of the operator of the kernel. +++ This package allows a map from any expression space into any object +++ to be lifted to a kernel over the expression set, using a given +++ property of the operator of the kernel. -- should not be exposed + ExpressionSpaceFunctions1(F:ExpressionSpace, S:Type): with map: (F -> S, String, Kernel F) -> S ++ map(f, p, k) uses the property p of the operator @@ -22839,7 +22903,6 @@ ExpressionSpaceFunctions1(F:ExpressionSpace, S:Type): with <>= )abbrev package ES2 ExpressionSpaceFunctions2 -++ Lifting of maps from expression spaces to kernels over them ++ Author: Manuel Bronstein ++ Date Created: 23 March 1988 ++ Date Last Updated: 19 April 1991 @@ -22848,6 +22911,7 @@ ExpressionSpaceFunctions1(F:ExpressionSpace, S:Type): with ++ This lifting can fail if the operator of the kernel cannot be applied ++ in F; Do not use this package with E = F, since this may ++ drop some properties of the operators. + ExpressionSpaceFunctions2(E:ExpressionSpace, F:ExpressionSpace): with map: (E -> F, Kernel E) -> F ++ map(f, k) returns \spad{g = op(f(a1),...,f(an))} where @@ -22873,12 +22937,13 @@ ExpressionSpaceFunctions2(E:ExpressionSpace, F:ExpressionSpace): with <>= )abbrev package EXPRODE ExpressionSpaceODESolver -++ Taylor series solutions of ODE's ++ Author: Manuel Bronstein ++ Date Created: 5 Mar 1990 ++ Date Last Updated: 30 September 1993 -++ Description: Taylor series solutions of explicit ODE's; ++ Keywords: differential equation, ODE, Taylor series +++ Description: +++ Taylor series solutions of explicit ODE's; + ExpressionSpaceODESolver(R, F): Exports == Implementation where R: Join(OrderedSet, IntegralDomain, ConvertibleTo InputForm) F: FunctionSpace R @@ -22899,7 +22964,7 @@ ExpressionSpaceODESolver(R, F): Exports == Implementation where seriesSolve: (EQ, OP, EQ, EQ) -> Any ++ seriesSolve(eq,y,x=a, y a = b) returns a Taylor series solution ++ of eq around x = a with initial condition \spad{y(a) = b}. - ++ Note: eq must be of the form + ++ Note that eq must be of the form ++ \spad{f(x, y x) y'(x) + g(x, y x) = h(x, y x)}. seriesSolve: (EQ, OP, EQ, List F) -> Any ++ seriesSolve(eq,y,x=a,[b0,...,b(n-1)]) returns a Taylor series @@ -22913,7 +22978,7 @@ ExpressionSpaceODESolver(R, F): Exports == Implementation where ++ seriesSolve([eq1,...,eqn],[y1,...,yn],x = a,[y1 a = b1,...,yn a = bn]) ++ returns a taylor series solution of \spad{[eq1,...,eqn]} around ++ \spad{x = a} with initial conditions \spad{yi(a) = bi}. - ++ Note: eqi must be of the form + ++ Note that eqi must be of the form ++ \spad{fi(x, y1 x, y2 x,..., yn x) y1'(x) + ++ gi(x, y1 x, y2 x,..., yn x) = h(x, y1 x, y2 x,..., yn x)}. seriesSolve: (List EQ, List OP, EQ, List F) -> Any @@ -23097,8 +23162,10 @@ ExpressionSpaceODESolver(R, F): Exports == Implementation where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: \spadtype{ExpressionToOpenMath} provides support for +++ Description: +++ \spadtype{ExpressionToOpenMath} provides support for ++ converting objects of type \spadtype{Expression} into OpenMath. + ExpressionToOpenMath(R: Join(OpenMath, OrderedSet, Ring)): with OMwrite : Expression R -> String OMwrite : (Expression R, Boolean) -> String @@ -23395,8 +23462,9 @@ ExpressionToOpenMath(R: Join(OpenMath, OrderedSet, Ring)): with ++ Examples: ++ References: ++ Description: -++ This package provides functions to convert functional expressions -++ to power series. +++ This package provides functions to convert functional expressions +++ to power series. + ExpressionToUnivariatePowerSeries(R,FE): Exports == Implementation where R : Join(GcdDomain,OrderedSet,RetractableTo Integer,_ LinearlyExplicitRingOver Integer) @@ -23423,11 +23491,11 @@ ExpressionToUnivariatePowerSeries(R,FE): Exports == Implementation where ++ \spad{taylor(x)} returns x viewed as a Taylor series. taylor: FE -> Any ++ \spad{taylor(f)} returns a Taylor expansion of the expression f. - ++ Note: f should have only one variable; the series will be + ++ Note that f should have only one variable; the series will be ++ expanded in powers of that variable. taylor: (FE,NNI) -> Any ++ \spad{taylor(f,n)} returns a Taylor expansion of the expression f. - ++ Note: f should have only one variable; the series will be + ++ Note that f should have only one variable; the series will be ++ expanded in powers of that variable and terms will be computed ++ up to order at least n. taylor: (FE,EQ FE) -> Any @@ -23442,11 +23510,11 @@ ExpressionToUnivariatePowerSeries(R,FE): Exports == Implementation where ++ \spad{laurent(x)} returns x viewed as a Laurent series. laurent: FE -> Any ++ \spad{laurent(f)} returns a Laurent expansion of the expression f. - ++ Note: f should have only one variable; the series will be + ++ Note that f should have only one variable; the series will be ++ expanded in powers of that variable. laurent: (FE,I) -> Any ++ \spad{laurent(f,n)} returns a Laurent expansion of the expression f. - ++ Note: f should have only one variable; the series will be + ++ Note that f should have only one variable; the series will be ++ expanded in powers of that variable and terms will be computed ++ up to order at least n. laurent: (FE,EQ FE) -> Any @@ -23460,11 +23528,11 @@ ExpressionToUnivariatePowerSeries(R,FE): Exports == Implementation where ++ \spad{puiseux(x)} returns x viewed as a Puiseux series. puiseux: FE -> Any ++ \spad{puiseux(f)} returns a Puiseux expansion of the expression f. - ++ Note: f should have only one variable; the series will be + ++ Note that f should have only one variable; the series will be ++ expanded in powers of that variable. puiseux: (FE,RN) -> Any ++ \spad{puiseux(f,n)} returns a Puiseux expansion of the expression f. - ++ Note: f should have only one variable; the series will be + ++ Note that f should have only one variable; the series will be ++ expanded in powers of that variable and terms will be computed ++ up to order at least n. puiseux: (FE,EQ FE) -> Any @@ -23479,11 +23547,11 @@ ExpressionToUnivariatePowerSeries(R,FE): Exports == Implementation where ++ \spad{series(x)} returns x viewed as a series. series: FE -> Any ++ \spad{series(f)} returns a series expansion of the expression f. - ++ Note: f should have only one variable; the series will be + ++ Note that f should have only one variable; the series will be ++ expanded in powers of that variable. series: (FE,RN) -> Any ++ \spad{series(f,n)} returns a series expansion of the expression f. - ++ Note: f should have only one variable; the series will be + ++ Note that f should have only one variable; the series will be ++ expanded in powers of that variable and terms will be computed ++ up to order at least n. series: (FE,EQ FE) -> Any @@ -23732,8 +23800,9 @@ ExpressionToUnivariatePowerSeries(R,FE): Exports == Implementation where ++ Date Created: Bastille Day 1989 ++ Date Last Updated: 5 June 1990 ++ Keywords: -++ Examples: +++ Description: ++ Package for constructing tubes around 3-dimensional parametric curves. + ExpressionTubePlot(): Exports == Implementation where B ==> Boolean I ==> Integer @@ -23869,7 +23938,7 @@ ExpressionTubePlot(): Exports == Implementation where cosSin := cosSinInfo n loopList : L L Pt := nil() while not null tvals repeat - -- note: tvals and curvePts have the same number of elements + -- note that tvals and curvePts have the same number of elements tval := first tvals; tvals := rest tvals ctr := first curvePts; curvePts := rest curvePts pNormList : L SF := @@ -23942,27 +24011,28 @@ ExpressionTubePlot(): Exports == Implementation where ++ \axiomType{e04AgentsPackage} is a package of numerical agents to be used ++ to investigate attributes of an input function so as to decide the ++ \axiomFun{measure} of an appropriate numerical optimization routine. -MDF ==> Matrix DoubleFloat -VEDF ==> Vector Expression DoubleFloat -EDF ==> Expression DoubleFloat -EFI ==> Expression Fraction Integer -PFI ==> Polynomial Fraction Integer -FI ==> Fraction Integer -F ==> Float -DF ==> DoubleFloat -OCDF ==> OrderedCompletion DoubleFloat -LOCDF ==> List OrderedCompletion DoubleFloat -LEDF ==> List Expression DoubleFloat -PDF ==> Polynomial DoubleFloat -LDF ==> List DoubleFloat -INT ==> Integer -NNI ==> NonNegativeInteger -LS ==> List Symbol -EF2 ==> ExpressionFunctions2 -NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) -LSA ==> Record(lfn:LEDF, init:LDF) e04AgentsPackage(): E == I where + MDF ==> Matrix DoubleFloat + VEDF ==> Vector Expression DoubleFloat + EDF ==> Expression DoubleFloat + EFI ==> Expression Fraction Integer + PFI ==> Polynomial Fraction Integer + FI ==> Fraction Integer + F ==> Float + DF ==> DoubleFloat + OCDF ==> OrderedCompletion DoubleFloat + LOCDF ==> List OrderedCompletion DoubleFloat + LEDF ==> List Expression DoubleFloat + PDF ==> Polynomial DoubleFloat + LDF ==> List DoubleFloat + INT ==> Integer + NNI ==> NonNegativeInteger + LS ==> List Symbol + EF2 ==> ExpressionFunctions2 + NOA ==> Record(fn:EDF, init:LDF, lb:LOCDF, cf:LEDF, ub:LOCDF) + LSA ==> Record(lfn:LEDF, init:LDF) + E ==> with finiteBound:(LOCDF,DF) -> LDF ++ finiteBound(l,b) repaces all instances of an infinite entry in @@ -23992,7 +24062,7 @@ e04AgentsPackage(): E == I where linearPart:LEDF -> LEDF ++ linearPart(l) returns the list of linear functions of \axiom{l}. nonLinearPart:LEDF -> LEDF - ++ nonLinearPart(l) returns the list of non-linear functions of \axiom{l}. + ++ nonLinearPart(l) returns the list of non-linear functions of l. quadratic?:EDF -> Boolean ++ quadratic?(e) tests if \axiom{e} is a quadratic function. variables:LSA -> LS @@ -24214,8 +24284,10 @@ e04AgentsPackage(): E == I where ++ Author: Manuel Bronstein ++ Date Created: 2 Feb 1988 ++ Date Last Updated: 25 Jun 1990 -++ Description: computes various functions on factored arguments. +++ Description: +++ computes various functions on factored arguments. -- not visible to the user + FactoredFunctions(M:IntegralDomain): Exports == Implementation where N ==> NonNegativeInteger @@ -24390,11 +24462,12 @@ o )show FactoredFunctions2 ++ Keywords: map, factor ++ References: ++ Description: -++ \spadtype{FactoredFunctions2} contains functions that involve -++ factored objects whose underlying domains may not be the same. -++ For example, \spadfun{map} might be used to coerce an object of -++ type \spadtype{Factored(Integer)} to -++ \spadtype{Factored(Complex(Integer))}. +++ \spadtype{FactoredFunctions2} contains functions that involve +++ factored objects whose underlying domains may not be the same. +++ For example, \spadfun{map} might be used to coerce an object of +++ type \spadtype{Factored(Integer)} to +++ \spadtype{Factored(Complex(Integer))}. + FactoredFunctions2(R, S): Exports == Implementation where R: IntegralDomain S: IntegralDomain @@ -24441,8 +24514,9 @@ FactoredFunctions2(R, S): Exports == Implementation where ++ Keywords: factor ++ References: ++ Description: -++ \spadtype{FactoredFunctionUtilities} implements some utility -++ functions for manipulating factored objects. +++ \spadtype{FactoredFunctionUtilities} implements some utility +++ functions for manipulating factored objects. + FactoredFunctionUtilities(R): Exports == Implementation where R: IntegralDomain FR ==> Factored R @@ -24585,7 +24659,7 @@ FactoringUtilities(E,OV,R,P) : C == T where if R has FiniteFieldCategory then ran(k:Z):R == random()$R else - ran(k:Z):R == (random(2*k+1)$Z -k)::R + ran(k:Z):R == (random(2*k+1)$Z -k)::R -- Compute the normalized m derivative normalDeriv(f:SUP P,m:Z) : SUP P== @@ -24631,9 +24705,9 @@ FactoringUtilities(E,OV,R,P) : C == T where ++ This is just an interface between several packages and domains. ++ The goal is to compute lexicographical Groebner bases ++ of sets of polynomial with type \spadtype{Polynomial R} -++ by the {\em FGLM} algorithm if this is possible (i.e. +++ by the FGLM algorithm if this is possible (i.e. ++ if the input system generates a zero-dimensional ideal). -++ Version: 1. + FGLMIfCanPackage(R,ls): Exports == Implementation where R: GcdDomain ls: List Symbol @@ -24658,13 +24732,13 @@ FGLMIfCanPackage(R,ls): Exports == Implementation where ++ w.r.t. the variables of \axiom{ls}. fglmIfCan: List(Q1) -> Union(List(Q1), "failed") ++ \axiom{fglmIfCan(lq1)} returns the lexicographical Groebner - ++ basis of \axiom{lq1} by using the {\em FGLM} strategy, + ++ basis of \axiom{lq1} by using the FGLM strategy, ++ if \axiom{zeroDimensional?(lq1)} holds. groebner: List(Q1) -> List(Q1) ++ \axiom{groebner(lq1)} returns the lexicographical Groebner ++ basis of \axiom{lq1}. If \axiom{lq1} generates a zero-dimensional - ++ ideal then the {\em FGLM} strategy is used, otherwise - ++ the {\em Sugar} strategy is used. + ++ ideal then the FGLM strategy is used, otherwise + ++ the Sugar strategy is used. Implementation == add @@ -24721,10 +24795,12 @@ FGLMIfCanPackage(R,ls): Exports == Implementation where <>= )abbrev package FORDER FindOrderFinite -++ Finds the order of a divisor over a finite field ++ Author: Manuel Bronstein ++ Date Created: 1988 ++ Date Last Updated: 11 Jul 1990 +++ Description: +++ Finds the order of a divisor over a finite field + FindOrderFinite(F, UP, UPUP, R): Exports == Implementation where F : Join(Finite, Field) UP : UnivariatePolynomialCategory F @@ -24733,7 +24809,7 @@ FindOrderFinite(F, UP, UPUP, R): Exports == Implementation where Exports ==> with order: FiniteDivisor(F, UP, UPUP, R) -> NonNegativeInteger - ++ order(x) \undocumented + ++ order(x) \undocumented Implementation ==> add order d == dd := d := reduce d @@ -24764,6 +24840,7 @@ FindOrderFinite(F, UP, UPUP, R): Exports == Implementation where ++ \spadtype{FiniteAbelianMonoidRing} ++ The packages defined in this file provide fast fraction free rational ++ interpolation algorithms. (see FAMR2, FFFG, FFFGF, NEWTON) + FiniteAbelianMonoidRingFunctions2(E: OrderedAbelianMonoid, R1: Ring, A1: FiniteAbelianMonoidRing(R1, E), @@ -24800,10 +24877,12 @@ FiniteAbelianMonoidRingFunctions2(E: OrderedAbelianMonoid, <>= )abbrev package FDIV2 FiniteDivisorFunctions2 -++ Lift a map to finite divisors. ++ Author: Manuel Bronstein ++ Date Created: 1988 ++ Date Last Updated: 19 May 1993 +++ Description: +++ Lift a map to finite divisors. + FiniteDivisorFunctions2(R1, UP1, UPUP1, F1, R2, UP2, UPUP2, F2): Exports == Implementation where R1 : Field @@ -24818,7 +24897,7 @@ FiniteDivisorFunctions2(R1, UP1, UPUP1, F1, R2, UP2, UPUP2, F2): Exports ==> with map: (R1 -> R2, FiniteDivisor(R1, UP1, UPUP1, F1)) -> FiniteDivisor(R2, UP2, UPUP2, F2) - ++ map(f,d) \undocumented{} + ++ map(f,d) \undocumented{} Implementation ==> add import UnivariatePolynomialCategoryFunctions2(R1,UP1,R2,UP2) @@ -24862,16 +24941,16 @@ FiniteDivisorFunctions2(R1, UP1, UPUP1, F1, R2, UP2, UPUP2, F2): ++ Related Constructors: ++ Also See: ++ AMS Classifications: +++ Keywords: finite field, Zech logarithm, Jacobi logarithm, normal basis ++ References: ++ Lidl, R. & Niederreiter, H., "Finite Fields", ++ Encycl. of Math. 20, Addison-Wesley, 1983 ++ J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM. ++ AXIOM Technical Report Series, ATR/5 NP2522. ++ Description: -++ FiniteFieldFunctions(GF) is a package with functions -++ concerning finite extension fields of the finite ground field {\em GF}, -++ e.g. Zech logarithms. -++ Keywords: finite field, Zech logarithm, Jacobi logarithm, normal basis +++ FiniteFieldFunctions(GF) is a package with functions +++ concerning finite extension fields of the finite ground field GF, +++ e.g. Zech logarithms. FiniteFieldFunctions(GF): Exports == Implementation where GF : FiniteFieldCategory -- the ground field @@ -24896,40 +24975,39 @@ FiniteFieldFunctions(GF): Exports == Implementation where createZechTable: SUP -> ARR ++ createZechTable(f) generates a Zech logarithm table for the cyclic ++ group representation of a extension of the ground field by the - ++ primitive polynomial {\em f(x)}, i.e. \spad{Z(i)}, - ++ defined by {\em x**Z(i) = 1+x**i} is stored at index i. + ++ primitive polynomial f(x), i.e. \spad{Z(i)}, + ++ defined by x**Z(i) = 1+x**i is stored at index i. ++ This is needed in particular ++ to perform addition of field elements in finite fields represented ++ in this way. See \spadtype{FFCGP}, \spadtype{FFCGX}. createMultiplicationTable: SUP -> V L TERM ++ createMultiplicationTable(f) generates a multiplication ++ table for the normal basis of the field extension determined - ++ by {\em f}. This is needed to perform multiplications + ++ by f. This is needed to perform multiplications ++ between elements represented as coordinate vectors to this basis. ++ See \spadtype{FFNBP}, \spadtype{FFNBX}. createMultiplicationMatrix: V L TERM -> M GF ++ createMultiplicationMatrix(m) forms the multiplication table - ++ {\em m} into a matrix over the ground field. + ++ m into a matrix over the ground field. -- only useful for the user to visualise the multiplication table -- in a nice form sizeMultiplication: V L TERM -> NNI ++ sizeMultiplication(m) returns the number of entries - ++ of the multiplication table {\em m}. + ++ of the multiplication table m. -- the time of the multiplication of field elements depends -- on this size createLowComplexityTable: PI -> Union(Vector List TERM,"failed") ++ createLowComplexityTable(n) tries to find - ++ a low complexity normal basis of degree {\em n} over {\em GF} + ++ a low complexity normal basis of degree n over GF ++ and returns its multiplication matrix ++ Fails, if it does not find a low complexity basis createLowComplexityNormalBasis: PI -> Union(SUP, V L TERM) ++ createLowComplexityNormalBasis(n) tries to find a - ++ a low complexity normal basis of degree {\em n} over {\em GF} + ++ a low complexity normal basis of degree n over GF ++ and returns its multiplication matrix ++ If no low complexity basis is found it calls ++ \axiomFunFrom{createNormalPoly}{FiniteFieldPolynomialPackage}(n) - ++ to produce a normal - ++ polynomial of degree {\em n} over {\em GF} + ++ to produce a normal polynomial of degree n over GF Implementation ==> add @@ -25125,9 +25203,10 @@ FiniteFieldFunctions(GF): Exports == Implementation where ++ J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM. ++ AXIOM Technical Report Series, ATR/5 NP2522. ++ Description: -++ FiniteFieldHomomorphisms(F1,GF,F2) exports coercion functions of -++ elements between the fields {\em F1} and {\em F2}, which both must be -++ finite simple algebraic extensions of the finite ground field {\em GF}. +++ FiniteFieldHomomorphisms(F1,GF,F2) exports coercion functions of +++ elements between the fields F1 and F2, which both must be +++ finite simple algebraic extensions of the finite ground field GF. + FiniteFieldHomomorphisms(F1,GF,F2): Exports == Implementation where F1: FiniteAlgebraicExtensionField(GF) GF: FiniteFieldCategory @@ -25153,23 +25232,23 @@ FiniteFieldHomomorphisms(F1,GF,F2): Exports == Implementation where coerce: F1 -> F2 ++ coerce(x) is the homomorphic image of x from - ++ {\em F1} in {\em F2}. Thus {\em coerce} is a + ++ F1 in F2. Thus coerce is a ++ field homomorphism between the fields extensions - ++ {\em F1} and {\em F2} both over ground field {\em GF} + ++ F1 and F2 both over ground field GF ++ (the second argument to the package). - ++ Error: if the extension degree of {\em F1} doesn't divide - ++ the extension degree of {\em F2}. + ++ Error: if the extension degree of F1 doesn't divide + ++ the extension degree of F2. ++ Note that the other coercion function in the ++ \spadtype{FiniteFieldHomomorphisms} is a left inverse. coerce: F2 -> F1 ++ coerce(x) is the homomorphic image of x from - ++ {\em F2} in {\em F1}, where {\em coerce} is a + ++ F2 in F1, where coerce is a ++ field homomorphism between the fields extensions - ++ {\em F2} and {\em F1} both over ground field {\em GF} + ++ F2 and F1 both over ground field GF ++ (the second argument to the package). - ++ Error: if the extension degree of {\em F2} doesn't divide - ++ the extension degree of {\em F1}. + ++ Error: if the extension degree of F2 doesn't divide + ++ the extension degree of F1. ++ Note that the other coercion function in the ++ \spadtype{FiniteFieldHomomorphisms} is a left inverse. -- coerce(coerce(x:F1)@F2)@F1 = x and coerce(coerce(y:F2)@F1)@F2 = y @@ -25525,9 +25604,9 @@ FiniteFieldHomomorphisms(F1,GF,F2): Exports == Implementation where ++ J. Grabmeier, A. Scheerhorn: Finite Fields in Axiom. ++ Axiom Technical Report Series, to appear. ++ Description: -++ This package provides a number of functions for generating, counting -++ and testing irreducible, normal, primitive, random polynomials -++ over finite fields. +++ This package provides a number of functions for generating, counting +++ and testing irreducible, normal, primitive, random polynomials +++ over finite fields. FiniteFieldPolynomialPackage GF : Exports == Implementation where @@ -25544,7 +25623,7 @@ FiniteFieldPolynomialPackage GF : Exports == Implementation where Exports ==> with -- qEulerPhiCyclotomic : PI -> PI -- ++ qEulerPhiCyclotomic(n)$FFPOLY(GF) yields the q-Euler's function --- ++ of the n-th cyclotomic polynomial over the field {\em GF} of +-- ++ of the n-th cyclotomic polynomial over the field GF of -- ++ order q (cf. [LN] p.122); -- ++ error if n is a multiple of the field characteristic. primitive? : SUP -> Boolean @@ -25556,36 +25635,36 @@ FiniteFieldPolynomialPackage GF : Exports == Implementation where numberOfIrreduciblePoly : PI -> PI ++ numberOfIrreduciblePoly(n)$FFPOLY(GF) yields the number of ++ monic irreducible univariate polynomials of degree n - ++ over the finite field {\em GF}. + ++ over the finite field GF. numberOfPrimitivePoly : PI -> PI ++ numberOfPrimitivePoly(n)$FFPOLY(GF) yields the number of - ++ primitive polynomials of degree n over the finite field {\em GF}. + ++ primitive polynomials of degree n over the finite field GF. numberOfNormalPoly : PI -> PI ++ numberOfNormalPoly(n)$FFPOLY(GF) yields the number of - ++ normal polynomials of degree n over the finite field {\em GF}. + ++ normal polynomials of degree n over the finite field GF. createIrreduciblePoly : PI -> SUP ++ createIrreduciblePoly(n)$FFPOLY(GF) generates a monic irreducible - ++ univariate polynomial of degree n over the finite field {\em GF}. + ++ univariate polynomial of degree n over the finite field GF. createPrimitivePoly : PI -> SUP ++ createPrimitivePoly(n)$FFPOLY(GF) generates a primitive polynomial - ++ of degree n over the finite field {\em GF}. + ++ of degree n over the finite field GF. createNormalPoly : PI -> SUP ++ createNormalPoly(n)$FFPOLY(GF) generates a normal polynomial - ++ of degree n over the finite field {\em GF}. + ++ of degree n over the finite field GF. createNormalPrimitivePoly : PI -> SUP ++ createNormalPrimitivePoly(n)$FFPOLY(GF) generates a normal and - ++ primitive polynomial of degree n over the field {\em GF}. - ++ Note: this function is equivalent to createPrimitiveNormalPoly(n) + ++ primitive polynomial of degree n over the field GF. + ++ Note that this function is equivalent to createPrimitiveNormalPoly(n) createPrimitiveNormalPoly : PI -> SUP ++ createPrimitiveNormalPoly(n)$FFPOLY(GF) generates a normal and - ++ primitive polynomial of degree n over the field {\em GF}. - ++ polynomial of degree n over the field {\em GF}. + ++ primitive polynomial of degree n over the field GF. + ++ polynomial of degree n over the field GF. nextIrreduciblePoly : SUP -> Union(SUP, "failed") ++ nextIrreduciblePoly(f) yields the next monic irreducible polynomial - ++ over a finite field {\em GF} of the same degree as f in the following + ++ over a finite field GF of the same degree as f in the following ++ order, or "failed" if there are no greater ones. ++ Error: if f has degree 0. - ++ Note: the input polynomial f is made monic. + ++ Note that the input polynomial f is made monic. ++ Also, \spad{f < g} if ++ the number of monomials of f is less ++ than this number for g. @@ -25593,14 +25672,14 @@ FiniteFieldPolynomialPackage GF : Exports == Implementation where ++ the lists of exponents are compared lexicographically. ++ If these lists are also equal, the lists of coefficients ++ are compared according to the lexicographic ordering induced by - ++ the ordering of the elements of {\em GF} given by {\em lookup}. + ++ the ordering of the elements of GF given by lookup. nextPrimitivePoly : SUP -> Union(SUP, "failed") ++ nextPrimitivePoly(f) yields the next primitive polynomial over - ++ a finite field {\em GF} of the same degree as f in the following + ++ a finite field GF of the same degree as f in the following ++ order, or "failed" if there are no greater ones. ++ Error: if f has degree 0. - ++ Note: the input polynomial f is made monic. - ++ Also, \spad{f < g} if the {\em lookup} of the constant term + ++ Note that the input polynomial f is made monic. + ++ Also, \spad{f < g} if the lookup of the constant term ++ of f is less than ++ this number for g. ++ If these values are equal, then \spad{f < g} if @@ -25609,33 +25688,33 @@ FiniteFieldPolynomialPackage GF : Exports == Implementation where ++ corresponding list for g. ++ If these lists are also equal, the lists of coefficients are ++ compared according to the lexicographic ordering induced by - ++ the ordering of the elements of {\em GF} given by {\em lookup}. + ++ the ordering of the elements of GF given by lookup. nextNormalPoly : SUP -> Union(SUP, "failed") ++ nextNormalPoly(f) yields the next normal polynomial over - ++ a finite field {\em GF} of the same degree as f in the following + ++ a finite field GF of the same degree as f in the following ++ order, or "failed" if there are no greater ones. ++ Error: if f has degree 0. - ++ Note: the input polynomial f is made monic. - ++ Also, \spad{f < g} if the {\em lookup} of the coefficient + ++ Note that the input polynomial f is made monic. + ++ Also, \spad{f < g} if the lookup of the coefficient ++ of the term of degree - ++ {\em n-1} of f is less than that for g. + ++ n-1 of f is less than that for g. ++ In case these numbers are equal, \spad{f < g} if ++ if the number of monomials of f is less that for g or if ++ the list of exponents of f are lexicographically less than the ++ corresponding list for g. ++ If these lists are also equal, the lists of coefficients are ++ compared according to the lexicographic ordering induced by - ++ the ordering of the elements of {\em GF} given by {\em lookup}. + ++ the ordering of the elements of GF given by lookup. nextNormalPrimitivePoly : SUP -> Union(SUP, "failed") ++ nextNormalPrimitivePoly(f) yields the next normal primitive polynomial - ++ over a finite field {\em GF} of the same degree as f in the following + ++ over a finite field GF of the same degree as f in the following ++ order, or "failed" if there are no greater ones. ++ Error: if f has degree 0. - ++ Note: the input polynomial f is made monic. - ++ Also, \spad{f < g} if the {\em lookup} of the constant + ++ Note that the input polynomial f is made monic. + ++ Also, \spad{f < g} if the lookup of the constant ++ term of f is less than ++ this number for g or if - ++ {\em lookup} of the coefficient of the term of degree {\em n-1} + ++ lookup of the coefficient of the term of degree n-1 ++ of f is less than this number for g. ++ Otherwise, \spad{f < g} ++ if the number of monomials of f is less than @@ -25643,18 +25722,18 @@ FiniteFieldPolynomialPackage GF : Exports == Implementation where ++ lexicographically less than those for g. ++ If these lists are also equal, the lists of coefficients are ++ compared according to the lexicographic ordering induced by - ++ the ordering of the elements of {\em GF} given by {\em lookup}. + ++ the ordering of the elements of GF given by lookup. ++ This operation is equivalent to nextPrimitiveNormalPoly(f). nextPrimitiveNormalPoly : SUP -> Union(SUP, "failed") ++ nextPrimitiveNormalPoly(f) yields the next primitive normal polynomial - ++ over a finite field {\em GF} of the same degree as f in the following + ++ over a finite field GF of the same degree as f in the following ++ order, or "failed" if there are no greater ones. ++ Error: if f has degree 0. - ++ Note: the input polynomial f is made monic. - ++ Also, \spad{f < g} if the {\em lookup} of the + ++ Note that the input polynomial f is made monic. + ++ Also, \spad{f < g} if the lookup of the ++ constant term of f is less than ++ this number for g or, in case these numbers are equal, if the - ++ {\em lookup} of the coefficient of the term of degree {\em n-1} + ++ lookup of the coefficient of the term of degree n-1 ++ of f is less than this number for g. ++ If these numbers are equals, \spad{f < g} ++ if the number of monomials of f is less than @@ -25662,22 +25741,22 @@ FiniteFieldPolynomialPackage GF : Exports == Implementation where ++ less than those for g. ++ If these lists are also equal, the lists of coefficients are ++ coefficients according to the lexicographic ordering induced by - ++ the ordering of the elements of {\em GF} given by {\em lookup}. + ++ the ordering of the elements of GF given by lookup. ++ This operation is equivalent to nextNormalPrimitivePoly(f). -- random : () -> SUP -- ++ random()$FFPOLY(GF) generates a random monic polynomial --- ++ of random degree over the field {\em GF} +-- ++ of random degree over the field GF random : PI -> SUP ++ random(n)$FFPOLY(GF) generates a random monic polynomial - ++ of degree n over the finite field {\em GF}. + ++ of degree n over the finite field GF. random : (PI, PI) -> SUP ++ random(m,n)$FFPOLY(GF) generates a random monic polynomial - ++ of degree d over the finite field {\em GF}, d between m and n. + ++ of degree d over the finite field GF, d between m and n. leastAffineMultiple: SUP -> SUP ++ leastAffineMultiple(f) computes the least affine polynomial which - ++ is divisible by the polynomial f over the finite field {\em GF}, + ++ is divisible by the polynomial f over the finite field GF, ++ i.e. a polynomial whose exponents are 0 or a power of q, the - ++ size of {\em GF}. + ++ size of GF. reducedQPowers: SUP -> PrimitiveArray SUP ++ reducedQPowers(f) ++ generates \spad{[x,x**q,x**(q**2),...,x**(q**(n-1))]} @@ -26511,20 +26590,21 @@ FiniteFieldPolynomialPackage GF : Exports == Implementation where ++ Its Applications, Vol. 20, Cambridge Univ. Press, 1983, ISBN 0 521 30240 4 ++ AXIOM Technical Report Series, to appear. ++ Description: -++ FiniteFieldPolynomialPackage2(F,GF) exports some functions concerning -++ finite fields, which depend on a finite field {\em GF} and an -++ algebraic extension F of {\em GF}, e.g. a zero of a polynomial -++ over {\em GF} in F. +++ FiniteFieldPolynomialPackage2(F,GF) exports some functions concerning +++ finite fields, which depend on a finite field GF and an +++ algebraic extension F of GF, e.g. a zero of a polynomial +++ over GF in F. + FiniteFieldPolynomialPackage2(F,GF):Exports == Implementation where F:FieldOfPrimeCharacteristic with coerce: GF -> F - ++ coerce(x) \undocumented{} + ++ coerce(x) \undocumented{} lookup: F -> PositiveInteger - ++ lookup(x) \undocumented{} + ++ lookup(x) \undocumented{} basis: PositiveInteger -> Vector F - ++ basis(n) \undocumented{} + ++ basis(n) \undocumented{} Frobenius: F -> F - ++ Frobenius(x) \undocumented{} + ++ Frobenius(x) \undocumented{} -- F should be a algebraic extension of the finite field GF, either an -- algebraic closure of GF or a simple algebraic extension field of GF GF:FiniteFieldCategory @@ -26547,8 +26627,8 @@ FiniteFieldPolynomialPackage2(F,GF):Exports == Implementation where ++ rootOfIrreduciblePoly(f) computes one root of the monic, ++ irreducible polynomial f, ++ which degree must divide the extension degree - ++ of {\em F} over {\em GF}, - ++ i.e. f splits into linear factors over {\em F}. + ++ of F over GF, + ++ i.e. f splits into linear factors over F. Implementation ==> add @@ -26696,8 +26776,6 @@ FiniteFieldSolveLinearPolynomialEquation(F:FiniteFieldCategory, <>= )abbrev package FLAGG2 FiniteLinearAggregateFunctions2 ---% FiniteLinearAggregateFunctions2 - ++ Author: ??? ++ Date Created: ??? ++ Date Last Updated: ??? @@ -26725,7 +26803,7 @@ FiniteLinearAggregateFunctions2(S, A, R, B): ++ aggregate \spad{a} and an accumulant initialized to r. ++ For example, ++ \spad{reduce(_+$Integer,[1,2,3],0)} - ++ does \spad{3+(2+(1+0))}. Note: third argument r + ++ does \spad{3+(2+(1+0))}. Note that third argument r ++ may be regarded as the ++ identity element for the function f. scan : ((S, R) -> R, A, R) -> B @@ -26829,13 +26907,12 @@ FiniteLinearAggregateFunctions2(S, A, R, B): <>= )abbrev package FLASORT FiniteLinearAggregateSort -++ FiniteLinearAggregateSort -++ Sort package (in-place) for shallowlyMutable Finite Linear Aggregates ++ Author: Michael Monagan Sep/88 ++ RelatedOperations: sort ++ Description: -++ This package exports 3 sorting algorithms which work over -++ FiniteLinearAggregates. +++ This package exports 3 sorting algorithms which work over +++ FiniteLinearAggregates. +++ Sort package (in-place) for shallowlyMutable Finite Linear Aggregates -- the following package is only instantiated over % -- thus shouldn't be cached. We prevent it -- from being cached by declaring it to be mutableDomains @@ -26947,9 +27024,6 @@ FiniteLinearAggregateSort(S, V): Exports == Implementation where <>= )abbrev package FSAGG2 FiniteSetAggregateFunctions2 - ---% FiniteSetAggregateFunctions2 - ++ Author: Robert S. Sutor ++ Date Created: 15 May 1990 ++ Date Last Updated: 14 Oct 1993 @@ -26977,7 +27051,7 @@ FiniteSetAggregateFunctions2(S, A, R, B): Exports == Implementation where ++ For example, ++ \spad{reduce(_+$Integer,[1,2,3],0)} ++ does a \spad{3+(2+(1+0))}. - ++ Note: third argument r may be regarded + ++ Note that third argument r may be regarded ++ as an identity element for the function. scan : ((S, R) -> R, A, R) -> B ++ scan(f,a,r) successively applies \spad{reduce(f,x,r)} @@ -27025,11 +27099,12 @@ FiniteSetAggregateFunctions2(S, A, R, B): Exports == Implementation where ++ Keywords: ++ References: ++ Description: -++ This is a package for the approximation of complex solutions for +++ This is a package for the approximation of complex solutions for ++ systems of equations of rational functions with complex rational ++ coefficients. The results are expressed as either complex rational ++ numbers or complex floats depending on the type of the precision ++ parameter which can be either a rational number or a floating point number. + FloatingComplexPackage(Par): Cat == Cap where Par : Join(Field, OrderedRing) K ==> GI @@ -27161,11 +27236,12 @@ FloatingComplexPackage(Par): Cat == Cap where ++ Keywords: ++ References: ++ Description: -++ This is a package for the approximation of real solutions for +++ This is a package for the approximation of real solutions for ++ systems of polynomial equations over the rational numbers. ++ The results are expressed as either rational numbers or floats ++ depending on the type of the precision parameter which can be ++ either a rational number or a floating point number. + FloatingRealPackage(Par): Cat == Cap where I ==> Integer NNI ==> NonNegativeInteger @@ -27296,17 +27372,17 @@ FloatingRealPackage(Par): Cat == Cap where ++ Keywords: ++ References: ++ Description: -++ \spadtype{FortranCodePackage1} provides some utilities for -++ producing useful objects in FortranCode domain. -++ The Package may be used with the FortranCode domain and its -++ \spad{printCode} or possibly via an outputAsFortran. -++ (The package provides items of use in connection with ASPs -++ in the AXIOM-NAG link and, where appropriate, naming accords -++ with that in IRENA.) -++ The easy-to-use functions use Fortran loop variables I1, I2, -++ and it is users' responsibility to check that this is sensible. -++ The advanced functions use SegmentBinding to allow users control -++ over Fortran loop variable names. +++ \spadtype{FortranCodePackage1} provides some utilities for +++ producing useful objects in FortranCode domain. +++ The Package may be used with the FortranCode domain and its +++ \spad{printCode} or possibly via an outputAsFortran. +++ (The package provides items of use in connection with ASPs +++ in the AXIOM-NAG link and, where appropriate, naming accords +++ with that in IRENA.) +++ The easy-to-use functions use Fortran loop variables I1, I2, +++ and it is users' responsibility to check that this is sensible. +++ The advanced functions use SegmentBinding to allow users control +++ over Fortran loop variable names. -- Later might add functions to build -- diagonalMatrix from List, i.e. the FC version of the corresponding -- AXIOM function from MatrixCategory; @@ -27461,7 +27537,9 @@ FortranCodePackage1: Exports == Implementation where ++ Keywords: ++ Examples: ++ References: -++ Description: Code to manipulate Fortran Output Stack +++ Description: +++ Code to manipulate Fortran Output Stack + FortranOutputStackPackage() : specification == implementation where specification == with @@ -27560,7 +27638,9 @@ FortranOutputStackPackage() : specification == implementation where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: provides an interface to the boot code for calling Fortran +++ Description: +++ provides an interface to the boot code for calling Fortran + FortranPackage(): Exports == Implementation where FST ==> FortranScalarType SEX ==> SExpression @@ -27571,15 +27651,15 @@ FortranPackage(): Exports == Implementation where Exports ==> with linkToFortran: (S, L U, L L U, L S) -> SEX - ++ linkToFortran(s,l,ll,lv) \undocumented{} + ++ linkToFortran(s,l,ll,lv) \undocumented{} linkToFortran: (S, L U, L L U, L S, S) -> SEX - ++ linkToFortran(s,l,ll,lv,t) \undocumented{} + ++ linkToFortran(s,l,ll,lv,t) \undocumented{} linkToFortran: (S,L S,TheSymbolTable,L S) -> SEX - ++ linkToFortran(s,l,t,lv) \undocumented{} + ++ linkToFortran(s,l,t,lv) \undocumented{} outputAsFortran: FileName -> Void - ++ outputAsFortran(fn) \undocumented{} + ++ outputAsFortran(fn) \undocumented{} setLegalFortranSourceExtensions: List String -> List String - ++ setLegalFortranSourceExtensions(l) \undocumented{} + ++ setLegalFortranSourceExtensions(l) \undocumented{} Implementation ==> add @@ -27655,11 +27735,13 @@ FortranPackage(): Exports == Implementation where <>= )abbrev package FRIDEAL2 FractionalIdealFunctions2 -++ Lifting of morphisms to fractional ideals. ++ Author: Manuel Bronstein ++ Date Created: 1 Feb 1989 ++ Date Last Updated: 27 Feb 1990 ++ Keywords: ideal, algebra, module. +++ Description: +++ Lifting of morphisms to fractional ideals. + FractionalIdealFunctions2(R1, F1, U1, A1, R2, F2, U2, A2): Exports == Implementation where R1, R2: EuclideanDomain @@ -27673,7 +27755,7 @@ FractionalIdealFunctions2(R1, F1, U1, A1, R2, F2, U2, A2): Exports ==> with map: (R1 -> R2, FractionalIdeal(R1, F1, U1, A1)) -> FractionalIdeal(R2, F2, U2, A2) - ++ map(f,i) \undocumented{} + ++ map(f,i) \undocumented{} Implementation ==> add fmap: (F1 -> F2, A1) -> A2 @@ -27724,6 +27806,7 @@ FractionalIdealFunctions2(R1, F1, U1, A1, R2, F2, U2, A2): ++ Applications 22. ++ The packages defined in this file provide fast fraction free rational ++ interpolation algorithms. (see FAMR2, FFFG, FFFGF, NEWTON) + FractionFreeFastGaussian(D, V): Exports == Implementation where D: Join(IntegralDomain, GcdDomain) V: AbelianMonoidRing(D, NonNegativeInteger) -- for example, SUP D @@ -28216,6 +28299,7 @@ $c_{\sigma,\sigma}$. ++ \spadtype{FractionFreeFastGaussian} to fractions. ++ The packages defined in this file provide fast fraction free rational ++ interpolation algorithms. (see FAMR2, FFFG, FFFGF, NEWTON) + FractionFreeFastGaussianFractions(D, V, VF): Exports == Implementation where D: Join(IntegralDomain, GcdDomain) V: FiniteAbelianMonoidRing(D, NonNegativeInteger) @@ -28332,9 +28416,11 @@ FractionFreeFastGaussianFractions(D, V, VF): Exports == Implementation where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: This package extends a map between integral domains to +++ Description: +++ This package extends a map between integral domains to ++ a map between Fractions over those domains by applying the map to the ++ numerators and denominators. + FractionFunctions2(A, B): Exports == Impl where A, B: IntegralDomain @@ -28376,10 +28462,10 @@ FractionFunctions2(A, B): Exports == Impl where ++ Keywords: non-associative algebra ++ References: ++ Description: -++ FramedNonAssociativeAlgebraFunctions2 implements functions between -++ two framed non associative algebra domains defined over different rings. -++ The function map is used to coerce between algebras over different -++ domains having the same structural constants. +++ FramedNonAssociativeAlgebraFunctions2 implements functions between +++ two framed non associative algebra domains defined over different rings. +++ The function map is used to coerce between algebras over different +++ domains having the same structural constants. FramedNonAssociativeAlgebraFunctions2(AR,R,AS,S) : Exports == Implementation where @@ -28452,12 +28538,13 @@ Gregory Vanuxem supplied the fix below. <>= )abbrev package FSPECF FunctionalSpecialFunction -++ Provides the special functions ++ Author: Manuel Bronstein ++ Date Created: 18 Apr 1989 ++ Date Last Updated: 4 October 1993 -++ Description: Provides some special functions over an integral domain. ++ Keywords: special, function. +++ Description: +++ Provides some special functions over an integral domain. + FunctionalSpecialFunction(R, F): Exports == Implementation where R: Join(OrderedSet, IntegralDomain) F: FunctionSpace R @@ -28852,11 +28939,12 @@ component of the gradient failed, it resulted in an infinite loop for <>= )abbrev package FFCAT2 FunctionFieldCategoryFunctions2 -++ Lifts a map from rings to function fields over them ++ Author: Manuel Bronstein ++ Date Created: May 1988 ++ Date Last Updated: 26 Jul 1988 -++ Description: Lifts a map from rings to function fields over them. +++ Description: +++ Lifts a map from rings to function fields over them. + FunctionFieldCategoryFunctions2(R1, UP1, UPUP1, F1, R2, UP2, UPUP2, F2): Exports == Implementation where R1 : UniqueFactorizationDomain @@ -28896,7 +28984,6 @@ FunctionFieldCategoryFunctions2(R1, UP1, UPUP1, F1, R2, UP2, UPUP2, F2): <>= )abbrev package FFINTBAS FunctionFieldIntegralBasis -++ Integral bases for function fields of dimension one ++ Author: Victor Miller ++ Date Created: 9 April 1990 ++ Date Last Updated: 20 September 1994 @@ -28904,17 +28991,17 @@ FunctionFieldCategoryFunctions2(R1, UP1, UPUP1, F1, R2, UP2, UPUP2, F2): ++ Examples: ++ References: ++ Description: +++ Integral bases for function fields of dimension one ++ In this package R is a Euclidean domain and F is a framed algebra ++ over R. The package provides functions to compute the integral ++ closure of R in the quotient field of F. It is assumed that ++ \spad{char(R/P) = char(R)} for any prime P of R. A typical instance of ++ this is when \spad{R = K[x]} and F is a function field over R. - FunctionFieldIntegralBasis(R,UP,F): Exports == Implementation where R : EuclideanDomain with - squareFree: $ -> Factored $ - ++ squareFree(x) returns a square-free factorisation of x + squareFree: $ -> Factored $ + ++ squareFree(x) returns a square-free factorisation of x UP : UnivariatePolynomialCategory R F : FramedAlgebra(R,UP) @@ -29037,12 +29124,13 @@ FunctionFieldIntegralBasis(R,UP,F): Exports == Implementation where <>= )abbrev package PMASSFS FunctionSpaceAssertions -++ Assertions for pattern-matching ++ Author: Manuel Bronstein -++ Description: Attaching assertions to symbols for pattern matching; ++ Date Created: 21 Mar 1989 ++ Date Last Updated: 23 May 1990 ++ Keywords: pattern, matching. +++ Description: +++ Attaching assertions to symbols for pattern matching; + FunctionSpaceAssertions(R, F): Exports == Implementation where R: OrderedSet F: FunctionSpace R @@ -29123,12 +29211,13 @@ FunctionSpaceAssertions(R, F): Exports == Implementation where <>= )abbrev package PMPREDFS FunctionSpaceAttachPredicates -++ Predicates for pattern-matching. ++ Author: Manuel Bronstein -++ Description: Attaching predicates to symbols for pattern matching. ++ Date Created: 21 Mar 1989 ++ Date Last Updated: 23 May 1990 ++ Keywords: pattern, matching. +++ Description: +++ Attaching predicates to symbols for pattern matching. + FunctionSpaceAttachPredicates(R, F, D): Exports == Implementation where R: OrderedSet F: FunctionSpace R @@ -29190,14 +29279,15 @@ FunctionSpaceAttachPredicates(R, F, D): Exports == Implementation where <>= )abbrev package FSCINT FunctionSpaceComplexIntegration -++ Top-level complex function integration ++ Author: Manuel Bronstein ++ Date Created: 4 February 1988 ++ Date Last Updated: 11 June 1993 -++ Description: -++ \spadtype{FunctionSpaceComplexIntegration} provides functions for the -++ indefinite integration of complex-valued functions. ++ Keywords: function, integration. +++ Description: +++ Top-level complex function integration +++ \spadtype{FunctionSpaceComplexIntegration} provides functions for the +++ indefinite integration of complex-valued functions. + FunctionSpaceComplexIntegration(R, F): Exports == Implementation where R : Join(EuclideanDomain, OrderedSet, CharacteristicZero, RetractableTo Integer, LinearlyExplicitRingOver Integer) @@ -29278,13 +29368,14 @@ FunctionSpaceComplexIntegration(R, F): Exports == Implementation where <>= )abbrev package FS2 FunctionSpaceFunctions2 -++ Lifting of maps to function spaces ++ Author: Manuel Bronstein ++ Date Created: 22 March 1988 ++ Date Last Updated: 3 May 1994 ++ Description: -++ This package allows a mapping R -> S to be lifted to a mapping -++ from a function space over R to a function space over S; +++ Lifting of maps to function spaces +++ This package allows a mapping R -> S to be lifted to a mapping +++ from a function space over R to a function space over S; + FunctionSpaceFunctions2(R, A, S, B): Exports == Implementation where R, S: Join(Ring, OrderedSet) A : FunctionSpace R @@ -29330,15 +29421,15 @@ FunctionSpaceFunctions2(R, A, S, B): Exports == Implementation where <>= )abbrev package FSINT FunctionSpaceIntegration -++ Top-level real function integration ++ Author: Manuel Bronstein ++ Date Created: 4 February 1988 ++ Date Last Updated: 11 June 1993 ++ Keywords: function, integration. ++ Description: -++ \spadtype{FunctionSpaceIntegration} provides functions for the -++ indefinite integration of real-valued functions. -++ Examples: )r INTEF INPUT +++ Top-level real function integration +++ \spadtype{FunctionSpaceIntegration} provides functions for the +++ indefinite integration of real-valued functions. + FunctionSpaceIntegration(R, F): Exports == Implementation where R : Join(EuclideanDomain, OrderedSet, CharacteristicZero, RetractableTo Integer, LinearlyExplicitRingOver Integer) @@ -29476,14 +29567,14 @@ FunctionSpaceIntegration(R, F): Exports == Implementation where <>= )abbrev package FSPRMELT FunctionSpacePrimitiveElement -++ Computation of primitive elements. ++ Author: Manuel Bronstein ++ Date Created: 6 Jun 1990 ++ Date Last Updated: 25 April 1991 -++ Description: -++ FunctionsSpacePrimitiveElement provides functions to compute -++ primitive elements in functions spaces; ++ Keywords: algebraic, extension, primitive. +++ Description: +++ FunctionsSpacePrimitiveElement provides functions to compute +++ primitive elements in functions spaces; + FunctionSpacePrimitiveElement(R, F): Exports == Implementation where R: Join(IntegralDomain, OrderedSet, CharacteristicZero) F: FunctionSpace R @@ -29601,15 +29692,16 @@ FunctionSpacePrimitiveElement(R, F): Exports == Implementation where <>= )abbrev package FSRED FunctionSpaceReduce -++ Reduction from a function space to the rational numbers ++ Author: Manuel Bronstein ++ Date Created: 1988 ++ Date Last Updated: 11 Jul 1990 +++ Keywords: function, space, redcution. ++ Description: +++ Reduction from a function space to the rational numbers ++ This package provides function which replaces transcendental kernels ++ in a function space by random integers. The correspondence between ++ the kernels and the integers is fixed between calls to new(). -++ Keywords: function, space, redcution. + FunctionSpaceReduce(R, F): Exports == Implementation where R: Join(OrderedSet, IntegralDomain, RetractableTo Integer) F: FunctionSpace R @@ -29622,11 +29714,11 @@ FunctionSpaceReduce(R, F): Exports == Implementation where Exports ==> with bringDown: F -> Q - ++ bringDown(f) \undocumented + ++ bringDown(f) \undocumented bringDown: (F, K) -> UP - ++ bringDown(f,k) \undocumented + ++ bringDown(f,k) \undocumented newReduc : () -> Void - ++ newReduc() \undocumented + ++ newReduc() \undocumented Implementation ==> add import SparseUnivariatePolynomialFunctions2(F, Q) @@ -29674,11 +29766,12 @@ FunctionSpaceReduce(R, F): Exports == Implementation where <>= )abbrev package SUMFS FunctionSpaceSum -++ Top-level sum function ++ Author: Manuel Bronstein ++ Date Created: ??? ++ Date Last Updated: 19 April 1991 -++ Description: computes sums of top-level expressions; +++ Description: +++ Computes sums of top-level expressions + FunctionSpaceSum(R, F): Exports == Implementation where R: Join(IntegralDomain, OrderedSet, RetractableTo Integer, LinearlyExplicitRingOver Integer) @@ -29760,8 +29853,9 @@ FunctionSpaceSum(R, F): Exports == Implementation where ++ Examples: ++ References: ++ Description: -++ This package converts expressions in some function space to exponential -++ expansions. +++ This package converts expressions in some function space to exponential +++ expansions. + FunctionSpaceToExponentialExpansion(R,FE,x,cen):_ Exports == Implementation where R : Join(GcdDomain,OrderedSet,RetractableTo Integer,_ @@ -30321,12 +30415,13 @@ FunctionSpaceToExponentialExpansion(R,FE,x,cen):_ ++ Examples: ++ References: ++ Description: -++ This package converts expressions in some function space to power -++ series in a variable x with coefficients in that function space. -++ The function \spadfun{exprToUPS} converts expressions to power series -++ whose coefficients do not contain the variable x. The function -++ \spadfun{exprToGenUPS} converts functional expressions to power series -++ whose coefficients may involve functions of \spad{log(x)}. +++ This package converts expressions in some function space to power +++ series in a variable x with coefficients in that function space. +++ The function \spadfun{exprToUPS} converts expressions to power series +++ whose coefficients do not contain the variable x. The function +++ \spadfun{exprToGenUPS} converts functional expressions to power series +++ whose coefficients may involve functions of \spad{log(x)}. + FunctionSpaceToUnivariatePowerSeries(R,FE,Expon,UPS,TRAN,x):_ Exports == Implementation where R : Join(GcdDomain,OrderedSet,RetractableTo Integer,_ @@ -31092,11 +31187,13 @@ FunctionSpaceToUnivariatePowerSeries(R,FE,Expon,UPS,TRAN,x):_ <>= )abbrev package FSUPFACT FunctionSpaceUnivariatePolynomialFactor -++ Used internally by IR2F ++ Author: Manuel Bronstein ++ Date Created: 12 May 1988 ++ Date Last Updated: 22 September 1993 ++ Keywords: function, space, polynomial, factoring +++ Description: +++ This package is used internally by IR2F + FunctionSpaceUnivariatePolynomialFactor(R, F, UP): Exports == Implementation where R : Join(IntegralDomain, OrderedSet, RetractableTo Integer) @@ -31467,14 +31564,15 @@ GaloisGroupFactorizationUtilities(R,UP,F): Exports == Implementation where ++ Mathematics of Computation, vol. 35, num. 35, Oct. 1980, 1379-1381 ++ [3] David R. Musser, On the Efficiency of a Polynomial Irreducibility Test, ++ Journal of the ACM, Vol. 25, No. 2, April 1978, pp. 271-282 -++ Description: \spadtype{GaloisGroupFactorizer} provides functions -++ to factor resolvents. +++ Description: +++ \spadtype{GaloisGroupFactorizer} provides functions to factor resolvents. -- improvements to do : -- + reformulate the lifting problem in completeFactor -- See [1] (hard) -- + implement algorithm RC -- See [1] (easy) -- + use Dedekind's criterion to prove sometimes irreducibility (easy) -- or even to improve early detection of true factors (hard) -- + replace Sets by Bits + GaloisGroupFactorizer(UP): Exports == Implementation where Z ==> Integer UP: UnivariatePolynomialCategory Z @@ -31497,9 +31595,7 @@ GaloisGroupFactorizer(UP): Exports == Implementation where degreePartition: DDList -> Multiset N ++ degreePartition(ddfactorization) returns the degree partition of ++ the polynomial f modulo p where ddfactorization is the distinct - ++ degree factorization of f computed by - ++ \spadfunFrom{ddFact}{ModularDistinctDegreeFactorizer} - ++ for some prime p. + ++ degree factorization of f computed by ddFact for some prime p. musserTrials: () -> P ++ musserTrials() returns the number of primes that are tried in ++ \spadfun{modularFactor}. @@ -31520,13 +31616,11 @@ GaloisGroupFactorizer(UP): Exports == Implementation where numberOfFactors: DDList -> N ++ numberOfFactors(ddfactorization) returns the number of factors of ++ the polynomial f modulo p where ddfactorization is the distinct - ++ degree factorization of f computed by - ++ \spadfunFrom{ddFact}{ModularDistinctDegreeFactorizer} - ++ for some prime p. + ++ degree factorization of f computed by ddFact for some prime p. modularFactor: UP -> MFact ++ modularFactor(f) chooses a "good" prime and returns the factorization ++ of f modulo this prime in a form that may be used by - ++ \spadfunFrom{completeHensel}{GeneralHenselPackage}. If prime is zero + ++ completeHensel. If prime is zero ++ it means that f has been proved to be irreducible over the integers ++ or that f is a unit (i.e. 1 or -1). ++ f shall be primitive (i.e. content(p)=1) and square free (i.e. @@ -32290,10 +32384,10 @@ GaloisGroupFactorizer(UP): Exports == Implementation where ++ Keywords: ++ Examples: ++ References: -++ Description: \spadtype{GaloisGroupPolynomialUtilities} provides useful +++ Description: +++ \spadtype{GaloisGroupPolynomialUtilities} provides useful ++ functions for univariate polynomials which should be added to ++ \spadtype{UnivariatePolynomialCategory} or to \spadtype{Factored} -++ (July 1994). GaloisGroupPolynomialUtilities(R,UP): Exports == Implementation where R : Ring @@ -32548,8 +32642,9 @@ GaloisGroupUtilities(R): Exports == Implementation where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: Package for the factorization of complex or gaussian -++ integers. +++ Description: +++ Package for the factorization of complex or gaussian integers. + GaussianFactorizationPackage() : C == T where NNI == NonNegativeInteger @@ -32736,8 +32831,10 @@ GaussianFactorizationPackage() : C == T <>= )abbrev package GHENSEL GeneralHenselPackage ++ Author : P.Gianni +++ Description: ++ General Hensel Lifting ++ Used for Factorization of bivariate polynomials over a finite field. + GeneralHenselPackage(RP,TP):C == T where RP : EuclideanDomain TP : UnivariatePolynomialCategory RP @@ -32900,13 +32997,14 @@ GeneralHenselPackage(RP,TP):C == T where ++ Date Created: 1983 ++ Date Last Updated: Sept. 1990 ++ Basic Functions: -++ Related Constructors: MultFiniteFactorize, AlgebraicMultFact, MultivariateFactorize +++ Related Constructors: MultFiniteFactorize, AlgebraicMultFact, +++ MultivariateFactorize ++ Also See: ++ AMS Classifications: ++ Keywords: ++ References: ++ Description: -++ This is the top level package for doing multivariate factorization +++ This is the top level package for doing multivariate factorization ++ over basic domains like \spadtype{Integer} or \spadtype{Fraction Integer}. GeneralizedMultivariateFactorize(OV,E,S,R,P) : C == T @@ -32962,8 +33060,8 @@ GeneralizedMultivariateFactorize(OV,E,S,R,P) : C == T <>= )abbrev package GENPGCD GeneralPolynomialGcdPackage ++ Description: -++ This package provides operations for GCD computations -++ on polynomials +++ This package provides operations for GCD computations on polynomials + GeneralPolynomialGcdPackage(E,OV,R,P):C == T where R : PolynomialFactorizationExplicit P : PolynomialCategory(R,E,OV) @@ -32975,9 +33073,9 @@ GeneralPolynomialGcdPackage(E,OV,R,P):C == T where C == with gcdPolynomial : (SUPP,SUPP) -> SUPP - ++ gcdPolynomial(p,q) returns the GCD of p and q + ++ gcdPolynomial(p,q) returns the GCD of p and q randomR : () ->R - ++ randomR() should be local but conditional + ++ randomR() should be local but conditional --JHD gcd : (P,P) -> P --JHD gcd : List P -> P --JHD gcdprim : (P,P) -> P @@ -33120,49 +33218,49 @@ GeneralPolynomialGcdPackage(E,OV,R,P):C == T where lr:=[randomR() for vv in lv] count:NonNegativeInteger:=0 while count<10 repeat - while zero? eval(gcdLC,lv,lr) and count<10 repeat - lr:=[randomR() for vv in lv] - count:=count+1 - count = 10 => error "too many evaluations in GCD code" - up1:SUPR:=map(y+->ground eval(y,lv,lr),p1) - up2:SUPR:=map(z+->ground eval(z,lv,lr),p2) - u:=gcdPolynomial(up1,up2) - degree u = 0 => return 1 + while zero? eval(gcdLC,lv,lr) and count<10 repeat + lr:=[randomR() for vv in lv] + count:=count+1 + count = 10 => error "too many evaluations in GCD code" + up1:SUPR:=map(y+->ground eval(y,lv,lr),p1) + up2:SUPR:=map(z+->ground eval(z,lv,lr),p2) + u:=gcdPolynomial(up1,up2) + degree u = 0 => return 1 -- let's pick a second one, just to check lrr:=[randomR() for vv in lv] - while zero? eval(gcdLC,lv,lrr) and count<10 repeat - lrr:=[randomR() for vv in lv] - count:=count+1 - count = 10 => error "too many evaluations in GCD code" - vp1:SUPR:=map(x1+->ground eval(x1,lv,lrr),p1) - vp2:SUPR:=map(y1+->ground eval(y1,lv,lrr),p2) - v:=gcdPolynomial(vp1,vp2) - degree v = 0 => return 1 + while zero? eval(gcdLC,lv,lrr) and count<10 repeat + lrr:=[randomR() for vv in lv] + count:=count+1 + count = 10 => error "too many evaluations in GCD code" + vp1:SUPR:=map(x1+->ground eval(x1,lv,lrr),p1) + vp2:SUPR:=map(y1+->ground eval(y1,lv,lrr),p2) + v:=gcdPolynomial(vp1,vp2) + degree v = 0 => return 1 if degree v < degree u then u:=v up1:=vp1 up2:=vp2 lr:=lrr - up1:=(up1 exquo u)::SUPR - degree gcd(u,up1) = 0 => + up1:=(up1 exquo u)::SUPR + degree gcd(u,up1) = 0 => ans:=lift(u,p1,up1,lv,lr) ans case SUPP => return ans "next" - up2:=(up2 exquo u)::SUPR - degree gcd(u,up2) = 0 => + up2:=(up2 exquo u)::SUPR + degree gcd(u,up2) = 0 => ans:=lift(u,p2,up2,lv,lr) ans case SUPP => return ans "next" - -- so neither cofactor is relatively prime - count:=0 - while count < 10 repeat - r:=randomR() - uu:=up1+r*up2 - degree gcd(u,uu)=0 => + -- so neither cofactor is relatively prime + count:=0 + while count < 10 repeat + r:=randomR() + uu:=up1+r*up2 + degree gcd(u,uu)=0 => ans:= lift(u,p1+r::P *p2,uu,lv,lr) ans case SUPP => return ans "next" - error "too many evaluations in GCD code" + error "too many evaluations in GCD code" count >= 10 => error "too many evaluations in GCD code" lift(gR:SUPR,p:SUPP,cfR:SUPR,lv:List OV,lr:List R) == -- lift the coprime factorisation gR*cfR = (univariate of p) @@ -33627,8 +33725,9 @@ GeneralPolynomialGcdPackage(E,OV,R,P):C == T where ++ Examples: ++ References: ++ Description: -++ \spadtype{GenerateUnivariatePowerSeries} provides functions that create -++ power series from explicit formulas for their \spad{n}th coefficient. +++ \spadtype{GenerateUnivariatePowerSeries} provides functions that create +++ power series from explicit formulas for their \spad{n}th coefficient. + GenerateUnivariatePowerSeries(R,FE): Exports == Implementation where R : Join(IntegralDomain,OrderedSet,RetractableTo Integer,_ LinearlyExplicitRingOver Integer) @@ -33835,7 +33934,8 @@ GenerateUnivariatePowerSeries(R,FE): Exports == Implementation where <>= )abbrev package GENEEZ GenExEuclid ++ Author : P.Gianni. -++ January 1990 +++ Date Created: January 1990 +++ Description: ++ The equation \spad{Af+Bg=h} and its generalization to n polynomials ++ is solved for solutions over the R, euclidean domain. ++ A table containing the solutions of \spad{Af+Bg=x**k} is used. @@ -33857,7 +33957,7 @@ GenExEuclid(R,BP) : C == T C == with reduction: (BP,R) -> BP ++ reduction(p,prime) reduces the polynomial p modulo prime of R. - ++ Note: this function is exported only because it's conditional. + ++ Note that this function is exported only because it's conditional. compBound: (BP,L BP) -> NNI ++ compBound(p,lp) ++ computes a bound for the coefficients of the solution @@ -33889,7 +33989,7 @@ GenExEuclid(R,BP) : C == T normlist:=[ +/[euclideanSize(u)**2 for u in coefficients f] for f in listpolys] nm:= +/[euclideanSize(u)**2 for u in coefficients m] - normprod := */[g**((n-df)::NNI) for g in normlist for df in ldeg] + normprod := */[g**((n-df)::NNI) for g in normlist for df in ldeg] 2*(approxSqrt(normprod * nm)$IntegerRoots(Integer))::NNI else if R has additiveValuation then -- a fairly crude Hadamard-style bound for the solution @@ -34044,11 +34144,12 @@ GenExEuclid(R,BP) : C == T <>= )abbrev package GENUFACT GenUFactorize -++ Description +++ Description: ++ This package provides operations for the factorization ++ of univariate polynomials with integer ++ coefficients. The factorization is done by "lifting" the ++ finite "berlekamp's" factorization + GenUFactorize(R) : public == private where R : EuclideanDomain PR ==> SparseUnivariatePolynomial R -- with factor @@ -34059,7 +34160,7 @@ GenUFactorize(R) : public == private where public == with factor : PR -> Factored PR - ++ factor(p) returns the factorisation of p + ++ factor(p) returns the factorisation of p private == add @@ -34131,17 +34232,18 @@ GenUFactorize(R) : public == private where <>= )abbrev package INTG0 GenusZeroIntegration -++ Rationalization of several types of genus 0 integrands; ++ Author: Manuel Bronstein ++ Date Created: 11 October 1988 ++ Date Last Updated: 24 June 1994 ++ Description: -++ This internal package rationalises integrands on curves of the form: -++ \spad{y\^2 = a x\^2 + b x + c} -++ \spad{y\^2 = (a x + b) / (c x + d)} -++ \spad{f(x, y) = 0} where f has degree 1 in x +++ Rationalization of several types of genus 0 integrands; +++ This internal package rationalises integrands on curves of the form:\br +++ \tab{5}\spad{y\^2 = a x\^2 + b x + c}\br +++ \tab{5}\spad{y\^2 = (a x + b) / (c x + d)}\br +++ \tab{5}\spad{f(x, y) = 0} where f has degree 1 in x\br ++ The rationalization is done for integration, limited integration, ++ extended integration and the risch differential equation; + GenusZeroIntegration(R, F, L): Exports == Implementation where R: Join(GcdDomain, RetractableTo Integer, OrderedSet, CharacteristicZero, LinearlyExplicitRingOver Integer) @@ -34220,11 +34322,11 @@ GenusZeroIntegration(R, F, L): Exports == Implementation where ++ solves \spad{du/dx + n * da/dx u(x) = u(x)} ++ for an unknown \spad{u(x)} not involving y. univariate: (F, K, K, UP) -> UPUP - ++ univariate(f,k,k,p) \undocumented + ++ univariate(f,k,k,p) \undocumented multivariate: (UPUP, K, F) -> F - ++ multivariate(u,k,f) \undocumented + ++ multivariate(u,k,f) \undocumented lift: (UP, K) -> UPUP - ++ lift(u,k) \undocumented + ++ lift(u,k) \undocumented if L has LinearOrdinaryDifferentialOperatorCategory F then palgLODE0 : (L, F, K, K, F, UP) -> ODE ++ palgLODE0(op, g, x, y, d, p) returns the solution of \spad{op f = g}. @@ -34407,11 +34509,12 @@ GenusZeroIntegration(R, F, L): Exports == Implementation where <>= )abbrev package GOSPER GosperSummationMethod -++ Gosper's summation algorithm ++ Author: SMW ++ Date Created: ??? ++ Date Last Updated: 19 August 1991 -++ Description: Gosper's summation algorithm. +++ Description: +++ Gosper's summation algorithm. + GosperSummationMethod(E, V, R, P, Q): Exports == Impl where E: OrderedAbelianMonoidSup V: OrderedSet @@ -34435,7 +34538,7 @@ GosperSummationMethod(E, V, R, P, Q): Exports == Impl where ++ where \spad{b(n) = a(n)/a(n-1)} is a rational function. ++ Returns "failed" if no such rational function \spad{rf(n)} ++ exists. - ++ Note: \spad{new} is a nullary function returning a new + ++ Note that \spad{new} is a nullary function returning a new ++ V every time. ++ The condition on \spad{a(n)} is that \spad{a(n)/a(n-1)} ++ is a rational function of \spad{n}. @@ -34651,7 +34754,8 @@ GosperSummationMethod(E, V, R, P, Q): Exports == Impl where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: TwoDimensionalPlotSettings sets global flags and constants +++ Description: +++ TwoDimensionalPlotSettings sets global flags and constants ++ for 2-dimensional plotting. GraphicsDefaults(): Exports == Implementation where @@ -34762,9 +34866,10 @@ GraphicsDefaults(): Exports == Implementation where ++ S.G.Williamson, Combinatorics for Computer Science, ++ Computer Science Press, 1985. ++ Description: -++ GrayCode provides a function for efficiently running -++ through all subsets of a finite set, only changing one element -++ by another one. +++ GrayCode provides a function for efficiently running +++ through all subsets of a finite set, only changing one element +++ by another one. + GrayCode: public == private where PI ==> PositiveInteger @@ -34774,28 +34879,28 @@ GrayCode: public == private where public ==> with nextSubsetGray: (V V I,PI) -> V V I - ++ nextSubsetGray(ww,n) returns a vector {\em vv} whose components - ++ have the following meanings:\begin{items} - ++ \item {\em vv.1}: a vector of length n whose entries are 0 or 1. This - ++ can be interpreted as a code for a subset of the set 1,...,n; - ++ {\em vv.1} differs from {\em ww.1} by exactly one entry; - ++ \item {\em vv.2.1} is the number of the entry of {\em vv.1} which - ++ will be changed next time; - ++ \item {\em vv.2.1 = n+1} means that {\em vv.1} is the last subset; - ++ trying to compute nextSubsetGray(vv) if {\em vv.2.1 = n+1} - ++ will produce an error! - ++ \end{items} - ++ The other components of {\em vv.2} are needed to compute + ++ nextSubsetGray(ww,n) returns a vector vv whose components + ++ have the following meanings:\br + ++ vv.1: a vector of length n whose entries are 0 or 1. This + ++ can be interpreted as a code for a subset of the set 1,...,n; + ++ vv.1 differs from ww.1 by exactly one entry;\br + ++ vv.2.1 is the number of the entry of vv.1 which + ++ will be changed next time;\br + ++ vv.2.1 = n+1 means that vv.1 is the last subset; + ++ trying to compute nextSubsetGray(vv) if vv.2.1 = n+1 + ++ will produce an error!\br + ++ + ++ The other components of vv.2 are needed to compute ++ nextSubsetGray efficiently. - ++ Note: this is an implementation of [Williamson, Topic II, 3.54, - ++ p. 112] for the special case {\em r1 = r2 = ... = rn = 2}; - ++ Note: nextSubsetGray produces a side-effect, i.e. - ++ {\em nextSubsetGray(vv)} and {\em vv := nextSubsetGray(vv)} + ++ Note that this is an implementation of [Williamson, Topic II, 3.54, + ++ p. 112] for the special case r1 = r2 = ... = rn = 2; + ++ Note that nextSubsetGray produces a side-effect, i.e. + ++ nextSubsetGray(vv) and vv := nextSubsetGray(vv) ++ will have the same effect. firstSubsetGray: PI -> V V I - ++ firstSubsetGray(n) creates the first vector {\em ww} to start a - ++ loop using {\em nextSubsetGray(ww,n)} + ++ firstSubsetGray(n) creates the first vector ww to start a + ++ loop using nextSubsetGray(ww,n) private ==> add @@ -35049,23 +35154,23 @@ o )show EuclideanGroebnerBasisPackage ++ Keywords: groebner basis, groebner factorization, ideal decomposition ++ References: ++ Description: -++ \spadtype{GroebnerFactorizationPackage} provides the function -++ groebnerFactor" which uses the factorization routines of \Language{} to -++ factor each polynomial under consideration while doing the groebner basis -++ algorithm. Then it writes the ideal as an intersection of ideals -++ determined by the irreducible factors. Note that the whole ring may -++ occur as well as other redundancies. We also use the fact, that from the -++ second factor on we can assume that the preceding factors are -++ not equal to 0 and we divide all polynomials under considerations -++ by the elements of this list of "nonZeroRestrictions". -++ The result is a list of groebner bases, whose union of solutions -++ of the corresponding systems of equations is the solution of -++ the system of equation corresponding to the input list. -++ The term ordering is determined by the polynomial type used. -++ Suggested types include -++ \spadtype{DistributedMultivariatePolynomial}, -++ \spadtype{HomogeneousDistributedMultivariatePolynomial}, -++ \spadtype{GeneralDistributedMultivariatePolynomial}. +++ \spadtype{GroebnerFactorizationPackage} provides the function +++ groebnerFactor" which uses the factorization routines of \Language{} to +++ factor each polynomial under consideration while doing the groebner basis +++ algorithm. Then it writes the ideal as an intersection of ideals +++ determined by the irreducible factors. Note that the whole ring may +++ occur as well as other redundancies. We also use the fact, that from the +++ second factor on we can assume that the preceding factors are +++ not equal to 0 and we divide all polynomials under considerations +++ by the elements of this list of "nonZeroRestrictions". +++ The result is a list of groebner bases, whose union of solutions +++ of the corresponding systems of equations is the solution of +++ the system of equation corresponding to the input list. +++ The term ordering is determined by the polynomial type used. +++ Suggested types include +++ \spadtype{DistributedMultivariatePolynomial}, +++ \spadtype{HomogeneousDistributedMultivariatePolynomial}, +++ \spadtype{GeneralDistributedMultivariatePolynomial}. GroebnerFactorizationPackage(Dom, Expon, VarSet, Dpol): T == C where @@ -35089,41 +35194,41 @@ GroebnerFactorizationPackage(Dom, Expon, VarSet, Dpol): T == C where factorGroebnerBasis : (L Dpol, Boolean) -> L L Dpol ++ factorGroebnerBasis(basis,info) checks whether the basis contains ++ reducible polynomials and uses these to split the basis. - ++ If argument {\em info} is true, information is printed about + ++ If argument info is true, information is printed about ++ partial results. groebnerFactorize : (L Dpol, L Dpol) -> L L Dpol ++ groebnerFactorize(listOfPolys, nonZeroRestrictions) returns ++ a list of groebner basis. The union of their solutions - ++ is the solution of the system of equations given by {\em listOfPolys} - ++ under the restriction that the polynomials of {\em nonZeroRestrictions} + ++ is the solution of the system of equations given by listOfPolys + ++ under the restriction that the polynomials of nonZeroRestrictions ++ don't vanish. ++ At each stage the polynomial p under consideration (either from ++ the given basis or obtained from a reduction of the next S-polynomial) ++ is factorized. For each irreducible factors of p, a - ++ new {\em createGroebnerBasis} is started + ++ new createGroebnerBasis is started ++ doing the usual updates with the factor ++ in place of p. groebnerFactorize : (L Dpol, L Dpol, Boolean) -> L L Dpol ++ groebnerFactorize(listOfPolys, nonZeroRestrictions, info) returns ++ a list of groebner basis. The union of their solutions - ++ is the solution of the system of equations given by {\em listOfPolys} - ++ under the restriction that the polynomials of {\em nonZeroRestrictions} + ++ is the solution of the system of equations given by listOfPolys + ++ under the restriction that the polynomials of nonZeroRestrictions ++ don't vanish. ++ At each stage the polynomial p under consideration (either from ++ the given basis or obtained from a reduction of the next S-polynomial) ++ is factorized. For each irreducible factors of p a - ++ new {\em createGroebnerBasis} is started + ++ new createGroebnerBasis is started ++ doing the usual updates with the factor in place of p. - ++ If argument {\em info} is true, information is printed about + ++ If argument info is true, information is printed about ++ partial results. groebnerFactorize : L Dpol -> L L Dpol ++ groebnerFactorize(listOfPolys) returns ++ a list of groebner bases. The union of their solutions - ++ is the solution of the system of equations given by {\em listOfPolys}. + ++ is the solution of the system of equations given by listOfPolys. ++ At each stage the polynomial p under consideration (either from ++ the given basis or obtained from a reduction of the next S-polynomial) ++ is factorized. For each irreducible factors of p, a - ++ new {\em createGroebnerBasis} is started + ++ new createGroebnerBasis is started ++ doing the usual updates with the factor ++ in place of p. ++ @@ -35136,14 +35241,14 @@ GroebnerFactorizationPackage(Dom, Expon, VarSet, Dpol): T == C where groebnerFactorize : (L Dpol, Boolean) -> L L Dpol ++ groebnerFactorize(listOfPolys, info) returns ++ a list of groebner bases. The union of their solutions - ++ is the solution of the system of equations given by {\em listOfPolys}. + ++ is the solution of the system of equations given by listOfPolys. ++ At each stage the polynomial p under consideration (either from ++ the given basis or obtained from a reduction of the next S-polynomial) ++ is factorized. For each irreducible factors of p, a - ++ new {\em createGroebnerBasis} is started + ++ new createGroebnerBasis is started ++ doing the usual updates with the factor ++ in place of p. - ++ If {\em info} is true, information is printed about partial results. + ++ If info is true, information is printed about partial results. C ==> add @@ -35153,34 +35258,34 @@ GroebnerFactorizationPackage(Dom, Expon, VarSet, Dpol): T == C where -- signatures of local functions newPairs : (L sugarPol, Dpol) -> L critPair - -- newPairs(lp, p) constructs list of critical pairs from the list of - -- {\em lp} of input polynomials and a given further one p. - -- It uses criteria M and T to reduce the list. + ++ newPairs(lp, p) constructs list of critical pairs from the list of + ++ lp of input polynomials and a given further one p. + ++ It uses criteria M and T to reduce the list. updateCritPairs : (L critPair, L critPair, Dpol) -> L critPair - -- updateCritPairs(lcP1,lcP2,p) applies criterion B to {\em lcP1} using - -- p. Then this list is merged with {\em lcP2}. + ++ updateCritPairs(lcP1,lcP2,p) applies criterion B to lcP1 using + ++ p. Then this list is merged with lcP2. updateBasis : (L sugarPol, Dpol, NNI) -> L sugarPol - -- updateBasis(li,p,deg) every polynomial in {\em li} is dropped if - -- its leading term is a multiple of the leading term of p. - -- The result is this list enlarged by p. + ++ updateBasis(li,p,deg) every polynomial in li is dropped if + ++ its leading term is a multiple of the leading term of p. + ++ The result is this list enlarged by p. createGroebnerBases : (L sugarPol, L Dpol, L Dpol, L Dpol, L critPair,_ L L Dpol, Boolean) -> L L Dpol - -- createGroebnerBases(basis, redPols, nonZeroRestrictions, inputPolys, - -- lcP,listOfBases): This function is used to be called from - -- groebnerFactorize. - -- basis: part of a Groebner basis, computed so far - -- redPols: Polynomials from the ideal to be used for reducing, - -- we don't throw away polynomials - -- nonZeroRestrictions: polynomials not zero in the common zeros - -- of the polynomials in the final (Groebner) basis - -- inputPolys: assumed to be in descending order - -- lcP: list of critical pairs built from polynomials of the - -- actual basis - -- listOfBases: Collects the (Groebner) bases constructed by this - -- recursive algorithm at different stages. - -- we print info messages if info is true + ++ createGroebnerBases(basis, redPols, nonZeroRestrictions, inputPolys, + ++ lcP,listOfBases): This function is used to be called from + ++ groebnerFactorize. + ++ basis: part of a Groebner basis, computed so far + ++ redPols: Polynomials from the ideal to be used for reducing, + ++ we don't throw away polynomials + ++ nonZeroRestrictions: polynomials not zero in the common zeros + ++ of the polynomials in the final (Groebner) basis + ++ inputPolys: assumed to be in descending order + ++ lcP: list of critical pairs built from polynomials of the + ++ actual basis + ++ listOfBases: Collects the (Groebner) bases constructed by this + ++ recursive algorithm at different stages. + ++ we print info messages if info is true createAllFactors: Dpol -> L Dpol - -- factor reduced critpair polynomial + ++ factor reduced critpair polynomial -- implementation of local functions @@ -35420,8 +35525,9 @@ GroebnerFactorizationPackage(Dom, Expon, VarSet, Dpol): T == C where ++ Date Created: ++ Date Last Updated: ++ Keywords: -++ Description +++ Description: ++ This package provides low level tools for Groebner basis computations + GroebnerInternalPackage(Dom, Expon, VarSet, Dpol): T == C where Dom: GcdDomain Expon: OrderedAbelianMonoidSup @@ -35441,54 +35547,54 @@ GroebnerInternalPackage(Dom, Expon, VarSet, Dpol): T == C where T== with credPol: (Dpol, List(Dpol)) -> Dpol - ++ credPol \undocumented + ++ credPol \undocumented redPol: (Dpol, List(Dpol)) -> Dpol - ++ redPol \undocumented + ++ redPol \undocumented gbasis: (List(Dpol), Integer, Integer) -> List(Dpol) - ++ gbasis \undocumented + ++ gbasis \undocumented critT: critPair -> Boolean - ++ critT \undocumented + ++ critT \undocumented critM: (Expon, Expon) -> Boolean - ++ critM \undocumented + ++ critM \undocumented critB: (Expon, Expon, Expon, Expon) -> Boolean - ++ critB \undocumented + ++ critB \undocumented critBonD: (Dpol, List(critPair)) -> List(critPair) - ++ critBonD \undocumented + ++ critBonD \undocumented critMTonD1: (List(critPair)) -> List(critPair) - ++ critMTonD1 \undocumented + ++ critMTonD1 \undocumented critMonD1: (Expon, List(critPair)) -> List(critPair) - ++ critMonD1 \undocumented + ++ critMonD1 \undocumented redPo: (Dpol, List(Dpol) ) -> Record(poly:Dpol, mult:Dom) - ++ redPo \undocumented + ++ redPo \undocumented hMonic: Dpol -> Dpol - ++ hMonic \undocumented + ++ hMonic \undocumented updatF: (Dpol, NNI, List(sugarPol) ) -> List(sugarPol) - ++ updatF \undocumented + ++ updatF \undocumented sPol: critPair -> Dpol - ++ sPol \undocumented + ++ sPol \undocumented updatD: (List(critPair), List(critPair)) -> List(critPair) - ++ updatD \undocumented + ++ updatD \undocumented minGbasis: List(Dpol) -> List(Dpol) - ++ minGbasis \undocumented + ++ minGbasis \undocumented lepol: Dpol -> Integer - ++ lepol \undocumented + ++ lepol \undocumented prinshINFO : Dpol -> Void - ++ prinshINFO \undocumented + ++ prinshINFO \undocumented prindINFO: (critPair, Dpol, Dpol,Integer,Integer,Integer) -> Integer - ++ prindINFO \undocumented + ++ prindINFO \undocumented fprindINFO: (critPair, Dpol, Dpol, Integer,Integer,Integer ,Integer) -> Integer - ++ fprindINFO \undocumented + ++ fprindINFO \undocumented prinpolINFO: List(Dpol) -> Void - ++ prinpolINFO \undocumented + ++ prinpolINFO \undocumented prinb: Integer-> Void - ++ prinb \undocumented + ++ prinb \undocumented critpOrder: (critPair, critPair) -> Boolean - ++ critpOrder \undocumented + ++ critpOrder \undocumented makeCrit: (sugarPol, Dpol, NonNegativeInteger) -> critPair - ++ makeCrit \undocumented + ++ makeCrit \undocumented virtualDegree : Dpol -> NonNegativeInteger - ++ virtualDegree \undocumented + ++ virtualDegree \undocumented C== add Ex ==> OutputForm @@ -37194,16 +37300,18 @@ o )show EuclideanGroebnerBasisPackage ++ AMS Classifications: ++ Keywords: groebner basis, polynomial ideal ++ References: -++ Description: \spadtype{GroebnerPackage} computes groebner -++ bases for polynomial ideals. The basic computation provides -++ a distinguished set of generators for polynomial ideals over fields. -++ This basis allows an easy test for membership: the operation \spadfun{normalForm} +++ Description: +++ \spadtype{GroebnerPackage} computes groebner +++ bases for polynomial ideals. The basic computation provides a distinguished +++ set of generators for polynomial ideals over fields. This basis allows an +++ easy test for membership: the operation \spadfun{normalForm} ++ returns zero on ideal members. When the provided coefficient domain, Dom, ++ is not a field, the result is equivalent to considering the extended -++ ideal with \spadtype{Fraction(Dom)} as coefficients, but considerably more efficient -++ since all calculations are performed in Dom. Additional argument "info" and "redcrit" -++ can be given to provide incremental information during -++ computation. Argument "info" produces a computational summary for each s-polynomial. +++ ideal with \spadtype{Fraction(Dom)} as coefficients, but considerably more +++ efficient since all calculations are performed in Dom. Additional +++ argument "info" and "redcrit" can be given to provide incremental +++ information during computation. Argument "info" produces a computational +++ summary for each s-polynomial. ++ Argument "redcrit" prints out the reduced critical pairs. The term ordering ++ is determined by the polynomial type used. Suggested types include ++ \spadtype{DistributedMultivariatePolynomial}, @@ -37356,9 +37464,11 @@ GroebnerPackage(Dom, Expon, VarSet, Dpol): T == C where <>= )abbrev package GROEBSOL GroebnerSolve ++ Author : P.Gianni, Summer '88, revised November '89 +++ Description: ++ Solve systems of polynomial equations using Groebner bases ++ Total order Groebner bases are computed and then converted to lex ones ++ This package is mostly intended for internal use. + GroebnerSolve(lv,F,R) : C == T where @@ -37581,9 +37691,11 @@ GFUN. <>= )abbrev package GUESS Guess ++ Author: Martin Rubey -++ Description: This package implements guessing of sequences. Packages for the +++ Description: +++ This package implements guessing of sequences. Packages for the ++ most common cases are provided as \spadtype{GuessInteger}, ++ \spadtype{GuessPolynomial}, etc. + Guess(F, S, EXPRR, R, retract, coerce): Exports == Implementation where F: Field -- zB.: FRAC POLY PF 5 -- in F we interpolate und check @@ -39938,6 +40050,7 @@ guess(list: List F, guessers: List GUESSER, ops: List Symbol) )abbrev package GUESSAN GuessAlgebraicNumber ++ Description: ++ This package exports guessing of sequences of rational functions + GuessAlgebraicNumber() == Guess(AlgebraicNumber, AlgebraicNumber, Expression Integer, AlgebraicNumber, @@ -39977,6 +40090,7 @@ GuessAlgebraicNumber() == Guess(AlgebraicNumber, AlgebraicNumber, )abbrev package GUESSF GuessFinite ++ Description: ++ This package exports guessing of sequences of numbers in a finite field + GuessFinite(F:Join(FiniteFieldCategory, ConvertibleTo Integer)) == Guess(F, F, Expression Integer, Integer, coerce$F, F2EXPRR$GuessFiniteFunctions(F)) @@ -40000,6 +40114,7 @@ GuessFinite(F:Join(FiniteFieldCategory, ConvertibleTo Integer)) == )abbrev package GUESSF1 GuessFiniteFunctions ++ Description: ++ This package exports guessing of sequences of numbers in a finite field + GuessFiniteFunctions(F:Join(FiniteFieldCategory, ConvertibleTo Integer)): Exports == Implementation where @@ -40048,6 +40163,7 @@ GuessFiniteFunctions(F:Join(FiniteFieldCategory, ConvertibleTo Integer)): )abbrev package GUESSINT GuessInteger ++ Description: ++ This package exports guessing of sequences of rational numbers + GuessInteger() == Guess(Fraction Integer, Integer, Expression Integer, Fraction Integer, id$MappingPackage1(Fraction Integer), @@ -40091,8 +40207,10 @@ GuessInteger() == Guess(Fraction Integer, Integer, Expression Integer, <>= )abbrev package GOPT0 GuessOptionFunctions0 ++ Author: Martin Rubey -++ Description: GuessOptionFunctions0 provides operations that extract the +++ Description: +++ GuessOptionFunctions0 provides operations that extract the ++ values of options for \spadtype{Guess}. + GuessOptionFunctions0(): Exports == Implementation where LGOPT ==> List GuessOption @@ -40264,6 +40382,7 @@ GuessOptionFunctions0(): Exports == Implementation where )abbrev package GUESSP GuessPolynomial ++ Description: ++ This package exports guessing of sequences of rational functions + GuessPolynomial() == Guess(Fraction Polynomial Integer, Polynomial Integer, Expression Integer, Fraction Polynomial Integer, @@ -40303,6 +40422,7 @@ GuessPolynomial() == Guess(Fraction Polynomial Integer, Polynomial Integer, )abbrev package GUESSUP GuessUnivariatePolynomial ++ Description: ++ This package exports guessing of sequences of univariate rational functions + GuessUnivariatePolynomial(q: Symbol): Exports == Implementation where UP ==> MyUnivariatePolynomial(q, Integer) @@ -40543,7 +40663,8 @@ GuessUnivariatePolynomial(q: Symbol): Exports == Implementation where ++ Related Constructors: OrderedSetInts, Commutator, FreeNilpotentLie ++ AMS Classification: Primary 17B05, 17B30; Secondary 17A50 ++ Keywords: free Lie algebra, Hall basis, basic commutators -++ Description : Generate a basis for the free Lie algebra on n +++ Description: +++ Generate a basis for the free Lie algebra on n ++ generators over a ring R with identity up to basic commutators ++ of length c using the algorithm of P. Hall as given in Serre's ++ book Lie Groups -- Lie Algebras @@ -40662,6 +40783,7 @@ HallBasis() : Export == Implement where ++ Description: ++ This package provides the functions for the heuristic integer gcd. ++ Geddes's algorithm,for univariate polynomials with integer coefficients + HeuGcd (BP):C == T where BP : UnivariatePolynomialCategory Integer @@ -40904,7 +41026,7 @@ HeuGcd (BP):C == T ++ Keywords: ++ References: ++ Description: -++ This package provides functions for the primary decomposition of +++ This package provides functions for the primary decomposition of ++ polynomial ideals over the rational numbers. The ideals are members ++ of the \spadtype{PolynomialIdeals} domain, and the polynomial generators are ++ required to be from the \spadtype{DistributedMultivariatePolynomial} domain. @@ -41016,7 +41138,7 @@ IdealDecompositionPackage(vl,nv) : C == T -- take away nv, now doesn't x:OV:=truelist.last #Id=1 => f:=Id.first - g:= (f exquo (gcd (f,differentiate(f,x))))::DPoly + g:= (f exquo (gcd (f,differentiate(f,x))))::DPoly groebnerIdeal([g]) y:=truelist.first px:DPoly:=x::DPoly @@ -41031,12 +41153,12 @@ IdealDecompositionPackage(vl,nv) : C == T -- take away nv, now doesn't val:=random()$Z rem 23 pv:=px+val*py pw:=px-val*py - Id:=groebner([(univariate(h,x)).pv for h in Id]) + Id:=groebner([(univariate(h,x)).pv for h in Id]) lf:=Id.first ris:= generators(zeroRadComp(groebnerIdeal(Id.rest),truelist.rest)) ris:=cons(lf,ris) if pv^=0 then - ris:=[(univariate(h,x)).pw for h in ris] + ris:=[(univariate(h,x)).pw for h in ris] groebnerIdeal(groebner ris) ---- find the power that stabilizes (I:s) ---- @@ -41057,10 +41179,10 @@ IdealDecompositionPackage(vl,nv) : C == T -- take away nv, now doesn't for x in truelist while Jd^=[] repeat f := Jd.first Jd:=Jd.rest - if ((y:=mainVariable f) case "failed") or (y::OV ^=x ) + if ((y:=mainVariable f) case "failed") or (y::OV ^=x ) or _^ (ismonic (f,x)) then return false - while Jd^=[] and (mainVariable Jd.first)::OV=x repeat Jd:=Jd.rest - if Jd=[] and position(x,truelist) 0 monomial((leadingCoefficient c)::F::DPoly,x,degree c) + - pushucoef(reductum c,x) + pushucoef(reductum c,x) -- is the 0-dimensional ideal I primary ? -- ---- internal function ---- @@ -41189,7 +41311,7 @@ IdealDecompositionPackage(vl,nv) : C == T -- take away nv, now doesn't else x:=truelist.i i:=(i-1)::NNI - if _^ testPower(univariate(f,x),x,JM) then return false + if _^ testPower(univariate(f,x),x,JM) then return false JM :=groebnerIdeal(append(cons(f,JP),generators JM)) true @@ -41212,9 +41334,10 @@ IdealDecompositionPackage(vl,nv) : C == T -- take away nv, now doesn't val:=-(_+/[rv*(vv::DPoly) for vv in lv1 for rv in lval]) val:=val+(x::DPoly) groebnerIdeal - (groebner([(univariate(p,x)).val for p in generators I ])) + (groebner([(univariate(p,x)).val for p in generators I ])) - ismonic(f:DPoly,x:OV) : Boolean == ground? leadingCoefficient(univariate(f,x)) + ismonic(f:DPoly,x:OV) : Boolean == + ground? leadingCoefficient(univariate(f,x)) ---- test if f is power of a linear mod (rad J) ---- ---- f is monic ---- @@ -41222,7 +41345,7 @@ IdealDecompositionPackage(vl,nv) : C == T -- take away nv, now doesn't df:=degree(uf) trailp:DPoly := inv(df:Z ::F) *coefficient(uf,(df-1)::NNI) linp:SUP:=(monomial(1$DPoly,1$NNI)$SUP + - monomial(trailp,0$NNI)$SUP)**df + monomial(trailp,0$NNI)$SUP)**df g:DPoly:=multivariate(uf-linp,x) inRadical?(g,J) @@ -41238,7 +41361,7 @@ IdealDecompositionPackage(vl,nv) : C == T -- take away nv, now doesn't #Jd^=n => false for f in Jd repeat if _^ ismonic(f,lvint.i) then return false - if i1 => false @@ -41309,7 +41432,7 @@ IdealDecompositionPackage(vl,nv) : C == T -- take away nv, now doesn't ++ Examples: ++ References: ++ Description: -++ This package provides operations to create incrementing functions. +++ This package provides operations to create incrementing functions. IncrementingMaps(R:Join(Monoid, AbelianSemiGroup)): with increment: () -> (R -> R) @@ -41358,8 +41481,9 @@ IncrementingMaps(R:Join(Monoid, AbelianSemiGroup)): with ++ Examples: ++ References: ++ Description: -++ This package computes infinite products of univariate Taylor series -++ over an integral domain of characteristic 0. +++ This package computes infinite products of univariate Taylor series +++ over an integral domain of characteristic 0. + InfiniteProductCharacteristicZero(Coef,UTS):_ Exports == Implementation where Coef : Join(IntegralDomain,CharacteristicZero) @@ -41427,8 +41551,9 @@ InfiniteProductCharacteristicZero(Coef,UTS):_ ++ Examples: ++ References: ++ Description: -++ This package computes infinite products of univariate Taylor series -++ over an arbitrary finite field. +++ This package computes infinite products of univariate Taylor series +++ over an arbitrary finite field. + InfiniteProductFiniteField(K,UP,Coef,UTS):_ Exports == Implementation where K : Join(Field,Finite,ConvertibleTo Integer) @@ -41556,8 +41681,9 @@ InfiniteProductFiniteField(K,UP,Coef,UTS):_ ++ Examples: ++ References: ++ Description: -++ This package computes infinite products of univariate Taylor series -++ over a field of prime order. +++ This package computes infinite products of univariate Taylor series +++ over a field of prime order. + InfiniteProductPrimeField(Coef,UTS): Exports == Implementation where Coef : Join(Field,Finite,ConvertibleTo Integer) UTS : UnivariateTaylorSeriesCategory Coef @@ -41617,8 +41743,10 @@ InfiniteProductPrimeField(Coef,UTS): Exports == Implementation where <>= )abbrev package ITFUN2 InfiniteTupleFunctions2 +++ Description: +++ Functions defined on streams with entries in two sets. + InfiniteTupleFunctions2(A:Type,B:Type): Exports == Implementation where - ++ Functions defined on streams with entries in two sets. IT ==> InfiniteTuple Exports ==> with @@ -41647,20 +41775,22 @@ InfiniteTupleFunctions2(A:Type,B:Type): Exports == Implementation where <>= )abbrev package ITFUN3 InfiniteTupleFunctions3 +++ Description: +++ Functions defined on streams with entries in two sets. + InfiniteTupleFunctions3(A:Type, B:Type,C:Type): Exports == Implementation where - ++ Functions defined on streams with entries in two sets. IT ==> InfiniteTuple ST ==> Stream SF3 ==> StreamFunctions3(A,B,C) FUN ==> ((A,B)->C) Exports ==> with map: (((A,B)->C), IT A, IT B) -> IT C - ++ map(f,a,b) \undocumented + ++ map(f,a,b) \undocumented map: (((A,B)->C), ST A, IT B) -> ST C - ++ map(f,a,b) \undocumented + ++ map(f,a,b) \undocumented map: (((A,B)->C), IT A, ST B) -> ST C - ++ map(f,a,b) \undocumented + ++ map(f,a,b) \undocumented Implementation ==> add @@ -41692,11 +41822,13 @@ InfiniteTupleFunctions3(A:Type, B:Type,C:Type): Exports <>= )abbrev package INFINITY Infinity -++ Top-level infinity ++ Author: Manuel Bronstein -++ Description: Default infinity signatures for the interpreter; ++ Date Created: 4 Oct 1989 ++ Date Last Updated: 4 Oct 1989 +++ Description: +++ Top-level infinity +++ Default infinity signatures for the interpreter; + Infinity(): with infinity : () -> OnePointCompletion Integer ++ infinity() returns infinity. @@ -41728,14 +41860,14 @@ Infinity(): with <>= )abbrev package IALGFACT InnerAlgFactor -++ Factorisation in a simple algebraic extension ++ Author: Patrizia Gianni ++ Date Created: ??? ++ Date Last Updated: 20 Jul 1988 +++ Keywords: factorization, algebraic extension, univariate polynomial ++ Description: +++ Factorisation in a simple algebraic extension ++ Factorization of univariate polynomials with coefficients in an ++ algebraic extension of a field over which we can factor UP's; -++ Keywords: factorization, algebraic extension, univariate polynomial InnerAlgFactor(F, UP, AlExt, AlPol): Exports == Implementation where F : Field @@ -41834,14 +41966,15 @@ InnerAlgFactor(F, UP, AlExt, AlPol): Exports == Implementation where <>= )abbrev package ICDEN InnerCommonDenominator ---% InnerCommonDenominator ++ Author: Manuel Bronstein ++ Date Created: 2 May 1988 ++ Date Last Updated: 22 Nov 1989 -++ Description: InnerCommonDenominator provides functions to compute +++ Keywords: gcd, quotient, common, denominator. +++ Description: +++ InnerCommonDenominator provides functions to compute ++ the common denominator of a finite linear aggregate of elements ++ of the quotient field of an integral domain. -++ Keywords: gcd, quotient, common, denominator. + InnerCommonDenominator(R, Q, A, B): Exports == Implementation where R: IntegralDomain Q: QuotientFieldCategory R @@ -41906,9 +42039,10 @@ InnerCommonDenominator(R, Q, A, B): Exports == Implementation where ++ Examples: ++ References: ++ Description: -++ \spadtype{InnerMatrixLinearAlgebraFunctions} is an internal package -++ which provides standard linear algebra functions on domains in -++ \spad{MatrixCategory} +++ \spadtype{InnerMatrixLinearAlgebraFunctions} is an internal package +++ which provides standard linear algebra functions on domains in +++ \spad{MatrixCategory} + InnerMatrixLinearAlgebraFunctions(R,Row,Col,M):_ Exports == Implementation where R : Field @@ -42146,10 +42280,11 @@ InnerMatrixLinearAlgebraFunctions(R,Row,Col,M):_ ++ Examples: ++ References: ++ Description: -++ \spadtype{InnerMatrixQuotientFieldFunctions} provides functions on matrices -++ over an integral domain which involve the quotient field of that integral -++ domain. The functions rowEchelon and inverse return matrices with -++ entries in the quotient field. +++ \spadtype{InnerMatrixQuotientFieldFunctions} provides functions on matrices +++ over an integral domain which involve the quotient field of that integral +++ domain. The functions rowEchelon and inverse return matrices with +++ entries in the quotient field. + InnerMatrixQuotientFieldFunctions(R,Row,Col,M,QF,Row2,Col2,M2):_ Exports == Implementation where R : IntegralDomain @@ -42172,7 +42307,7 @@ InnerMatrixQuotientFieldFunctions(R,Row,Col,M,QF,Row2,Col2,M2):_ ++ \spad{inverse(m)} returns the inverse of the matrix m. ++ If the matrix is not invertible, "failed" is returned. ++ Error: if the matrix is not square. - ++ Note: the result will have entries in the quotient field. + ++ Note that the result will have entries in the quotient field. if Col2 has shallowlyMutable then nullSpace : M -> List Col ++ \spad{nullSpace(m)} returns a basis for the null space of the @@ -42220,14 +42355,13 @@ InnerMatrixQuotientFieldFunctions(R,Row,Col,M,QF,Row2,Col2,M2):_ ++ for univariate polynomials with coefficients in a ++ non-trivial euclidean domain (i.e. not a field). ++ The package parametrised by the coefficient domain, -++ the polynomial domain, a prime, -++ and a function for choosing the next prime +++ the polynomial domain, a prime, and a function for choosing the next prime -Z ==> Integer -NNI ==> NonNegativeInteger InnerModularGcd(R,BP,pMod,nextMod):C == T where + Z ==> Integer + NNI ==> NonNegativeInteger R : EuclideanDomain BP : UnivariatePolynomialCategory(R) pMod : R @@ -42279,7 +42413,7 @@ InnerModularGcd(R,BP,pMod,nextMod):C == T g := first listf for f in rest listf | ^zero? f while degree g > 0 repeat g:=modGcdPrimitive(g,f) - g + g -- gcd for univariate polynomials modularGcd(listf : List BP): BP == @@ -42497,7 +42631,7 @@ InnerModularGcd(R,BP,pMod,nextMod):C == T ++ Keywords: ++ References: ++ Description: -++ This is an inner package for factoring multivariate polynomials +++ This is an inner package for factoring multivariate polynomials ++ over various coefficient domains in characteristic 0. ++ The univariate factor operation is passed as a parameter. ++ Multivariate hensel lifting is used to lift the univariate @@ -42976,9 +43110,9 @@ InnerMultFact(OV,E,R,P) : C == T ++ J. Grabmeier, A. Scheerhorn: Finite Fields in AXIOM. ++ AXIOM Technical Report Series, ATR/5 NP2522. ++ Description: -++ InnerNormalBasisFieldFunctions(GF) (unexposed): -++ This package has functions used by -++ every normal basis finite field extension domain. +++ InnerNormalBasisFieldFunctions(GF) (unexposed): +++ This package has functions used by +++ every normal basis finite field extension domain. InnerNormalBasisFieldFunctions(GF): Exports == Implementation where GF : FiniteFieldCategory -- the ground field @@ -43027,7 +43161,8 @@ InnerNormalBasisFieldFunctions(GF): Exports == Implementation where ++ \spad{e - 1} of \spad{v**(q**i*d)}, interpreting ++ v as an element of a normal basis field and where q is ++ the size of the ground field. - ++ Note: for a description of the algorithm, see T.Itoh and S.Tsujii, + ++ Note that for a description of the algorithm, see + ++ T.Itoh and S.Tsujii, ++ "A fast algorithm for computing multiplicative inverses in GF(2^m) ++ using normal bases", ++ Information and Computation 78, pp.171-177, 1988. @@ -43039,38 +43174,38 @@ InnerNormalBasisFieldFunctions(GF): Exports == Implementation where -- the semantic of the following functions is obvious from the finite field -- context, for description see category FAXF "**" :(VGF,I) -> VGF - ++ x**n \undocumented{} - ++ See \axiomFunFrom{**}{DivisionRing} + ++ x**n \undocumented{} + ++ See \axiomFunFrom{**}{DivisionRing} "*" :(VGF,VGF) -> VGF - ++ x*y \undocumented{} - ++ See \axiomFunFrom{*}{SemiGroup} + ++ x*y \undocumented{} + ++ See \axiomFunFrom{*}{SemiGroup} "/" :(VGF,VGF) -> VGF - ++ x/y \undocumented{} - ++ See \axiomFunFrom{/}{Field} + ++ x/y \undocumented{} + ++ See \axiomFunFrom{/}{Field} norm :(VGF,PI) -> VGF - ++ norm(x,n) \undocumented{} - ++ See \axiomFunFrom{norm}{FiniteAlgebraicExtensionField} + ++ norm(x,n) \undocumented{} + ++ See \axiomFunFrom{norm}{FiniteAlgebraicExtensionField} trace :(VGF,PI) -> VGF - ++ trace(x,n) \undocumented{} - ++ See \axiomFunFrom{trace}{FiniteAlgebraicExtensionField} + ++ trace(x,n) \undocumented{} + ++ See \axiomFunFrom{trace}{FiniteAlgebraicExtensionField} inv : VGF -> VGF - ++ inv x \undocumented{} - ++ See \axiomFunFrom{inv}{DivisionRing} + ++ inv x \undocumented{} + ++ See \axiomFunFrom{inv}{DivisionRing} lookup : VGF -> PI - ++ lookup(x) \undocumented{} - ++ See \axiomFunFrom{lookup}{Finite} + ++ lookup(x) \undocumented{} + ++ See \axiomFunFrom{lookup}{Finite} normal? : VGF -> Boolean - ++ normal?(x) \undocumented{} - ++ See \axiomFunFrom{normal?}{FiniteAlgebraicExtensionField} + ++ normal?(x) \undocumented{} + ++ See \axiomFunFrom{normal?}{FiniteAlgebraicExtensionField} basis : PI -> V VGF - ++ basis(n) \undocumented{} - ++ See \axiomFunFrom{basis}{FiniteAlgebraicExtensionField} + ++ basis(n) \undocumented{} + ++ See \axiomFunFrom{basis}{FiniteAlgebraicExtensionField} normalElement:PI -> VGF - ++ normalElement(n) \undocumented{} - ++ See \axiomFunFrom{normalElement}{FiniteAlgebraicExtensionField} + ++ normalElement(n) \undocumented{} + ++ See \axiomFunFrom{normalElement}{FiniteAlgebraicExtensionField} minimalPolynomial: VGF -> SUP GF - ++ minimalPolynomial(x) \undocumented{} - ++ See \axiomFunFrom{minimalPolynomial}{FiniteAlgebraicExtensionField} + ++ minimalPolynomial(x) \undocumented{} + ++ See \axiomFunFrom{minimalPolynomial}{FiniteAlgebraicExtensionField} Implementation ==> add @@ -43339,6 +43474,7 @@ InnerNormalBasisFieldFunctions(GF): Exports == Implementation where ++ This package is the inner package to be used by NumericRealEigenPackage ++ and NumericComplexEigenPackage for the computation of numeric ++ eigenvalues and eigenvectors. + InnerNumericEigenPackage(K,F,Par) : C == T where F : Field -- this is the field where the answer will be @@ -43555,11 +43691,15 @@ InnerNumericEigenPackage(K,F,Par) : C == T ++ This is an internal package ++ for computing approximate solutions to systems of polynomial equations. ++ The parameter K specifies the coefficient field of the input polynomials -++ and must be either \spad{Fraction(Integer)} or \spad{Complex(Fraction Integer)}. +++ and must be either \spad{Fraction(Integer)} or +++ \spad{Complex(Fraction Integer)}. ++ The parameter F specifies where the solutions must lie and can -++ be one of the following: \spad{Float}, \spad{Fraction(Integer)}, \spad{Complex(Float)}, +++ be one of the following: \spad{Float}, \spad{Fraction(Integer)}, +++ \spad{Complex(Float)}, ++ \spad{Complex(Fraction Integer)}. The last parameter specifies the type -++ of the precision operand and must be either \spad{Fraction(Integer)} or \spad{Float}. +++ of the precision operand and must be either \spad{Fraction(Integer)} or +++ \spad{Float}. + InnerNumericFloatSolvePackage(K,F,Par): Cat == Cap where F : Field -- this is the field where the answer will be K : GcdDomain -- type of the input @@ -43746,12 +43886,12 @@ InnerNumericFloatSolvePackage(K,F,Par): Cat == Cap where <>= )abbrev package INPSIGN InnerPolySign ---%% InnerPolySign ++ Author: Manuel Bronstein ++ Date Created: 23 Aug 1989 ++ Date Last Updated: 19 Feb 1990 ++ Description: ++ Find the sign of a polynomial around a point or infinity. + InnerPolySign(R, UP): Exports == Implementation where R : Ring UP: UnivariatePolynomialCategory R @@ -43760,11 +43900,11 @@ InnerPolySign(R, UP): Exports == Implementation where Exports ==> with signAround: (UP, Integer, R -> U) -> U - ++ signAround(u,i,f) \undocumented + ++ signAround(u,i,f) \undocumented signAround: (UP, R, Integer, R -> U) -> U - ++ signAround(u,r,i,f) \undocumented + ++ signAround(u,r,i,f) \undocumented signAround: (UP, R, R -> U) -> U - ++ signAround(u,r,f) \undocumented + ++ signAround(u,r,f) \undocumented Implementation ==> add signAround(p:UP, x:R, rsign:R -> U) == @@ -43804,11 +43944,12 @@ InnerPolySign(R, UP): Exports == Implementation where <>= )abbrev package ISUMP InnerPolySum -++ Summation of polynomials ++ Author: SMW ++ Date Created: ??? ++ Date Last Updated: 19 April 1991 -++ Description: tools for the summation packages. +++ Description: +++ Tools for the summation packages of polynomials + InnerPolySum(E, V, R, P): Exports == Impl where E: OrderedAbelianMonoidSup V: OrderedSet @@ -43880,15 +44021,15 @@ InnerPolySum(E, V, R, P): Exports == Impl where <>= )abbrev package ITRIGMNP InnerTrigonometricManipulations -++ Trigs to/from exps and logs ++ Author: Manuel Bronstein ++ Date Created: 4 April 1988 ++ Date Last Updated: 9 October 1993 -++ Description: -++ This package provides transformations from trigonometric functions -++ to exponentials and logarithms, and back. -++ F and FG should be the same type of function space. ++ Keywords: trigonometric, function, manipulation. +++ Description: +++ This package provides transformations from trigonometric functions +++ to exponentials and logarithms, and back. +++ F and FG should be the same type of function space. + InnerTrigonometricManipulations(R,F,FG): Exports == Implementation where R : Join(IntegralDomain, OrderedSet) F : Join(FunctionSpace R, RadicalCategory, @@ -44066,11 +44207,11 @@ InnerTrigonometricManipulations(R,F,FG): Exports == Implementation where )abbrev package INFORM1 InputFormFunctions1 --)boot $noSubsumption := false -++ Tools for manipulating input forms ++ Author: Manuel Bronstein ++ Date Created: ??? ++ Date Last Updated: 19 April 1991 -++ Description: Tools for manipulating input forms. +++ Description: +++ Tools for manipulating input forms. InputFormFunctions1(R:Type):with packageCall: Symbol -> InputForm @@ -44118,6 +44259,7 @@ representation and so are much facter than using a quotient loop. )abbrev package INTBIT IntegerBits ++ Description: ++ This package provides functions to lookup bits in integers + IntegerBits: with -- bitLength(n) == # of bits to represent abs(n) -- bitCoef (n,i) == coef of 2**i in abs(n) @@ -44272,13 +44414,15 @@ o )help set ++ Examples: ++ References: ++ Description: -++ The \spadtype{IntegerCombinatoricFunctions} package provides some -++ standard functions in combinatorics. -Z ==> Integer -N ==> NonNegativeInteger -SUP ==> SparseUnivariatePolynomial +++ The \spadtype{IntegerCombinatoricFunctions} package provides some +++ standard functions in combinatorics. -IntegerCombinatoricFunctions(I:IntegerNumberSystem): with +IntegerCombinatoricFunctions(I:IntegerNumberSystem): EE == II where + Z ==> Integer + N ==> NonNegativeInteger + SUP ==> SparseUnivariatePolynomial + EE ==> + with binomial: (I, I) -> I ++ \spad{binomial(n,r)} returns the binomial coefficient ++ \spad{C(n,r) = n!/(r! (n-r)!)}, where \spad{n >= r >= 0}. @@ -44288,7 +44432,7 @@ IntegerCombinatoricFunctions(I:IntegerNumberSystem): with factorial: I -> I ++ \spad{factorial(n)} returns \spad{n!}. this is the product of all ++ integers between 1 and n (inclusive). - ++ Note: \spad{0!} is defined to be 1. + ++ Note that \spad{0!} is defined to be 1. multinomial: (I, List I) -> I ++ \spad{multinomial(n,[m1,m2,...,mk])} returns the multinomial ++ coefficient \spad{n!/(m1! m2! ... mk!)}. @@ -44305,7 +44449,8 @@ IntegerCombinatoricFunctions(I:IntegerNumberSystem): with stirling2: (I, I) -> I ++ \spad{stirling2(n,m)} returns the Stirling number of the second kind ++ denoted \spad{SS[n,m]}. - == add + II ==> + add F : Record(Fn:I, Fv:I) := [0,1] B : Record(Bn:I, Bm:I, Bv:I) := [0,0,0] S : Record(Sn:I, Sp:SUP I) := [0,0] @@ -44428,6 +44573,7 @@ IntegerCombinatoricFunctions(I:IntegerNumberSystem): with <>= )abbrev package INTFACT IntegerFactorizationPackage +++ Description: ++ This Package contains basic methods for integer factorization. ++ The factor operation employs trial division up to 10,000. It ++ then tests to see if n is a perfect power before using Pollards @@ -44925,11 +45071,12 @@ o )show IntegerLinearDependence <>= )abbrev package ZLINDEP IntegerLinearDependence -++ Test for linear dependence over the integers ++ Author: Manuel Bronstein ++ Date Created: ??? ++ Date Last Updated: 14 May 1991 -++ Description: Test for linear dependence over the integers. +++ Description: +++ Test for linear dependence over the integers. + IntegerLinearDependence(R): Exports == Implementation where R: LinearlyExplicitRingOver Integer @@ -45649,6 +45796,7 @@ o )show IntegerNumberTheoryFunctions ++ References: Knuth, The Art of Computer Programming Vol.2 ++ Description: ++ This package provides various number theoretic functions on the integers. + IntegerNumberTheoryFunctions(): Exports == Implementation where I ==> Integer RN ==> Fraction I @@ -45662,7 +45810,7 @@ IntegerNumberTheoryFunctions(): Exports == Implementation where ++ polynomial. chineseRemainder: (I,I,I,I) -> I ++ \spad{chineseRemainder(x1,m1,x2,m2)} returns w, where w is such that - ++ \spad{w = x1 mod m1} and \spad{w = x2 mod m2}. Note: \spad{m1} and + ++ \spad{w = x1 mod m1} and \spad{w = x2 mod m2}. Note that \spad{m1} and ++ \spad{m2} must be relatively prime. divisors : I -> List I ++ \spad{divisors(n)} returns a list of the divisors of n. @@ -45686,13 +45834,13 @@ IntegerNumberTheoryFunctions(): Exports == Implementation where jacobi : (I,I) -> I ++ \spad{jacobi(a,b)} returns the Jacobi symbol \spad{J(a/b)}. ++ When b is odd, \spad{J(a/b) = product(L(a/p) for p in factor b )}. - ++ Note: by convention, 0 is returned if \spad{gcd(a,b) ^= 1}. + ++ Note that by convention, 0 is returned if \spad{gcd(a,b) ^= 1}. ++ Iterative \spad{O(log(b)^2)} version coded by Michael Monagan June 1987. legendre : (I,I) -> I ++ \spad{legendre(a,p)} returns the Legendre symbol \spad{L(a/p)}. ++ \spad{L(a/p) = (-1)**((p-1)/2) mod p} (p prime), which is 0 if \spad{a} ++ is 0, 1 if \spad{a} is a quadratic residue \spad{mod p} and -1 otherwise. - ++ Note: because the primality test is expensive, + ++ Note that because the primality test is expensive, ++ if it is known that p is prime then use \spad{jacobi(a,p)}. moebiusMu : I -> I ++ \spad{moebiusMu(n)} returns the Moebius function \spad{mu(n)}. @@ -45921,10 +46069,11 @@ We've expanded the list of small primes to include those between 1 and 10000. ++ References: Davenport's paper in ISSAC 1992 ++ AXIOM Technical Report ATR/6 ++ Description: -++ The \spadtype{IntegerPrimesPackage} implements a modification of -++ Rabin's probabilistic -++ primality test and the utility functions \spadfun{nextPrime}, -++ \spadfun{prevPrime} and \spadfun{primes}. +++ The \spadtype{IntegerPrimesPackage} implements a modification of +++ Rabin's probabilistic +++ primality test and the utility functions \spadfun{nextPrime}, +++ \spadfun{prevPrime} and \spadfun{primes}. + IntegerPrimesPackage(I:IntegerNumberSystem): with prime?: I -> Boolean ++ \spad{prime?(n)} returns true if n is prime and false if not. @@ -46349,9 +46498,11 @@ that is the square of the upper bound of the table range, in this case <>= )abbrev package INTRET IntegerRetractions ++ Author: Manuel Bronstein -++ Description: Provides integer testing and retraction functions. ++ Date Created: March 1990 ++ Date Last Updated: 9 April 1991 +++ Description: +++ Provides integer testing and retraction functions. + IntegerRetractions(S:RetractableTo(Integer)): with integer : S -> Integer ++ integer(x) returns x as an integer; @@ -46400,8 +46551,10 @@ IntegerRetractions(S:RetractableTo(Integer)): with ++ Keywords: integer roots ++ Examples: ++ References: -++ Description: The \spadtype{IntegerRoots} package computes square roots and -++ nth roots of integers efficiently. +++ Description: +++ The \spadtype{IntegerRoots} package computes square roots and +++ nth roots of integers efficiently. + IntegerRoots(I:IntegerNumberSystem): Exports == Implementation where NNI ==> NonNegativeInteger @@ -46552,6 +46705,7 @@ IntegerRoots(I:IntegerNumberSystem): Exports == Implementation where ++ \spadfun{solveLinearPolynomialEquation} ++ operation over the integers. It uses a lifting technique ++ from the package GenExEuclid + IntegerSolveLinearPolynomialEquation(): C ==T where ZP ==> SparseUnivariatePolynomial Integer @@ -46607,7 +46761,6 @@ IntegerSolveLinearPolynomialEquation(): C ==T <>= )abbrev package IBATOOL IntegralBasisTools -++ Functions common to both integral basis packages ++ Author: Victor Miller, Barry Trager, Clifton Williamson ++ Date Created: 11 April 1990 ++ Date Last Updated: 20 September 1994 @@ -46620,8 +46773,8 @@ IntegerSolveLinearPolynomialEquation(): C ==T IntegralBasisTools(R,UP,F): Exports == Implementation where R : EuclideanDomain with - squareFree: $ -> Factored $ - ++ squareFree(x) returns a square-free factorisation of x + squareFree: $ -> Factored $ + ++ squareFree(x) returns a square-free factorisation of x UP : UnivariatePolynomialCategory R F : FramedAlgebra(R,UP) Mat ==> Matrix R @@ -46681,7 +46834,7 @@ IntegralBasisTools(R,UP,F): Exports == Implementation where ans matrixGcd(mat,sing,n) == - -- note: 'matrix' is upper triangular; + -- note that 'matrix' is upper triangular; -- no need to do anything below the diagonal d := sing for i in 1..n repeat @@ -46692,7 +46845,7 @@ IntegralBasisTools(R,UP,F): Exports == Implementation where d divideIfCan_!(matrix,matrixOut,prime,n) == - -- note: both 'matrix' and 'matrixOut' will be upper triangular; + -- note that both 'matrix' and 'matrixOut' will be upper triangular; -- no need to do anything below the diagonal for i in 1..n repeat for j in i..n repeat @@ -46777,9 +46930,9 @@ IntegralBasisTools(R,UP,F): Exports == Implementation where ++ Keywords: function field, finite field, integral basis ++ Examples: ++ References: -++ Description: IntegralBasisPolynomialTools provides functions for -++ mapping functions on the coefficients of univariate and bivariate -++ polynomials. +++ Description: +++ IntegralBasisPolynomialTools provides functions for mapping functions +++ on the coefficients of univariate and bivariate polynomials. IntegralBasisPolynomialTools(K,R,UP,L): Exports == Implementation where K : Ring @@ -46871,11 +47024,13 @@ IntegralBasisPolynomialTools(K,R,UP,L): Exports == Implementation where <>= )abbrev package IR2 IntegrationResultFunctions2 -++ Internally used by the integration packages ++ Author: Manuel Bronstein ++ Date Created: 1987 ++ Date Last Updated: 12 August 1992 ++ Keywords: integration. +++ Description: +++ Internally used by the integration packages + IntegrationResultFunctions2(E, F): Exports == Implementation where E : Field F : Field @@ -46898,14 +47053,14 @@ IntegrationResultFunctions2(E, F): Exports == Implementation where Exports ==> with map: (E -> F, IRE) -> IRF - ++ map(f,ire) \undocumented + ++ map(f,ire) \undocumented map: (E -> F, URE) -> Union(Record(ratpart:F, coeff:F), "failed") - ++ map(f,ure) \undocumented + ++ map(f,ure) \undocumented map: (E -> F, UE) -> Union(F, "failed") - ++ map(f,ue) \undocumented + ++ map(f,ue) \undocumented map: (E -> F, UFE) -> Union(Record(mainpart:F, limitedlogs:List NLF), "failed") - ++ map(f,ufe) \undocumented + ++ map(f,ufe) \undocumented Implementation ==> add import SparseUnivariatePolynomialFunctions2(E, F) @@ -46956,14 +47111,15 @@ IntegrationResultFunctions2(E, F): Exports == Implementation where <>= )abbrev package IRRF2F IntegrationResultRFToFunction -++ Conversion of integration results to top-level expressions ++ Author: Manuel Bronstein -++ Description: -++ This package allows a sum of logs over the roots of a polynomial -++ to be expressed as explicit logarithms and arc tangents, provided -++ that the indexing polynomial can be factored into quadratics. ++ Date Created: 21 August 1988 ++ Date Last Updated: 4 October 1993 +++ Description: +++ Conversion of integration results to top-level expressions. +++ This package allows a sum of logs over the roots of a polynomial +++ to be expressed as explicit logarithms and arc tangents, provided +++ that the indexing polynomial can be factored into quadratics. + IntegrationResultRFToFunction(R): Exports == Implementation where R: Join(GcdDomain, RetractableTo Integer, OrderedSet, LinearlyExplicitRingOver Integer) @@ -47039,15 +47195,16 @@ IntegrationResultRFToFunction(R): Exports == Implementation where <>= )abbrev package IR2F IntegrationResultToFunction -++ Conversion of integration results to top-level expressions ++ Author: Manuel Bronstein ++ Date Created: 4 February 1988 ++ Date Last Updated: 9 October 1991 -++ Description: -++ This package allows a sum of logs over the roots of a polynomial -++ to be expressed as explicit logarithms and arc tangents, provided -++ that the indexing polynomial can be factored into quadratics. ++ Keywords: integration, expansion, function. +++ Description: +++ Conversion of integration results to top-level expressions +++ This package allows a sum of logs over the roots of a polynomial +++ to be expressed as explicit logarithms and arc tangents, provided +++ that the indexing polynomial can be factored into quadratics. + IntegrationResultToFunction(R, F): Exports == Implementation where R: Join(GcdDomain, RetractableTo Integer, OrderedSet, LinearlyExplicitRingOver Integer) @@ -47277,11 +47434,13 @@ IntegrationResultToFunction(R, F): Exports == Implementation where <>= )abbrev package INTTOOLS IntegrationTools -++ Tools for the integrator ++ Author: Manuel Bronstein ++ Date Created: 25 April 1990 ++ Date Last Updated: 9 June 1993 ++ Keywords: elementary, function, integration. +++ Description: +++ Tools for the integrator + IntegrationTools(R:OrderedSet, F:FunctionSpace R): Exp == Impl where K ==> Kernel F SE ==> Symbol @@ -47435,8 +47594,8 @@ IntegrationTools(R:OrderedSet, F:FunctionSpace R): Exp == Impl where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: A package to print strings without line-feed -++ nor carriage-return. +++ Description: +++ A package to print strings without line-feed nor carriage-return. InternalPrintPackage(): Exports == Implementation where @@ -47478,15 +47637,13 @@ InternalPrintPackage(): Exports == Implementation where ++ Also See: ++ AMS Classifications: ++ Keywords: -++ Description: -++ An internal package for computing the rational univariate representation -++ of a zero-dimensional algebraic variety given by a square-free -++ triangular set. -++ The main operation is \axiomOpFrom{rur}{InternalRationalUnivariateRepresentationPackage}. -++ It is based on the {\em generic} algorithm description in [1]. \newline References: +++ References: ++ [1] D. LAZARD "Solving Zero-dimensional Algebraic Systems" ++ Journal of Symbolic Computation, 1992, 13, 117-131 -++ Version: 1. +++ Description: +++ An internal package for computing the rational univariate representation +++ of a zero-dimensional algebraic variety given by a square-free +++ triangular set. The main operation is rur InternalRationalUnivariateRepresentationPackage(R,E,V,P,TS): Exports == Implementation where R : Join(EuclideanDomain,CharacteristicZero) @@ -47781,16 +47938,16 @@ IrredPolyOverFiniteField(GF:FiniteFieldCategory): Exports == Impl where ++ their Realization in the Computer Algebra System Scratchpad, ++ Bayreuther Mathematische Schriften, Heft 33, 1990, 1-23 ++ Description: -++ IrrRepSymNatPackage contains functions for computing -++ the ordinary irreducible representations of symmetric groups on -++ n letters {\em {1,2,...,n}} in Young's natural form and their dimensions. -++ These representations can be labelled by number partitions of n, -++ i.e. a weakly decreasing sequence of integers summing up to n, e.g. -++ {\em [3,3,3,1]} labels an irreducible representation for n equals 10. -++ Note: whenever a \spadtype{List Integer} appears in a signature, -++ a partition required. --- NOT TRUE in current system, but should: --- also could be an element of \spadtype(Partition) +++ IrrRepSymNatPackage contains functions for computing +++ the ordinary irreducible representations of symmetric groups on +++ n letters {1,2,...,n} in Young's natural form and their dimensions. +++ These representations can be labelled by number partitions of n, +++ i.e. a weakly decreasing sequence of integers summing up to n, e.g. +++ [3,3,3,1] labels an irreducible representation for n equals 10. +++ Note that whenever a \spadtype{List Integer} appears in a signature, +++ a partition required. +-- NOT TRUE in current system, but should: +-- also could be an element of \spadtype(Partition) IrrRepSymNatPackage(): public == private where NNI ==> NonNegativeInteger @@ -47809,25 +47966,25 @@ IrrRepSymNatPackage(): public == private where dimensionOfIrreducibleRepresentation : L I -> NNI ++ dimensionOfIrreducibleRepresentation(lambda) is the dimension ++ of the ordinary irreducible representation of the symmetric group - ++ corresponding to {\em lambda}. - ++ Note: the Robinson-Thrall hook formula is implemented. + ++ corresponding to lambda. + ++ Note that the Robinson-Thrall hook formula is implemented. irreducibleRepresentation : (L I, PERM I) -> M I ++ irreducibleRepresentation(lambda,pi) is the irreducible representation - ++ corresponding to partition {\em lambda} in Young's natural form of the - ++ permutation {\em pi} in the symmetric group, whose elements permute - ++ {\em {1,2,...,n}}. + ++ corresponding to partition lambda in Young's natural form of the + ++ permutation pi in the symmetric group, whose elements permute + ++ {1,2,...,n}. irreducibleRepresentation : L I -> L M I ++ irreducibleRepresentation(lambda) is the list of the two - ++ irreducible representations corresponding to the partition {\em lambda} + ++ irreducible representations corresponding to the partition lambda ++ in Young's natural form for the following two generators ++ of the symmetric group, whose elements permute - ++ {\em {1,2,...,n}}, namely {\em (1 2)} (2-cycle) and - ++ {\em (1 2 ... n)} (n-cycle). + ++ {1,2,...,n}, namely (1 2) (2-cycle) and + ++ (1 2 ... n) (n-cycle). irreducibleRepresentation : (L I, L PERM I) -> L M I ++ irreducibleRepresentation(lambda,listOfPerm) is the list of the - ++ irreducible representations corresponding to {\em lambda} + ++ irreducible representations corresponding to lambda ++ in Young's natural form for the list of permutations - ++ given by {\em listOfPerm}. + ++ given by listOfPerm. private ==> add @@ -48084,11 +48241,12 @@ IrrRepSymNatPackage(): public == private where <>= )abbrev package INVLAPLA InverseLaplaceTransform -++ Inverse Laplace transform ++ Author: Barry Trager ++ Date Created: 3 Sept 1991 ++ Date Last Updated: 3 Sept 1991 -++ Description: This package computes the inverse Laplace Transform. +++ Description: +++ This package computes the inverse Laplace Transform. + InverseLaplaceTransform(R, F): Exports == Implementation where R : Join(EuclideanDomain, OrderedSet, CharacteristicZero, RetractableTo Integer, LinearlyExplicitRingOver Integer) @@ -48202,11 +48360,12 @@ InverseLaplaceTransform(R, F): Exports == Implementation where )abbrev package KERNEL2 KernelFunctions2 ++ Description: ++ This package exports some auxiliary functions on kernels + KernelFunctions2(R:OrderedSet, S:OrderedSet): with constantKernel: R -> Kernel S - ++ constantKernel(r) \undocumented + ++ constantKernel(r) \undocumented constantIfCan : Kernel S -> Union(R, "failed") - ++ constantIfCan(k) \undocumented + ++ constantIfCan(k) \undocumented == add import BasicOperatorFunctions1(R) @@ -48234,11 +48393,12 @@ KernelFunctions2(R:OrderedSet, S:OrderedSet): with ++ Author: Manuel Bronstein ++ Date Created: 14 January 1992 ++ Date Last Updated: 3 February 1994 +++ Keywords: differential equation, ODE ++ Description: ++ \spadtype{Kovacic} provides a modified Kovacic's algorithm for ++ solving explicitely irreducible 2nd order linear ordinary ++ differential equations. -++ Keywords: differential equation, ODE + Kovacic(F, UP): Exports == Impl where F : Join(CharacteristicZero, AlgebraicallyClosedField, RetractableTo Integer, RetractableTo Fraction Integer) @@ -48340,11 +48500,12 @@ Kovacic(F, UP): Exports == Impl where <>= )abbrev package LAPLACE LaplaceTransform -++ Laplace transform ++ Author: Manuel Bronstein ++ Date Created: 30 May 1990 ++ Date Last Updated: 13 December 1995 -++ Description: This package computes the forward Laplace Transform. +++ Description: +++ This package computes the forward Laplace Transform. + LaplaceTransform(R, F): Exports == Implementation where R : Join(EuclideanDomain, OrderedSet, CharacteristicZero, RetractableTo Integer, LinearlyExplicitRingOver Integer) @@ -49272,7 +49433,7 @@ zeroSetSplit(lp,false)$pack 2916b1 - 30600w - 46692w - 20274w - 8076w + 593} ] -We see the sixth triangular set is {\em nicer} now: each one of its +We see the sixth triangular set is nicer now: each one of its polynomials has a constant initial. We follow with the Vermeer example. The ordering is the usual one @@ -49547,22 +49708,20 @@ o )show ZeroDimensionalSolvePackage ++ Also See: ++ AMS Classifications: ++ Keywords: +++ References : +++ [1] D. LAZARD "A new method for solving algebraic systems of +++ positive dimension" Discr. App. Math. 33:147-160,1991 +++ [2] M. MORENO MAZA "A new algorithm for computing triangular +++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. ++ Description: ++ A package for solving polynomial systems by means of Lazard triangular -++ sets [1]. -++ This package provides two operations. One for solving in the sense +++ sets. This package provides two operations. One for solving in the sense ++ of the regular zeros, and the other for solving in the sense of ++ the Zariski closure. Both produce square-free regular sets. ++ Moreover, the decompositions do not contain any redundant component. ++ However, only zero-dimensional regular sets are normalized, since ++ normalization may be time consumming in positive dimension. -++ The decomposition process is that of [2].\newline -++ References : -++ [1] D. LAZARD "A new method for solving algebraic systems of -++ positive dimension" Discr. App. Math. 33:147-160,1991 -++ [2] M. MORENO MAZA "A new algorithm for computing triangular -++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. -++ Version: 1. +++ The decomposition process is that of [2]. LazardSetSolvingPackage(R,E,V,P,TS,ST): Exports == Implementation where @@ -49600,7 +49759,7 @@ LazardSetSolvingPackage(R,E,V,P,TS,ST): Exports == Implementation where ++ if \axiom{ts} is zero-dimensional. zeroSetSplit: (LP, B) -> List ST ++ \axiom{zeroSetSplit(lp,clos?)} has the same specifications as - ++ \axiomOpFrom{zeroSetSplit(lp,clos?)}{RegularTriangularSetCategory}. + ++ zeroSetSplit(lp,clos?) from RegularTriangularSetCategory. Implementation == add @@ -49683,6 +49842,7 @@ LazardSetSolvingPackage(R,E,V,P,TS,ST): Exports == Implementation where ++ Description: ++ Package for leading coefficient determination in the lifting step. ++ Package working for every R euclidean with property "F". + LeadingCoefDetermination(OV,E,Z,P) : C == T where OV : OrderedSet @@ -53259,25 +53419,25 @@ o )show LexTriangularPackage ++ Also See: ++ AMS Classifications: ++ Keywords: +++ References: +++ [1] D. LAZARD "Solving Zero-dimensional Algebraic Systems" +++ published in the J. of Symbol. Comput. (1992) 13, 117-131. +++ [2] M. MORENO MAZA and R. RIOBOO "Computations of gcd over +++ algebraic towers of simple extensions" +++ In proceedings of AAECC11, Paris, 1995. ++ Description: ++ A package for solving polynomial systems with finitely many solutions. ++ The decompositions are given by means of regular triangular sets. ++ The computations use lexicographical Groebner bases. -++ The main operations are \axiomOpFrom{lexTriangular}{LexTriangularPackage} -++ and \axiomOpFrom{squareFreeLexTriangular}{LexTriangularPackage}. -++ The second one provide decompositions by means of square-free regular triangular sets. -++ Both are based on the {\em lexTriangular} method described in [1]. +++ The main operations are lexTriangular +++ and squareFreeLexTriangular. The second one provide decompositions by +++ means of square-free regular triangular sets. +++ Both are based on the lexTriangular method described in [1]. ++ They differ from the algorithm described in [2] by the fact that ++ multiciplities of the roots are not kept. -++ With the \axiomOpFrom{squareFreeLexTriangular}{LexTriangularPackage} operation -++ all multiciplities are removed. With the other operation some multiciplities may remain. -++ Both operations admit an optional argument to produce normalized triangular sets. \newline -++ References: \newline -++ [1] D. LAZARD "Solving Zero-dimensional Algebraic Systems" -++ published in the J. of Symbol. Comput. (1992) 13, 117-131.\newline -++ [2] M. MORENO MAZA and R. RIOBOO "Computations of gcd over -++ algebraic towers of simple extensions" In proceedings of AAECC11, Paris, 1995.\newline -++ Version: 2. +++ With the squareFreeLexTriangular operation all multiciplities are removed. +++ With the other operation some multiciplities may remain. Both operations +++ admit an optional argument to produce normalized triangular sets. LexTriangularPackage(R,ls): Exports == Implementation where @@ -53316,13 +53476,13 @@ LexTriangularPackage(R,ls): Exports == Implementation where ++ w.r.t. the variables involved in \axiom{lp}. fglmIfCan: LP -> Union(LP, "failed") ++ \axiom{fglmIfCan(lp)} returns the lexicographical Groebner - ++ basis of \axiom{lp} by using the {\em FGLM} strategy, + ++ basis of \axiom{lp} by using the FGLM strategy, ++ if \axiom{zeroDimensional?(lp)} holds . groebner: LP -> LP ++ \axiom{groebner(lp)} returns the lexicographical Groebner ++ basis of \axiom{lp}. If \axiom{lp} generates a zero-dimensional - ++ ideal then the {\em FGLM} strategy is used, otherwise - ++ the {\em Sugar} strategy is used. + ++ ideal then the FGLM strategy is used, otherwise + ++ the Sugar strategy is used. lexTriangular: (LP, B) -> List TS ++ \axiom{lexTriangular(base, norm?)} decomposes the variety ++ associated with \axiom{base} into regular chains. @@ -53493,11 +53653,12 @@ LexTriangularPackage(R,ls): Exports == Implementation where <>= )abbrev package LINDEP LinearDependence -++ Test for linear dependence ++ Author: Manuel Bronstein ++ Date Created: ??? ++ Date Last Updated: 14 May 1991 -++ Description: Test for linear dependence. +++ Description: +++ Test for linear dependence. + LinearDependence(S, R): Exports == Implementation where S: IntegralDomain R: LinearlyExplicitRingOver S @@ -53587,11 +53748,12 @@ LinearDependence(S, R): Exports == Implementation where ++ Author: Fritz Schwarz, Manuel Bronstein ++ Date Created: 1988 ++ Date Last Updated: 3 February 1994 +++ Keywords: differential equation, ODE, LODO, factoring ++ Description: ++ \spadtype{LinearOrdinaryDifferentialOperatorFactorizer} provides a ++ factorizer for linear ordinary differential operators whose coefficients ++ are rational functions. -++ Keywords: differential equation, ODE, LODO, factoring + LinearOrdinaryDifferentialOperatorFactorizer(F, UP): Exports == Impl where F : Join(Field, CharacteristicZero, RetractableTo Integer, RetractableTo Fraction Integer) @@ -53730,11 +53892,12 @@ LinearOrdinaryDifferentialOperatorFactorizer(F, UP): Exports == Impl where ++ Date Created: 18 January 1994 ++ Date Last Updated: 15 April 1994 ++ Description: -++ \spad{LinearOrdinaryDifferentialOperatorsOps} provides symmetric -++ products and sums for linear ordinary differential operators. +++ \spad{LinearOrdinaryDifferentialOperatorsOps} provides symmetric +++ products and sums for linear ordinary differential operators. -- Putting those operations here rather than defaults in LODOCAT allows -- LODOCAT to be defined independently of the derivative used. -- MB 1/94 + LinearOrdinaryDifferentialOperatorsOps(A, L): Exports == Implementation where A: Field L: LinearOrdinaryDifferentialOperatorCategory A @@ -53857,6 +54020,7 @@ LinearOrdinaryDifferentialOperatorsOps(A, L): Exports == Implementation where ++ provides a defaulting rule for the \spad{solveLinearPolynomialEquation} ++ operation, by moving into the field of fractions, and solving it there ++ via the \spad{multiEuclidean} operation. + LinearPolynomialEquationByFractions(R:PolynomialFactorizationExplicit): with solveLinearPolynomialEquationByFractions: ( _ List SparseUnivariatePolynomial R, _ @@ -53939,12 +54103,12 @@ LinearSystemMatrixPackage(F, Row, Col, M): Cat == Capsule where Cat ==> with solve : (M, Col) -> Both - ++ solve(A,B) finds a particular solution of the system \spad{AX = B} - ++ and a basis of the associated homogeneous system \spad{AX = 0}. + ++ solve(A,B) finds a particular solution of the system \spad{AX = B} + ++ and a basis of the associated homogeneous system \spad{AX = 0}. solve : (M, List Col) -> List Both - ++ solve(A,LB) finds a particular soln of the systems \spad{AX = B} - ++ and a basis of the associated homogeneous systems \spad{AX = 0} - ++ where B varies in the list of column vectors LB. + ++ solve(A,LB) finds a particular soln of the systems \spad{AX = B} + ++ and a basis of the associated homogeneous systems \spad{AX = 0} + ++ where B varies in the list of column vectors LB. particularSolution: (M, Col) -> PartialV ++ particularSolution(A,B) finds a particular solution of the linear @@ -54057,19 +54221,19 @@ LinearSystemMatrixPackage1(F): Cat == Capsule where Cat ==> with solve : (M, Col) -> Both - ++ solve(A,B) finds a particular solution of the system \spad{AX = B} - ++ and a basis of the associated homogeneous system \spad{AX = 0}. + ++ solve(A,B) finds a particular solution of the system \spad{AX = B} + ++ and a basis of the associated homogeneous system \spad{AX = 0}. solve : (LL, Col) -> Both - ++ solve(A,B) finds a particular solution of the system \spad{AX = B} - ++ and a basis of the associated homogeneous system \spad{AX = 0}. + ++ solve(A,B) finds a particular solution of the system \spad{AX = B} + ++ and a basis of the associated homogeneous system \spad{AX = 0}. solve : (M, List Col) -> List Both - ++ solve(A,LB) finds a particular soln of the systems \spad{AX = B} - ++ and a basis of the associated homogeneous systems \spad{AX = 0} - ++ where B varies in the list of column vectors LB. + ++ solve(A,LB) finds a particular soln of the systems \spad{AX = B} + ++ and a basis of the associated homogeneous systems \spad{AX = 0} + ++ where B varies in the list of column vectors LB. solve : (LL, List Col) -> List Both - ++ solve(A,LB) finds a particular soln of the systems \spad{AX = B} - ++ and a basis of the associated homogeneous systems \spad{AX = 0} - ++ where B varies in the list of column vectors LB. + ++ solve(A,LB) finds a particular soln of the systems \spad{AX = B} + ++ and a basis of the associated homogeneous systems \spad{AX = 0} + ++ where B varies in the list of column vectors LB. particularSolution: (M, Col) -> PartialV ++ particularSolution(A,B) finds a particular solution of the linear @@ -54117,7 +54281,7 @@ LinearSystemMatrixPackage1(F): Cat == Capsule where ++ Keywords: ++ References: SystemSolvePackage ++ Description: -++ this package finds the solutions of linear systems presented as a +++ This package finds the solutions of linear systems presented as a ++ list of polynomials. LinearSystemPolynomialPackage(R, E, OV, P): Cat == Capsule where @@ -54196,10 +54360,12 @@ LinearSystemPolynomialPackage(R, E, OV, P): Cat == Capsule where <>= )abbrev package LGROBP LinGroebnerPackage -++ Given a Groebner basis B with respect to the total degree ordering for -++ a zero-dimensional ideal I, compute -++ a Groebner basis with respect to the lexicographical ordering by using -++ linear algebra. +++ Description: +++ Given a Groebner basis B with respect to the total degree ordering for +++ a zero-dimensional ideal I, compute +++ a Groebner basis with respect to the lexicographical ordering by using +++ linear algebra. + LinGroebnerPackage(lv,F) : C == T where @@ -54224,29 +54390,29 @@ LinGroebnerPackage(lv,F) : C == T C == with linGenPos : List HDPoly -> LVals - ++ linGenPos \undocumented + ++ linGenPos \undocumented groebgen : List DPoly -> cLVars - ++ groebgen \undocumented + ++ groebgen \undocumented totolex : List HDPoly -> List DPoly - ++ totolex \undocumented + ++ totolex \undocumented minPol : (List HDPoly,List HDPoly,OV) -> HDPoly - ++ minPol \undocumented + ++ minPol \undocumented minPol : (List HDPoly,OV) -> HDPoly - ++ minPol \undocumented + ++ minPol \undocumented computeBasis : List HDPoly -> List HDPoly - ++ computeBasis \undocumented + ++ computeBasis \undocumented coord : (HDPoly,List HDPoly) -> VF - ++ coord \undocumented + ++ coord \undocumented anticoord : (List F,DPoly,List DPoly) -> DPoly - ++ anticoord \undocumented + ++ anticoord \undocumented intcompBasis : (OV,List HDPoly,List HDPoly) -> List HDPoly - ++ intcompBasis \undocumented + ++ intcompBasis \undocumented choosemon : (DPoly,List DPoly) -> DPoly - ++ choosemon \undocumented + ++ choosemon \undocumented transform : DPoly -> HDPoly - ++ transform \undocumented + ++ transform \undocumented T == add @@ -54536,7 +54702,8 @@ LinGroebnerPackage(lv,F) : C == T ++ Keywords: liouvillian, function, primitive, exponential. ++ Examples: )r LF INPUT ++ Description: -++ This package provides liouvillian functions over an integral domain. +++ This package provides liouvillian functions over an integral domain. + LiouvillianFunction(R, F): Exports == Implementation where R:Join(OrderedSet, IntegralDomain) F:Join(FunctionSpace R,RadicalCategory,TranscendentalFunctionCategory) @@ -54746,9 +54913,10 @@ LiouvillianFunction(R, F): Exports == Implementation where ++ AMS Classification: ++ Keywords: list, aggregate, map, reduce ++ Description: -++ \spadtype{ListFunctions2} implements utility functions that -++ operate on two kinds of lists, each with a possibly different -++ type of element. +++ \spadtype{ListFunctions2} implements utility functions that +++ operate on two kinds of lists, each with a possibly different +++ type of element. + ListFunctions2(A:Type, B:Type): public == private where LA ==> List A LB ==> List B @@ -54807,9 +54975,10 @@ ListFunctions2(A:Type, B:Type): public == private where ++ AMS Classification: ++ Keywords: list, aggregate, map ++ Description: -++ \spadtype{ListFunctions3} implements utility functions that -++ operate on three kinds of lists, each with a possibly different -++ type of element. +++ \spadtype{ListFunctions3} implements utility functions that +++ operate on three kinds of lists, each with a possibly different +++ type of element. + ListFunctions3(A:Type, B:Type, C:Type): public == private where LA ==> List A LB ==> List B @@ -54857,13 +55026,14 @@ ListFunctions3(A:Type, B:Type, C:Type): public == private where ++ AMS Classification: ++ Keywords: mapping, list ++ Description: -++ \spadtype{ListToMap} allows mappings to be described by a pair of -++ lists of equal lengths. The image of an element \spad{x}, -++ which appears in position \spad{n} in the first list, is then -++ the \spad{n}th element of the second list. A default value or -++ default function can be specified to be used when \spad{x} -++ does not appear in the first list. In the absence of defaults, -++ an error will occur in that case. +++ \spadtype{ListToMap} allows mappings to be described by a pair of +++ lists of equal lengths. The image of an element \spad{x}, +++ which appears in position \spad{n} in the first list, is then +++ the \spad{n}th element of the second list. A default value or +++ default function can be specified to be used when \spad{x} +++ does not appear in the first list. In the absence of defaults, +++ an error will occur in that case. + ListToMap(A:SetCategory, B:Type): Exports == Implementation where LA ==> List A LB ==> List B @@ -54876,7 +55046,7 @@ ListToMap(A:SetCategory, B:Type): Exports == Implementation where ++ The target of a source value \spad{x} in la is the ++ value y with the same index lb. ++ Error: if la and lb are not of equal length. - ++ Note: when this map is applied, an error occurs when + ++ Note that when this map is applied, an error occurs when ++ applied to a value missing from la. match: (LA, LB, A) -> B ++ match(la, lb, a) creates a map @@ -54955,11 +55125,13 @@ ListToMap(A:SetCategory, B:Type): Exports == Implementation where <>= )abbrev package MKBCFUNC MakeBinaryCompiledFunction -++ Tools for making compiled functions from top-level expressions ++ Author: Manuel Bronstein ++ Date Created: 1 Dec 1988 ++ Date Last Updated: 5 Mar 1990 -++ Description: transforms top-level objects into compiled functions. +++ Description: +++ Tools and transforms for making compiled functions from +++ top-level expressions + MakeBinaryCompiledFunction(S, D1, D2, I):Exports == Implementation where S: ConvertibleTo InputForm D1, D2, I: Type @@ -55008,15 +55180,16 @@ MakeBinaryCompiledFunction(S, D1, D2, I):Exports == Implementation where <>= )abbrev package MKFLCFN MakeFloatCompiledFunction -++ Tools for making compiled functions from top-level expressions ++ Author: Manuel Bronstein ++ Date Created: 2 Mar 1990 ++ Date Last Updated: 2 Dec 1996 (MCD) ++ Description: +++ Tools for making compiled functions from top-level expressions ++ MakeFloatCompiledFunction transforms top-level objects into ++ compiled Lisp functions whose arguments are Lisp floats. ++ This by-passes the \Language{} compiler and interpreter, ++ thereby gaining several orders of magnitude. + MakeFloatCompiledFunction(S): Exports == Implementation where S: ConvertibleTo InputForm @@ -55351,11 +55524,13 @@ o )show MakeFunction <>= )abbrev package MKFUNC MakeFunction -++ Tools for making interpreter functions from top-level expressions ++ Author: Manuel Bronstein ++ Date Created: 22 Nov 1988 ++ Date Last Updated: 8 Jan 1990 -++ Description: transforms top-level objects into interpreter functions. +++ Description: +++ Tools for making interpreter functions from top-level expressions +++ Transforms top-level objects into interpreter functions. + MakeFunction(S:ConvertibleTo InputForm): Exports == Implementation where SY ==> Symbol @@ -55397,8 +55572,9 @@ MakeFunction(S:ConvertibleTo InputForm): Exports == Implementation where <>= )abbrev package MKRECORD MakeRecord ++ Description: -++ MakeRecord is used internally by the interpreter to create record -++ types which are used for doing parallel iterations on streams. +++ MakeRecord is used internally by the interpreter to create record +++ types which are used for doing parallel iterations on streams. + MakeRecord(S: Type, T: Type): public == private where public == with makeRecord: (S,T) -> Record(part1: S, part2: T) @@ -55431,11 +55607,13 @@ MakeRecord(S: Type, T: Type): public == private where <>= )abbrev package MKUCFUNC MakeUnaryCompiledFunction -++ Tools for making compiled functions from top-level expressions ++ Author: Manuel Bronstein ++ Date Created: 1 Dec 1988 ++ Date Last Updated: 5 Mar 1990 -++ Description: transforms top-level objects into compiled functions. +++ Description: +++ Tools for making compiled functions from top-level expressions +++ Transforms top-level objects into compiled functions. + MakeUnaryCompiledFunction(S, D, I): Exports == Implementation where S: ConvertibleTo InputForm D, I: Type @@ -55497,7 +55675,9 @@ MakeUnaryCompiledFunction(S, D, I): Exports == Implementation where ++ Keywords: ++ Examples: ++ References: -++ Description: various Currying operations. +++ Description: +++ Various Currying operations. + MappingPackageInternalHacks1(A: SetCategory): MPcat == MPdef where NNI ==> NonNegativeInteger @@ -55537,7 +55717,9 @@ MappingPackageInternalHacks1(A: SetCategory): MPcat == MPdef where <>= )abbrev package MAPHACK2 MappingPackageInternalHacks2 -++ Description: various Currying operations. +++ Description: +++ Various Currying operations. + MappingPackageInternalHacks2(A: SetCategory, C: SetCategory):_ MPcat == MPdef where NNI ==> NonNegativeInteger @@ -55571,7 +55753,9 @@ MappingPackageInternalHacks2(A: SetCategory, C: SetCategory):_ <>= )abbrev package MAPHACK3 MappingPackageInternalHacks3 -++ Description: various Currying operations. +++ Description: +++ Various Currying operations. + MappingPackageInternalHacks3(A: SetCategory, B: SetCategory, C: SetCategory):_ MPcat == MPdef where NNI ==> NonNegativeInteger @@ -56037,7 +56221,9 @@ o )help MappingPackage4 ++ Keywords: ++ Examples: ++ References: -++ Description: various Currying operations. +++ Description: +++ Various Currying operations. + MappingPackage1(A:SetCategory): MPcat == MPdef where NNI ==> NonNegativeInteger @@ -56537,7 +56723,9 @@ o )help MappingPackage4 <>= )abbrev package MAPPKG2 MappingPackage2 -++ Description: various Currying operations. +++ Description: +++ Various Currying operations. + MappingPackage2(A:SetCategory, C:SetCategory): MPcat == MPdef where NNI ==> NonNegativeInteger @@ -57015,7 +57203,9 @@ o )help MappingPackage4 <>= )abbrev package MAPPKG3 MappingPackage3 -++ Description: various Currying operations. +++ Description: +++ Various Currying operations. + MappingPackage3(A:SetCategory, B:SetCategory, C:SetCategory):_ MPcat == MPdef where NNI ==> NonNegativeInteger @@ -57348,8 +57538,10 @@ o )help MappingPackage4 <>= )abbrev package MAPPKG4 MappingPackage4 ++ Author: Timothy Daly -++ Description: Functional Composition +++ Description: +++ Functional Composition. ++ Given functions f and g, returns the applicable closure + MappingPackage4(A:SetCategory, B:Ring): with "+": (A->B, A->B) -> (A->B) @@ -57433,8 +57625,9 @@ MappingPackage4(A:SetCategory, B:Ring): ++ Examples: ++ References: ++ Description: -++ \spadtype{MatrixCategoryFunctions2} provides functions between two matrix -++ domains. The functions provided are \spadfun{map} and \spadfun{reduce}. +++ \spadtype{MatrixCategoryFunctions2} provides functions between two matrix +++ domains. The functions provided are \spadfun{map} and \spadfun{reduce}. + MatrixCategoryFunctions2(R1,Row1,Col1,M1,R2,Row2,Col2,M2):_ Exports == Implementation where R1 : Ring @@ -57504,14 +57697,15 @@ MatrixCategoryFunctions2(R1,Row1,Col1,M1,R2,Row2,Col2,M2):_ <>= )abbrev package MCDEN MatrixCommonDenominator ---% MatrixCommonDenominator ++ Author: Manuel Bronstein ++ Date Created: 2 May 1988 ++ Date Last Updated: 20 Jul 1990 -++ Description: MatrixCommonDenominator provides functions to +++ Keywords: gcd, quotient, matrix, common, denominator. +++ Description: +++ MatrixCommonDenominator provides functions to ++ compute the common denominator of a matrix of elements of the ++ quotient field of an integral domain. -++ Keywords: gcd, quotient, matrix, common, denominator. + MatrixCommonDenominator(R, Q): Exports == Implementation where R: IntegralDomain Q: QuotientFieldCategory R @@ -57591,8 +57785,9 @@ MatrixCommonDenominator(R, Q): Exports == Implementation where ++ Examples: ++ References: ++ Description: -++ \spadtype{MatrixLinearAlgebraFunctions} provides functions to compute -++ inverses and canonical forms. +++ \spadtype{MatrixLinearAlgebraFunctions} provides functions to compute +++ inverses and canonical forms. + MatrixLinearAlgebraFunctions(R,Row,Col,M):Exports == Implementation where R : CommutativeRing Row : FiniteLinearAggregate R @@ -57925,12 +58120,14 @@ MatrixLinearAlgebraFunctions(R,Row,Col,M):Exports == Implementation where <>= )abbrev package MTHING MergeThing +++ Description: ++ This package exports tools for merging lists + MergeThing(S:OrderedSet): Exports == Implementation where Exports == with mergeDifference: (List(S),List(S)) -> List(S) - ++ mergeDifference(l1,l2) returns a list of elements in l1 not present - ++ in l2. Assumes lists are ordered and all x in l2 are also in l1. + ++ mergeDifference(l1,l2) returns a list of elements in l1 not present + ++ in l2. Assumes lists are ordered and all x in l2 are also in l1. Implementation == add mergeDifference1: (List S,S,List S) -> List S mergeDifference(x,y) == @@ -57976,13 +58173,15 @@ MergeThing(S:OrderedSet): Exports == Implementation where <>= )abbrev package MESH MeshCreationRoutinesForThreeDimensions -++ ++ Author: Jim Wen ++ Date Created: ?? ++ Date Last Updated: October 1991 by Jon Steinbach ++ Keywords: ++ Examples: ++ References: +++ Description: +++ This package has no description + MeshCreationRoutinesForThreeDimensions():Exports == Implementation where I ==> Integer @@ -58005,15 +58204,15 @@ MeshCreationRoutinesForThreeDimensions():Exports == Implementation where Exports ==> with meshPar2Var: (Fn2,Fn2,Fn2,FnU,SEG SF,SEG SF,L DROP) -> SPACE3 - ++ meshPar2Var(f,g,h,j,s1,s2,l) \undocumented + ++ meshPar2Var(f,g,h,j,s1,s2,l) \undocumented meshPar2Var: (FnPt,SEG SF,SEG SF,L DROP) -> SPACE3 - ++ meshPar2Var(f,s1,s2,l) \undocumented + ++ meshPar2Var(f,s1,s2,l) \undocumented meshPar2Var: (SPACE3,FnPt,SEG SF,SEG SF,L DROP) -> SPACE3 - ++ meshPar2Var(sp,f,s1,s2,l) \undocumented + ++ meshPar2Var(sp,f,s1,s2,l) \undocumented meshFun2Var: (Fn2,FnU,SEG SF,SEG SF,L DROP) -> SPACE3 - ++ meshFun2Var(f,g,s1,s2,l) \undocumented + ++ meshFun2Var(f,g,s1,s2,l) \undocumented meshPar1Var: (EX I,EX I,EX I,Fn1,SEG SF,L DROP) -> SPACE3 - ++ meshPar1Var(s,t,u,f,s1,l) \undocumented + ++ meshPar1Var(s,t,u,f,s1,l) \undocumented ptFunc: (Fn2,Fn2,Fn2,Fn3) -> ((SF,SF) -> POINT) ++ ptFunc(a,b,c,d) is an internal function exported in ++ order to compile packages. @@ -58181,8 +58380,7 @@ ModularDistinctDegreeFactorizer(U):C == T where ++ polynomial f is assumed to be square-free modulo p. separateFactors:(UDDList,I) -> L U ++ separateFactors(ddl, p) refines the distinct degree factorization - ++ produced by \spadfunFrom{ddFact}{ModularDistinctDegreeFactorizer} - ++ to give a complete list of factors. + ++ produced by ddFact to give a complete list of factors. exptMod:(U,I,U,I) -> U ++ exptMod(f,n,g,p) raises the univariate polynomial f to the nth ++ power modulo the polynomial g and the prime p. @@ -58381,12 +58579,14 @@ ModularDistinctDegreeFactorizer(U):C == T where <>= )abbrev package MHROWRED ModularHermitianRowReduction -++ Modular hermitian row reduction. ++ Author: Manuel Bronstein ++ Date Created: 22 February 1989 ++ Date Last Updated: 24 November 1993 ++ Keywords: matrix, reduction. +++ Description: +++ Modular hermitian row reduction. -- should be moved into matrix whenever possible + ModularHermitianRowReduction(R): Exports == Implementation where R: EuclideanDomain @@ -58646,8 +58846,9 @@ ModularHermitianRowReduction(R): Exports == Implementation where ++ Keywords: monoid ring, group ring, change of coefficient domain ++ References: ++ Description: -++ MonoidRingFunctions2 implements functions between -++ two monoid rings defined with the same monoid over different rings. +++ MonoidRingFunctions2 implements functions between +++ two monoid rings defined with the same monoid over different rings. + MonoidRingFunctions2(R,S,M) : Exports == Implementation where R : Ring S : Ring @@ -58688,11 +58889,12 @@ MonoidRingFunctions2(R,S,M) : Exports == Implementation where <>= )abbrev package MONOTOOL MonomialExtensionTools -++ Tools for handling monomial extensions ++ Author: Manuel Bronstein ++ Date Created: 18 August 1992 ++ Date Last Updated: 3 June 1993 -++ Description: Tools for handling monomial extensions. +++ Description: +++ Tools for handling monomial extensions. + MonomialExtensionTools(F, UP): Exports == Implementation where F : Field UP: UnivariatePolynomialCategory F @@ -58783,10 +58985,10 @@ MonomialExtensionTools(F, UP): Exports == Implementation where ++ AMS Classification: ++ Keywords: command ++ Description: -++ \spadtype{MoreSystemCommands} implements an interface with the -++ system command facility. These are the commands that are issued -++ from source files or the system interpreter and they start with -++ a close parenthesis, e.g., \spadsyscom{what} commands. +++ \spadtype{MoreSystemCommands} implements an interface with the +++ system command facility. These are the commands that are issued +++ from source files or the system interpreter and they start with +++ a close parenthesis, e.g., the "what" commands. MoreSystemCommands: public == private where @@ -58829,7 +59031,7 @@ MoreSystemCommands: public == private where ++ Keywords: ++ References: ++ Description: -++ This package exports a factor operation for multivariate polynomials +++ This package exports a factor operation for multivariate polynomials ++ with coefficients which are polynomials over ++ some ring R over which we can factor. It is used internally by packages ++ such as the solve package which need to work with polynomials in a specific @@ -58912,7 +59114,7 @@ MPolyCatPolyFactorizer(E,OV,R,PPR) : C == T ++ Keywords: ++ References: ++ Description: -++ This package exports a factor operation for multivariate polynomials +++ This package exports a factor operation for multivariate polynomials ++ with coefficients which are rational functions over ++ some ring R over which we can factor. It is used internally by packages ++ such as primary decomposition which need to work with polynomials @@ -59066,10 +59268,12 @@ MPolyCatRationalFunctionFactorizer(E,OV,R,PRF) : C == T <>= )abbrev package MPC2 MPolyCatFunctions2 -++ Utilities for MPolyCat ++ Author: Manuel Bronstein ++ Date Created: 1987 ++ Date Last Updated: 28 March 1990 (PG) +++ Description: +++ Utilities for MPolyCat + MPolyCatFunctions2(VarSet,E1,E2,R,S,PR,PS) : public == private where VarSet : OrderedSet @@ -59084,9 +59288,9 @@ MPolyCatFunctions2(VarSet,E1,E2,R,S,PR,PS) : public == private where public == with map: (R -> S,PR) -> PS - ++ map(f,p) \undocumented + ++ map(f,p) \undocumented reshape: (List S, PR) -> PS - ++ reshape(l,p) \undocumented + ++ reshape(l,p) \undocumented private == add @@ -59123,7 +59327,8 @@ MPolyCatFunctions2(VarSet,E1,E2,R,S,PR,PS) : public == private where <>= )abbrev package MPC3 MPolyCatFunctions3 ++ Description: -++ This package \undocumented +++ This package has no description + MPolyCatFunctions3(Vars1,Vars2,E1,E2,R,PR1,PR2): C == T where E1 : OrderedAbelianMonoidSup E2 : OrderedAbelianMonoidSup @@ -59135,7 +59340,7 @@ MPolyCatFunctions3(Vars1,Vars2,E1,E2,R,PR1,PR2): C == T where C ==> with map: (Vars1 -> Vars2, PR1) -> PR2 - ++ map(f,x) \undocumented + ++ map(f,x) \undocumented T ==> add @@ -59177,11 +59382,11 @@ MPolyCatFunctions3(Vars1,Vars2,E1,E2,R,PR1,PR2): C == T where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: MRationalFactorize contains the factor function for multivariate +++ Description: +++ MRationalFactorize contains the factor function for multivariate ++ polynomials over the quotient field of a ring R such that the package ++ MultivariateFactorize can factor multivariate polynomials over R. - MRationalFactorize(E,OV,R,P) : C == T where E : OrderedAbelianMonoidSup @@ -59244,9 +59449,8 @@ MRationalFactorize(E,OV,R,P) : C == T ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: Package for factorization of multivariate polynomials -++ over finite fields. - +++ Description: +++ Package for factorization of multivariate polynomials over finite fields. MultFiniteFactorize(OV,E,F,PG) : C == T where @@ -59743,11 +59947,12 @@ MultFiniteFactorize(OV,E,F,PG) : C == T <>= )abbrev package MMAP MultipleMap -++ Lifting a map through 2 levels of polynomials ++ Author: Manuel Bronstein ++ Date Created: May 1988 ++ Date Last Updated: 11 Jul 1990 -++ Description: Lifting of a map through 2 levels of polynomials; +++ Description: +++ Lifting of a map through 2 levels of polynomials; + MultipleMap(R1,UP1,UPUP1,R2,UP2,UPUP2): Exports == Implementation where R1 : IntegralDomain UP1 : UnivariatePolynomialCategory R1 @@ -59809,12 +60014,11 @@ MultipleMap(R1,UP1,UPUP1,R2,UP2,UPUP2): Exports == Implementation where ++ Keywords: ++ References: ++ Description: -++ \spadtype{MultiVariableCalculusFunctions} Package provides several -++ functions for multivariable calculus. -++ These include gradient, hessian and jacobian, -++ divergence and laplacian. -++ Various forms for banded and sparse storage of matrices are -++ included. +++ \spadtype{MultiVariableCalculusFunctions} Package provides several +++ functions for multivariable calculus. +++ These include gradient, hessian and jacobian, divergence and laplacian. +++ Various forms for banded and sparse storage of matrices are included. + MultiVariableCalculusFunctions(S,F,FLAF,FLAS) : Exports == Implementation where PI ==> PositiveInteger NNI ==> NonNegativeInteger @@ -59985,7 +60189,7 @@ MultiVariableCalculusFunctions(S,F,FLAF,FLAS) : Exports == Implementation where ++ Keywords: ++ References: ++ Description: -++ This is the top level package for doing multivariate factorization +++ This is the top level package for doing multivariate factorization ++ over basic domains like \spadtype{Integer} or \spadtype{Fraction Integer}. MultivariateFactorize(OV,E,R,P) : C == T @@ -60062,12 +60266,12 @@ MultivariateLifting(E,OV,R,P) : C == T C == with corrPoly: (SUP,L OV,L R,L NNI,L SUP,Table,R) -> Union(L SUP,"failed") - ++ corrPoly(u,lv,lr,ln,lu,t,r) \undocumented + ++ corrPoly(u,lv,lr,ln,lu,t,r) \undocumented lifting: (SUP,L OV,L BP,L R,L P,L NNI,R) -> Union(L SUP,"failed") - ++ lifting(u,lv,lu,lr,lp,ln,r) \undocumented + ++ lifting(u,lv,lu,lr,lp,ln,r) \undocumented lifting1: (SUP,L OV,L SUP,L R,L P,L VTerm,L NNI,Table,R) -> Union(L SUP,"failed") - ++ lifting1(u,lv,lu,lr,lp,lt,ln,t,r) \undocumented + ++ lifting1(u,lv,lu,lr,lp,lt,ln,t,r) \undocumented T == add GenExEuclid(R,BP) @@ -60287,6 +60491,7 @@ MultivariateLifting(E,OV,R,P) : C == T <>= )abbrev package MULTSQFR MultivariateSquareFree ++ Author : P.Gianni +++ Description: ++ This package provides the functions for the computation of the square ++ free decomposition of a multivariate polynomial. ++ It uses the package GenExEuclid for the resolution of @@ -60332,25 +60537,25 @@ MultivariateSquareFree (E,OV,R,P) : C == T where ---- local functions ---- compdegd : List FFE -> Z - ++ compdegd should be local + ++ compdegd should be local univcase : (P,OV) -> Factored(P) - ++ univcase should be local + ++ univcase should be local consnewpol : (SUP,BP,Z) -> Twopol - ++ consnewpol should be local + ++ consnewpol should be local nsqfree : (SUP,List(OV), List List R) -> squareForm - ++ nsqfree should be local + ++ nsqfree should be local intChoose : (SUP,List(OV),List List R) -> Choice - ++ intChoose should be local + ++ intChoose should be local coefChoose : (Z,Factored P) -> P - ++ coefChoose should be local + ++ coefChoose should be local check : (List(FFE),List(FFE)) -> Boolean - ++ check should be local - lift : (SUP,BP,BP,P,List(OV),List(NNI),List(R)) -> Union(List(SUP),"failed") - ++ lift should be local + ++ check should be local + lift : (SUP,BP,BP,P,List(OV),List(NNI),List(R)) -> Union(List(SUP),"failed") + ++ lift should be local myDegree : (SUP,List OV,NNI) -> List NNI - ++ myDegree should be local + ++ myDegree should be local normDeriv2 : (BP,Z) -> BP - ++ normDeriv2 should be local + ++ normDeriv2 should be local @@ -63963,14 +64168,11 @@ MultivariateSquareFree (E,OV,R,P) : C == T where ++ Date Created: Jan 1994 ++ Date Last Updated: Thu May 12 17:45:20 1994 ++ Description: -++ This package uses the NAG Library to compute -++ \begin{items} -++ \item eigenvalues and eigenvectors of a matrix -++ \item eigenvalues and eigenvectors of generalized matrix -++ eigenvalue problems -++ \item singular values and singular vectors of a matrix. -++ \end{items} -++ See \downlink{Manual Page}{manpageXXf02}. +++ This package uses the NAG Library to compute\br +++ \tab{5}eigenvalues and eigenvectors of a matrix\br +++ \tab{5} eigenvalues and eigenvectors of generalized matrix +++ eigenvalue problems\br +++ \tab{5}singular values and singular vectors of a matrix. NagEigenPackage(): Exports == Implementation where S ==> Symbol @@ -63981,21 +64183,20 @@ NagEigenPackage(): Exports == Implementation where ++ f02aaf(ia,n,a,ifail) ++ calculates all the eigenvalue. ++ See \downlink{Manual Page}{manpageXXf02aaf}. - f02abf : (Matrix DoubleFloat,Integer,Integer,Integer,_ - Integer) -> Result + f02abf : (Matrix DoubleFloat,Integer,Integer,Integer,Integer) -> Result ++ f02abf(a,ia,n,iv,ifail) ++ calculates all the eigenvalues of a real ++ symmetric matrix. ++ See \downlink{Manual Page}{manpageXXf02abf}. f02adf : (Integer,Integer,Integer,Matrix DoubleFloat,_ - Matrix DoubleFloat,Integer) -> Result + Matrix DoubleFloat,Integer) -> Result ++ f02adf(ia,ib,n,a,b,ifail) ++ calculates all the eigenvalues of Ax=(lambda)Bx, where A ++ is a real symmetric matrix and B is a real symmetric positive- ++ definite matrix. ++ See \downlink{Manual Page}{manpageXXf02adf}. f02aef : (Integer,Integer,Integer,Integer,_ - Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result + Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result ++ f02aef(ia,ib,n,iv,a,b,ifail) ++ calculates all the eigenvalues of ++ Ax=(lambda)Bx, where A is a real symmetric matrix and B is a @@ -64007,36 +64208,36 @@ NagEigenPackage(): Exports == Implementation where ++ matrix. ++ See \downlink{Manual Page}{manpageXXf02aff}. f02agf : (Integer,Integer,Integer,Integer,_ - Matrix DoubleFloat,Integer) -> Result + Matrix DoubleFloat,Integer) -> Result ++ f02agf(ia,n,ivr,ivi,a,ifail) ++ calculates all the eigenvalues of a real ++ unsymmetric matrix. ++ See \downlink{Manual Page}{manpageXXf02agf}. f02ajf : (Integer,Integer,Integer,Matrix DoubleFloat,_ - Matrix DoubleFloat,Integer) -> Result + Matrix DoubleFloat,Integer) -> Result ++ f02ajf(iar,iai,n,ar,ai,ifail) ++ calculates all the eigenvalue. ++ See \downlink{Manual Page}{manpageXXf02ajf}. f02akf : (Integer,Integer,Integer,Integer,_ - Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result + Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result ++ f02akf(iar,iai,n,ivr,ivi,ar,ai,ifail) ++ calculates all the eigenvalues of a ++ complex matrix. ++ See \downlink{Manual Page}{manpageXXf02akf}. f02awf : (Integer,Integer,Integer,Matrix DoubleFloat,_ - Matrix DoubleFloat,Integer) -> Result + Matrix DoubleFloat,Integer) -> Result ++ f02awf(iar,iai,n,ar,ai,ifail) ++ calculates all the eigenvalues of a complex Hermitian ++ matrix. ++ See \downlink{Manual Page}{manpageXXf02awf}. f02axf : (Matrix DoubleFloat,Integer,Matrix DoubleFloat,Integer,_ - Integer,Integer,Integer,Integer) -> Result + Integer,Integer,Integer,Integer) -> Result ++ f02axf(ar,iar,ai,iai,n,ivr,ivi,ifail) ++ calculates all the eigenvalues of a ++ complex Hermitian matrix. ++ See \downlink{Manual Page}{manpageXXf02axf}. f02bbf : (Integer,Integer,DoubleFloat,DoubleFloat,_ - Integer,Integer,Matrix DoubleFloat,Integer) -> Result + Integer,Integer,Matrix DoubleFloat,Integer) -> Result ++ f02bbf(ia,n,alb,ub,m,iv,a,ifail) ++ calculates selected eigenvalues of a real ++ symmetric matrix by reduction to tridiagonal form, bisection and @@ -64044,32 +64245,40 @@ NagEigenPackage(): Exports == Implementation where ++ given interval. ++ See \downlink{Manual Page}{manpageXXf02bbf}. f02bjf : (Integer,Integer,Integer,DoubleFloat,_ - Boolean,Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result + Boolean,Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result ++ f02bjf(n,ia,ib,eps1,matv,iv,a,b,ifail) ++ calculates all the eigenvalues and, if required, all the ++ eigenvectors of the generalized eigenproblem Ax=(lambda)Bx ++ where A and B are real, square matrices, using the QZ algorithm. ++ See \downlink{Manual Page}{manpageXXf02bjf}. f02fjf : (Integer,Integer,DoubleFloat,Integer,_ - Integer,Integer,Integer,Integer,Integer,Integer,Matrix DoubleFloat,Integer,Union(fn:FileName,fp:Asp27(DOT)),Union(fn:FileName,fp:Asp28(IMAGE))) -> Result - ++ f02fjf(n,k,tol,novecs,nrx,lwork,lrwork,liwork,m,noits,x,ifail,dot,image) + Integer,Integer,Integer,Integer,Integer,Integer,Matrix DoubleFloat,_ + Integer,Union(fn:FileName,fp:Asp27(DOT)),_ + Union(fn:FileName,fp:Asp28(IMAGE))) -> Result + ++ f02fjf(n,k,tol,novecs,nrx,lwork,lrwork, + ++ liwork,m,noits,x,ifail,dot,image) ++ finds eigenvalues of a real sparse symmetric ++ or generalized symmetric eigenvalue problem. ++ See \downlink{Manual Page}{manpageXXf02fjf}. f02fjf : (Integer,Integer,DoubleFloat,Integer,_ - Integer,Integer,Integer,Integer,Integer,Integer,Matrix DoubleFloat,Integer,Union(fn:FileName,fp:Asp27(DOT)),Union(fn:FileName,fp:Asp28(IMAGE)),FileName) -> Result - ++ f02fjf(n,k,tol,novecs,nrx,lwork,lrwork,liwork,m,noits,x,ifail,dot,image,monit) + Integer,Integer,Integer,Integer,Integer,Integer,Matrix DoubleFloat,_ + Integer,Union(fn:FileName,fp:Asp27(DOT)),_ + Union(fn:FileName,fp:Asp28(IMAGE)),FileName) -> Result + ++ f02fjf(n,k,tol,novecs,nrx,lwork,lrwork, + ++ liwork,m,noits,x,ifail,dot,image,monit) ++ finds eigenvalues of a real sparse symmetric ++ or generalized symmetric eigenvalue problem. ++ See \downlink{Manual Page}{manpageXXf02fjf}. f02wef : (Integer,Integer,Integer,Integer,_ - Integer,Boolean,Integer,Boolean,Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result + Integer,Boolean,Integer,Boolean,Integer,Matrix DoubleFloat,_ + Matrix DoubleFloat,Integer) -> Result ++ f02wef(m,n,lda,ncolb,ldb,wantq,ldq,wantp,ldpt,a,b,ifail) ++ returns all, or part, of the singular value decomposition ++ of a general real matrix. ++ See \downlink{Manual Page}{manpageXXf02wef}. f02xef : (Integer,Integer,Integer,Integer,_ - Integer,Boolean,Integer,Boolean,Integer,Matrix Complex DoubleFloat,Matrix Complex DoubleFloat,Integer) -> Result + Integer,Boolean,Integer,Boolean,Integer,Matrix Complex DoubleFloat,_ + Matrix Complex DoubleFloat,Integer) -> Result ++ f02xef(m,n,lda,ncolb,ldb,wantq,ldq,wantp,ldph,a,b,ifail) ++ returns all, or part, of the singular value decomposition ++ of a general complex matrix. @@ -64093,299 +64302,341 @@ NagEigenPackage(): Exports == Implementation where f02aaf(iaArg:Integer,nArg:Integer,aArg:Matrix DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f02aaf",_ - ["ia"::S,"n"::S,"ifail"::S,"r"::S,"a"::S,"e"::S]$Lisp,_ - ["r"::S,"e"::S]$Lisp,_ - [["double"::S,["r"::S,"n"::S]$Lisp,["a"::S,"ia"::S,"n"::S]$Lisp_ - ,["e"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"ia"::S,"n"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["r"::S,"a"::S,"ifail"::S]$Lisp,_ - [([iaArg::Any,nArg::Any,ifailArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f02aaf",_ + ["ia"::S,"n"::S,"ifail"::S,"r"::S,"a"::S,"e"::S]$Lisp,_ + ["r"::S,"e"::S]$Lisp,_ + [["double"::S,["r"::S,"n"::S]$Lisp,["a"::S,"ia"::S,"n"::S]$Lisp_ + ,["e"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"ia"::S,"n"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["r"::S,"a"::S,"ifail"::S]$Lisp,_ + [([iaArg::Any,nArg::Any,ifailArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f02abf(aArg:Matrix DoubleFloat,iaArg:Integer,nArg:Integer,_ - ivArg:Integer,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f02abf",_ - ["ia"::S,"n"::S,"iv"::S,"ifail"::S,"a"::S,"r"::S,"v"::S,"e"::S]$Lisp,_ - ["r"::S,"v"::S,"e"::S]$Lisp,_ - [["double"::S,["a"::S,"ia"::S,"n"::S]$Lisp_ - ,["r"::S,"n"::S]$Lisp,["v"::S,"iv"::S,"n"::S]$Lisp,["e"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"ia"::S,"n"::S,"iv"::S,"ifail"::S_ - ]$Lisp_ - ]$Lisp,_ - ["r"::S,"v"::S,"ifail"::S]$Lisp,_ - [([iaArg::Any,nArg::Any,ivArg::Any,ifailArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ivArg:Integer,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f02abf",_ + ["ia"::S,"n"::S,"iv"::S,"ifail"::S,"a"::S,"r"::S,"v"::S,"e"::S]$Lisp,_ + ["r"::S,"v"::S,"e"::S]$Lisp,_ + [["double"::S,["a"::S,"ia"::S,"n"::S]$Lisp_ + ,["r"::S,"n"::S]$Lisp,["v"::S,"iv"::S,"n"::S]$Lisp,_ + ["e"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"ia"::S,"n"::S,"iv"::S,"ifail"::S_ + ]$Lisp_ + ]$Lisp,_ + ["r"::S,"v"::S,"ifail"::S]$Lisp,_ + [([iaArg::Any,nArg::Any,ivArg::Any,ifailArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f02adf(iaArg:Integer,ibArg:Integer,nArg:Integer,_ - aArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f02adf",_ - ["ia"::S,"ib"::S,"n"::S,"ifail"::S,"r"::S,"a"::S,"b"::S,"de"::S]$Lisp,_ - ["r"::S,"de"::S]$Lisp,_ - [["double"::S,["r"::S,"n"::S]$Lisp,["a"::S,"ia"::S,"n"::S]$Lisp_ - ,["b"::S,"ib"::S,"n"::S]$Lisp,["de"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"ia"::S,"ib"::S,"n"::S,"ifail"::S_ - ]$Lisp_ - ]$Lisp,_ - ["r"::S,"a"::S,"b"::S,"ifail"::S]$Lisp,_ - [([iaArg::Any,ibArg::Any,nArg::Any,ifailArg::Any,aArg::Any,bArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + aArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f02adf",_ + ["ia"::S,"ib"::S,"n"::S,"ifail"::S,"r"::S,"a"::S,"b"::S,"de"::S]$Lisp,_ + ["r"::S,"de"::S]$Lisp,_ + [["double"::S,["r"::S,"n"::S]$Lisp,["a"::S,"ia"::S,"n"::S]$Lisp_ + ,["b"::S,"ib"::S,"n"::S]$Lisp,["de"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"ia"::S,"ib"::S,"n"::S,"ifail"::S_ + ]$Lisp_ + ]$Lisp,_ + ["r"::S,"a"::S,"b"::S,"ifail"::S]$Lisp,_ + [([iaArg::Any,ibArg::Any,nArg::Any,ifailArg::Any,aArg::Any,bArg::Any])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f02aef(iaArg:Integer,ibArg:Integer,nArg:Integer,_ - ivArg:Integer,aArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f02aef",_ - ["ia"::S,"ib"::S,"n"::S,"iv"::S,"ifail"::S_ - ,"r"::S,"v"::S,"a"::S,"b"::S,"dl"::S_ - ,"e"::S]$Lisp,_ - ["r"::S,"v"::S,"dl"::S,"e"::S]$Lisp,_ - [["double"::S,["r"::S,"n"::S]$Lisp,["v"::S,"iv"::S,"n"::S]$Lisp_ - ,["a"::S,"ia"::S,"n"::S]$Lisp,["b"::S,"ib"::S,"n"::S]$Lisp,["dl"::S,"n"::S]$Lisp,["e"::S,"n"::S]$Lisp_ - ]$Lisp_ - ,["integer"::S,"ia"::S,"ib"::S,"n"::S,"iv"::S_ - ,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["r"::S,"v"::S,"a"::S,"b"::S,"ifail"::S]$Lisp,_ - [([iaArg::Any,ibArg::Any,nArg::Any,ivArg::Any,ifailArg::Any,aArg::Any,bArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ivArg:Integer,aArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f02aef",_ + ["ia"::S,"ib"::S,"n"::S,"iv"::S,"ifail"::S_ + ,"r"::S,"v"::S,"a"::S,"b"::S,"dl"::S_ + ,"e"::S]$Lisp,_ + ["r"::S,"v"::S,"dl"::S,"e"::S]$Lisp,_ + [["double"::S,["r"::S,"n"::S]$Lisp,["v"::S,"iv"::S,"n"::S]$Lisp_ + ,["a"::S,"ia"::S,"n"::S]$Lisp,["b"::S,"ib"::S,"n"::S]$Lisp,_ + ["dl"::S,"n"::S]$Lisp,["e"::S,"n"::S]$Lisp_ + ]$Lisp_ + ,["integer"::S,"ia"::S,"ib"::S,"n"::S,"iv"::S_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["r"::S,"v"::S,"a"::S,"b"::S,"ifail"::S]$Lisp,_ + [([iaArg::Any,ibArg::Any,nArg::Any,ivArg::Any,_ + ifailArg::Any,aArg::Any,bArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f02aff(iaArg:Integer,nArg:Integer,aArg:Matrix DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f02aff",_ - ["ia"::S,"n"::S,"ifail"::S,"rr"::S,"ri"::S,"intger"::S,"a"::S]$Lisp,_ - ["rr"::S,"ri"::S,"intger"::S]$Lisp,_ - [["double"::S,["rr"::S,"n"::S]$Lisp,["ri"::S,"n"::S]$Lisp_ - ,["a"::S,"ia"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"ia"::S,"n"::S,["intger"::S,"n"::S]$Lisp_ - ,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["rr"::S,"ri"::S,"intger"::S,"a"::S,"ifail"::S]$Lisp,_ - [([iaArg::Any,nArg::Any,ifailArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f02aff",_ + ["ia"::S,"n"::S,"ifail"::S,"rr"::S,"ri"::S,"intger"::S,"a"::S]$Lisp,_ + ["rr"::S,"ri"::S,"intger"::S]$Lisp,_ + [["double"::S,["rr"::S,"n"::S]$Lisp,["ri"::S,"n"::S]$Lisp_ + ,["a"::S,"ia"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"ia"::S,"n"::S,["intger"::S,"n"::S]$Lisp_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["rr"::S,"ri"::S,"intger"::S,"a"::S,"ifail"::S]$Lisp,_ + [([iaArg::Any,nArg::Any,ifailArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f02agf(iaArg:Integer,nArg:Integer,ivrArg:Integer,_ - iviArg:Integer,aArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f02agf",_ - ["ia"::S,"n"::S,"ivr"::S,"ivi"::S,"ifail"::S_ - ,"rr"::S,"ri"::S,"vr"::S,"vi"::S,"intger"::S_ - ,"a"::S]$Lisp,_ - ["rr"::S,"ri"::S,"vr"::S,"vi"::S,"intger"::S]$Lisp,_ - [["double"::S,["rr"::S,"n"::S]$Lisp,["ri"::S,"n"::S]$Lisp_ - ,["vr"::S,"ivr"::S,"n"::S]$Lisp,["vi"::S,"ivi"::S,"n"::S]$Lisp,["a"::S,"ia"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"ia"::S,"n"::S,"ivr"::S,"ivi"::S_ - ,["intger"::S,"n"::S]$Lisp,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["rr"::S,"ri"::S,"vr"::S,"vi"::S,"intger"::S,"a"::S,"ifail"::S]$Lisp,_ - [([iaArg::Any,nArg::Any,ivrArg::Any,iviArg::Any,ifailArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + iviArg:Integer,aArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f02agf",_ + ["ia"::S,"n"::S,"ivr"::S,"ivi"::S,"ifail"::S_ + ,"rr"::S,"ri"::S,"vr"::S,"vi"::S,"intger"::S_ + ,"a"::S]$Lisp,_ + ["rr"::S,"ri"::S,"vr"::S,"vi"::S,"intger"::S]$Lisp,_ + [["double"::S,["rr"::S,"n"::S]$Lisp,["ri"::S,"n"::S]$Lisp_ + ,["vr"::S,"ivr"::S,"n"::S]$Lisp,["vi"::S,"ivi"::S,"n"::S]$Lisp,_ + ["a"::S,"ia"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"ia"::S,"n"::S,"ivr"::S,"ivi"::S_ + ,["intger"::S,"n"::S]$Lisp,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["rr"::S,"ri"::S,"vr"::S,"vi"::S,"intger"::S,"a"::S,"ifail"::S]$Lisp,_ + [([iaArg::Any,nArg::Any,ivrArg::Any,iviArg::Any,_ + ifailArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f02ajf(iarArg:Integer,iaiArg:Integer,nArg:Integer,_ - arArg:Matrix DoubleFloat,aiArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f02ajf",_ - ["iar"::S,"iai"::S,"n"::S,"ifail"::S,"rr"::S,"ri"::S,"ar"::S,"ai"::S,"intger"::S_ - ]$Lisp,_ - ["rr"::S,"ri"::S,"intger"::S]$Lisp,_ - [["double"::S,["rr"::S,"n"::S]$Lisp,["ri"::S,"n"::S]$Lisp_ - ,["ar"::S,"iar"::S,"n"::S]$Lisp,["ai"::S,"iai"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"iar"::S,"iai"::S,"n"::S,"ifail"::S_ - ,["intger"::S,"n"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["rr"::S,"ri"::S,"ar"::S,"ai"::S,"ifail"::S]$Lisp,_ - [([iarArg::Any,iaiArg::Any,nArg::Any,ifailArg::Any,arArg::Any,aiArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + arArg:Matrix DoubleFloat,aiArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f02ajf",_ + ["iar"::S,"iai"::S,"n"::S,"ifail"::S,"rr"::S,"ri"::S,_ + "ar"::S,"ai"::S,"intger"::S_ + ]$Lisp,_ + ["rr"::S,"ri"::S,"intger"::S]$Lisp,_ + [["double"::S,["rr"::S,"n"::S]$Lisp,["ri"::S,"n"::S]$Lisp_ + ,["ar"::S,"iar"::S,"n"::S]$Lisp,["ai"::S,"iai"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"iar"::S,"iai"::S,"n"::S,"ifail"::S_ + ,["intger"::S,"n"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["rr"::S,"ri"::S,"ar"::S,"ai"::S,"ifail"::S]$Lisp,_ + [([iarArg::Any,iaiArg::Any,nArg::Any,ifailArg::Any,_ + arArg::Any,aiArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f02akf(iarArg:Integer,iaiArg:Integer,nArg:Integer,_ - ivrArg:Integer,iviArg:Integer,arArg:Matrix DoubleFloat,_ - aiArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f02akf",_ - ["iar"::S,"iai"::S,"n"::S,"ivr"::S,"ivi"::S_ - ,"ifail"::S,"rr"::S,"ri"::S,"vr"::S,"vi"::S,"ar"::S_ - ,"ai"::S,"intger"::S]$Lisp,_ - ["rr"::S,"ri"::S,"vr"::S,"vi"::S,"intger"::S]$Lisp,_ - [["double"::S,["rr"::S,"n"::S]$Lisp,["ri"::S,"n"::S]$Lisp_ - ,["vr"::S,"ivr"::S,"n"::S]$Lisp,["vi"::S,"ivi"::S,"n"::S]$Lisp,["ar"::S,"iar"::S,"n"::S]$Lisp,["ai"::S,"iai"::S,"n"::S]$Lisp_ - ]$Lisp_ - ,["integer"::S,"iar"::S,"iai"::S,"n"::S,"ivr"::S_ - ,"ivi"::S,"ifail"::S,["intger"::S,"n"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["rr"::S,"ri"::S,"vr"::S,"vi"::S,"ar"::S,"ai"::S,"ifail"::S]$Lisp,_ - [([iarArg::Any,iaiArg::Any,nArg::Any,ivrArg::Any,iviArg::Any,ifailArg::Any,arArg::Any,aiArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ivrArg:Integer,iviArg:Integer,arArg:Matrix DoubleFloat,_ + aiArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f02akf",_ + ["iar"::S,"iai"::S,"n"::S,"ivr"::S,"ivi"::S_ + ,"ifail"::S,"rr"::S,"ri"::S,"vr"::S,"vi"::S,"ar"::S_ + ,"ai"::S,"intger"::S]$Lisp,_ + ["rr"::S,"ri"::S,"vr"::S,"vi"::S,"intger"::S]$Lisp,_ + [["double"::S,["rr"::S,"n"::S]$Lisp,["ri"::S,"n"::S]$Lisp_ + ,["vr"::S,"ivr"::S,"n"::S]$Lisp,["vi"::S,"ivi"::S,"n"::S]$Lisp,_ + ["ar"::S,"iar"::S,"n"::S]$Lisp,["ai"::S,"iai"::S,"n"::S]$Lisp_ + ]$Lisp_ + ,["integer"::S,"iar"::S,"iai"::S,"n"::S,"ivr"::S_ + ,"ivi"::S,"ifail"::S,["intger"::S,"n"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["rr"::S,"ri"::S,"vr"::S,"vi"::S,"ar"::S,"ai"::S,"ifail"::S]$Lisp,_ + [([iarArg::Any,iaiArg::Any,nArg::Any,ivrArg::Any,iviArg::Any,_ + ifailArg::Any,arArg::Any,aiArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f02awf(iarArg:Integer,iaiArg:Integer,nArg:Integer,_ - arArg:Matrix DoubleFloat,aiArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f02awf",_ - ["iar"::S,"iai"::S,"n"::S,"ifail"::S,"r"::S,"ar"::S,"ai"::S,"wk1"::S,"wk2"::S_ - ,"wk3"::S]$Lisp,_ - ["r"::S,"wk1"::S,"wk2"::S,"wk3"::S]$Lisp,_ - [["double"::S,["r"::S,"n"::S]$Lisp,["ar"::S,"iar"::S,"n"::S]$Lisp_ - ,["ai"::S,"iai"::S,"n"::S]$Lisp,["wk1"::S,"n"::S]$Lisp,["wk2"::S,"n"::S]$Lisp,["wk3"::S,"n"::S]$Lisp_ - ]$Lisp_ - ,["integer"::S,"iar"::S,"iai"::S,"n"::S,"ifail"::S_ - ]$Lisp_ - ]$Lisp,_ - ["r"::S,"ar"::S,"ai"::S,"ifail"::S]$Lisp,_ - [([iarArg::Any,iaiArg::Any,nArg::Any,ifailArg::Any,arArg::Any,aiArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + arArg:Matrix DoubleFloat,aiArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f02awf",_ + ["iar"::S,"iai"::S,"n"::S,"ifail"::S,"r"::S,"ar"::S,"ai"::S,_ + "wk1"::S,"wk2"::S_ + ,"wk3"::S]$Lisp,_ + ["r"::S,"wk1"::S,"wk2"::S,"wk3"::S]$Lisp,_ + [["double"::S,["r"::S,"n"::S]$Lisp,["ar"::S,"iar"::S,"n"::S]$Lisp_ + ,["ai"::S,"iai"::S,"n"::S]$Lisp,["wk1"::S,"n"::S]$Lisp,_ + ["wk2"::S,"n"::S]$Lisp,["wk3"::S,"n"::S]$Lisp_ + ]$Lisp_ + ,["integer"::S,"iar"::S,"iai"::S,"n"::S,"ifail"::S_ + ]$Lisp_ + ]$Lisp,_ + ["r"::S,"ar"::S,"ai"::S,"ifail"::S]$Lisp,_ + [([iarArg::Any,iaiArg::Any,nArg::Any,ifailArg::Any,arArg::Any,_ + aiArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f02axf(arArg:Matrix DoubleFloat,iarArg:Integer,aiArg:Matrix DoubleFloat,_ - iaiArg:Integer,nArg:Integer,ivrArg:Integer,_ - iviArg:Integer,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f02axf",_ - ["iar"::S,"iai"::S,"n"::S,"ivr"::S,"ivi"::S_ - ,"ifail"::S,"ar"::S,"ai"::S,"r"::S,"vr"::S,"vi"::S_ - ,"wk1"::S,"wk2"::S,"wk3"::S]$Lisp,_ - ["r"::S,"vr"::S,"vi"::S,"wk1"::S,"wk2"::S,"wk3"::S]$Lisp,_ - [["double"::S,["ar"::S,"iar"::S,"n"::S]$Lisp_ - ,["ai"::S,"iai"::S,"n"::S]$Lisp,["r"::S,"n"::S]$Lisp,["vr"::S,"ivr"::S,"n"::S]$Lisp,["vi"::S,"ivi"::S,"n"::S]$Lisp,["wk1"::S,"n"::S]$Lisp_ - ,["wk2"::S,"n"::S]$Lisp,["wk3"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"iar"::S,"iai"::S,"n"::S,"ivr"::S_ - ,"ivi"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["r"::S,"vr"::S,"vi"::S,"ifail"::S]$Lisp,_ - [([iarArg::Any,iaiArg::Any,nArg::Any,ivrArg::Any,iviArg::Any,ifailArg::Any,arArg::Any,aiArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + iaiArg:Integer,nArg:Integer,ivrArg:Integer,_ + iviArg:Integer,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f02axf",_ + ["iar"::S,"iai"::S,"n"::S,"ivr"::S,"ivi"::S_ + ,"ifail"::S,"ar"::S,"ai"::S,"r"::S,"vr"::S,"vi"::S_ + ,"wk1"::S,"wk2"::S,"wk3"::S]$Lisp,_ + ["r"::S,"vr"::S,"vi"::S,"wk1"::S,"wk2"::S,"wk3"::S]$Lisp,_ + [["double"::S,["ar"::S,"iar"::S,"n"::S]$Lisp_ + ,["ai"::S,"iai"::S,"n"::S]$Lisp,["r"::S,"n"::S]$Lisp,_ + ["vr"::S,"ivr"::S,"n"::S]$Lisp,["vi"::S,"ivi"::S,"n"::S]$Lisp,_ + ["wk1"::S,"n"::S]$Lisp_ + ,["wk2"::S,"n"::S]$Lisp,["wk3"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"iar"::S,"iai"::S,"n"::S,"ivr"::S_ + ,"ivi"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["r"::S,"vr"::S,"vi"::S,"ifail"::S]$Lisp,_ + [([iarArg::Any,iaiArg::Any,nArg::Any,ivrArg::Any,iviArg::Any,_ + ifailArg::Any,arArg::Any,aiArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f02bbf(iaArg:Integer,nArg:Integer,albArg:DoubleFloat,_ - ubArg:DoubleFloat,mArg:Integer,ivArg:Integer,_ - aArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f02bbf",_ - ["ia"::S,"n"::S,"alb"::S,"ub"::S,"m"::S_ - ,"iv"::S,"mm"::S,"ifail"::S,"r"::S,"v"::S,"icount"::S,"a"::S,"d"::S_ - ,"e"::S,"e2"::S,"x"::S,"g"::S,"c"::S_ - ]$Lisp,_ - ["mm"::S,"r"::S,"v"::S,"icount"::S,"d"::S,"e"::S,"e2"::S,"x"::S,"g"::S,"c"::S]$Lisp,_ - [["double"::S,"alb"::S,"ub"::S,["r"::S,"m"::S]$Lisp_ - ,["v"::S,"iv"::S,"m"::S]$Lisp,["a"::S,"ia"::S,"n"::S]$Lisp,["d"::S,"n"::S]$Lisp,["e"::S,"n"::S]$Lisp,["e2"::S,"n"::S]$Lisp_ - ,["x"::S,"n"::S,7$Lisp]$Lisp,["g"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"ia"::S,"n"::S,"m"::S,"iv"::S_ - ,"mm"::S,["icount"::S,"m"::S]$Lisp,"ifail"::S]$Lisp_ - ,["logical"::S,["c"::S,"n"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["mm"::S,"r"::S,"v"::S,"icount"::S,"a"::S,"ifail"::S]$Lisp,_ - [([iaArg::Any,nArg::Any,albArg::Any,ubArg::Any,mArg::Any,ivArg::Any,ifailArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ubArg:DoubleFloat,mArg:Integer,ivArg:Integer,_ + aArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f02bbf",_ + ["ia"::S,"n"::S,"alb"::S,"ub"::S,"m"::S_ + ,"iv"::S,"mm"::S,"ifail"::S,"r"::S,"v"::S,"icount"::S,"a"::S,"d"::S_ + ,"e"::S,"e2"::S,"x"::S,"g"::S,"c"::S_ + ]$Lisp,_ + ["mm"::S,"r"::S,"v"::S,"icount"::S,"d"::S,"e"::S,"e2"::S,"x"::S,_ + "g"::S,"c"::S]$Lisp,_ + [["double"::S,"alb"::S,"ub"::S,["r"::S,"m"::S]$Lisp_ + ,["v"::S,"iv"::S,"m"::S]$Lisp,["a"::S,"ia"::S,"n"::S]$Lisp,_ + ["d"::S,"n"::S]$Lisp,["e"::S,"n"::S]$Lisp,["e2"::S,"n"::S]$Lisp_ + ,["x"::S,"n"::S,7$Lisp]$Lisp,["g"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"ia"::S,"n"::S,"m"::S,"iv"::S_ + ,"mm"::S,["icount"::S,"m"::S]$Lisp,"ifail"::S]$Lisp_ + ,["logical"::S,["c"::S,"n"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["mm"::S,"r"::S,"v"::S,"icount"::S,"a"::S,"ifail"::S]$Lisp,_ + [([iaArg::Any,nArg::Any,albArg::Any,ubArg::Any,mArg::Any,_ + ivArg::Any,ifailArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f02bjf(nArg:Integer,iaArg:Integer,ibArg:Integer,_ - eps1Arg:DoubleFloat,matvArg:Boolean,ivArg:Integer,_ - aArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f02bjf",_ - ["n"::S,"ia"::S,"ib"::S,"eps1"::S,"matv"::S_ - ,"iv"::S,"ifail"::S,"alfr"::S,"alfi"::S,"beta"::S,"v"::S,"iter"::S_ - ,"a"::S,"b"::S]$Lisp,_ - ["alfr"::S,"alfi"::S,"beta"::S,"v"::S,"iter"::S]$Lisp,_ - [["double"::S,"eps1"::S,["alfr"::S,"n"::S]$Lisp_ - ,["alfi"::S,"n"::S]$Lisp,["beta"::S,"n"::S]$Lisp,["v"::S,"iv"::S,"n"::S]$Lisp,["a"::S,"ia"::S,"n"::S]$Lisp,["b"::S,"ib"::S,"n"::S]$Lisp_ - ]$Lisp_ - ,["integer"::S,"n"::S,"ia"::S,"ib"::S,"iv"::S_ - ,["iter"::S,"n"::S]$Lisp,"ifail"::S]$Lisp_ - ,["logical"::S,"matv"::S]$Lisp_ - ]$Lisp,_ - ["alfr"::S,"alfi"::S,"beta"::S,"v"::S,"iter"::S,"a"::S,"b"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,iaArg::Any,ibArg::Any,eps1Arg::Any,matvArg::Any,ivArg::Any,ifailArg::Any,aArg::Any,bArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + eps1Arg:DoubleFloat,matvArg:Boolean,ivArg:Integer,_ + aArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f02bjf",_ + ["n"::S,"ia"::S,"ib"::S,"eps1"::S,"matv"::S_ + ,"iv"::S,"ifail"::S,"alfr"::S,"alfi"::S,"beta"::S,"v"::S,"iter"::S_ + ,"a"::S,"b"::S]$Lisp,_ + ["alfr"::S,"alfi"::S,"beta"::S,"v"::S,"iter"::S]$Lisp,_ + [["double"::S,"eps1"::S,["alfr"::S,"n"::S]$Lisp_ + ,["alfi"::S,"n"::S]$Lisp,["beta"::S,"n"::S]$Lisp,_ + ["v"::S,"iv"::S,"n"::S]$Lisp,["a"::S,"ia"::S,"n"::S]$Lisp,_ + ["b"::S,"ib"::S,"n"::S]$Lisp_ + ]$Lisp_ + ,["integer"::S,"n"::S,"ia"::S,"ib"::S,"iv"::S_ + ,["iter"::S,"n"::S]$Lisp,"ifail"::S]$Lisp_ + ,["logical"::S,"matv"::S]$Lisp_ + ]$Lisp,_ + ["alfr"::S,"alfi"::S,"beta"::S,"v"::S,"iter"::S,"a"::S,"b"::S,_ + "ifail"::S]$Lisp,_ + [([nArg::Any,iaArg::Any,ibArg::Any,eps1Arg::Any,matvArg::Any,_ + ivArg::Any,ifailArg::Any,aArg::Any,bArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f02fjf(nArg:Integer,kArg:Integer,tolArg:DoubleFloat,_ - novecsArg:Integer,nrxArg:Integer,lworkArg:Integer,_ - lrworkArg:Integer,liworkArg:Integer,mArg:Integer,_ - noitsArg:Integer,xArg:Matrix DoubleFloat,ifailArg:Integer,_ - dotArg:Union(fn:FileName,fp:Asp27(DOT)),imageArg:Union(fn:FileName,fp:Asp28(IMAGE))): Result == - pushFortranOutputStack(dotFilename := aspFilename "dot")$FOP - if dotArg case fn - then outputAsFortran(dotArg.fn) - else outputAsFortran(dotArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(imageFilename := aspFilename "image")$FOP - if imageArg case fn - then outputAsFortran(imageArg.fn) - else outputAsFortran(imageArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(monitFilename := aspFilename "monit")$FOP - outputAsFortran()$Asp29(MONIT) - popFortranOutputStack()$FOP - [(invokeNagman([dotFilename,imageFilename,monitFilename]$Lisp,_ - "f02fjf",_ - ["n"::S,"k"::S,"tol"::S,"novecs"::S,"nrx"::S_ - ,"lwork"::S,"lrwork"::S,"liwork"::S,"m"::S,"noits"::S_ - ,"ifail"::S,"dot"::S,"image"::S,"monit"::S,"d"::S,"x"::S,"work"::S,"rwork"::S,"iwork"::S_ - ]$Lisp,_ - ["d"::S,"work"::S,"rwork"::S,"iwork"::S,"dot"::S,"image"::S,"monit"::S]$Lisp,_ - [["double"::S,"tol"::S,["d"::S,"k"::S]$Lisp_ - ,["x"::S,"nrx"::S,"k"::S]$Lisp,["work"::S,"lwork"::S]$Lisp,["rwork"::S,"lrwork"::S]$Lisp,"dot"::S,"image"::S,"monit"::S_ - ]$Lisp_ - ,["integer"::S,"n"::S,"k"::S,"novecs"::S,"nrx"::S_ - ,"lwork"::S,"lrwork"::S,"liwork"::S,"m"::S,"noits"::S,"ifail"::S,["iwork"::S,"liwork"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["d"::S,"m"::S,"noits"::S,"x"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,kArg::Any,tolArg::Any,novecsArg::Any,nrxArg::Any,lworkArg::Any,lrworkArg::Any,liworkArg::Any,mArg::Any,noitsArg::Any,ifailArg::Any,xArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + novecsArg:Integer,nrxArg:Integer,lworkArg:Integer,_ + lrworkArg:Integer,liworkArg:Integer,mArg:Integer,_ + noitsArg:Integer,xArg:Matrix DoubleFloat,ifailArg:Integer,_ + dotArg:Union(fn:FileName,fp:Asp27(DOT)),_ + imageArg:Union(fn:FileName,fp:Asp28(IMAGE))): Result == + pushFortranOutputStack(dotFilename := aspFilename "dot")$FOP + if dotArg case fn + then outputAsFortran(dotArg.fn) + else outputAsFortran(dotArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(imageFilename := aspFilename "image")$FOP + if imageArg case fn + then outputAsFortran(imageArg.fn) + else outputAsFortran(imageArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(monitFilename := aspFilename "monit")$FOP + outputAsFortran()$Asp29(MONIT) + popFortranOutputStack()$FOP + [(invokeNagman([dotFilename,imageFilename,monitFilename]$Lisp,_ + "f02fjf",_ + ["n"::S,"k"::S,"tol"::S,"novecs"::S,"nrx"::S_ + ,"lwork"::S,"lrwork"::S,"liwork"::S,"m"::S,"noits"::S_ + ,"ifail"::S,"dot"::S,"image"::S,"monit"::S,"d"::S,"x"::S,_ + "work"::S,"rwork"::S,"iwork"::S_ + ]$Lisp,_ + ["d"::S,"work"::S,"rwork"::S,"iwork"::S,"dot"::S,"image"::S,_ + "monit"::S]$Lisp,_ + [["double"::S,"tol"::S,["d"::S,"k"::S]$Lisp_ + ,["x"::S,"nrx"::S,"k"::S]$Lisp,["work"::S,"lwork"::S]$Lisp,_ + ["rwork"::S,"lrwork"::S]$Lisp,"dot"::S,"image"::S,"monit"::S_ + ]$Lisp_ + ,["integer"::S,"n"::S,"k"::S,"novecs"::S,"nrx"::S_ + ,"lwork"::S,"lrwork"::S,"liwork"::S,"m"::S,"noits"::S,"ifail"::S,_ + ["iwork"::S,"liwork"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["d"::S,"m"::S,"noits"::S,"x"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,kArg::Any,tolArg::Any,novecsArg::Any,nrxArg::Any,_ + lworkArg::Any,lrworkArg::Any,liworkArg::Any,mArg::Any,_ + noitsArg::Any,ifailArg::Any,xArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f02fjf(nArg:Integer,kArg:Integer,tolArg:DoubleFloat,_ - novecsArg:Integer,nrxArg:Integer,lworkArg:Integer,_ - lrworkArg:Integer,liworkArg:Integer,mArg:Integer,_ - noitsArg:Integer,xArg:Matrix DoubleFloat,ifailArg:Integer,_ - dotArg:Union(fn:FileName,fp:Asp27(DOT)),imageArg:Union(fn:FileName,fp:Asp28(IMAGE)),monitArg:FileName): Result == - pushFortranOutputStack(dotFilename := aspFilename "dot")$FOP - if dotArg case fn - then outputAsFortran(dotArg.fn) - else outputAsFortran(dotArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(imageFilename := aspFilename "image")$FOP - if imageArg case fn - then outputAsFortran(imageArg.fn) - else outputAsFortran(imageArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(monitFilename := aspFilename "monit")$FOP - outputAsFortran(monitArg) - [(invokeNagman([dotFilename,imageFilename,monitFilename]$Lisp,_ - "f02fjf",_ - ["n"::S,"k"::S,"tol"::S,"novecs"::S,"nrx"::S_ - ,"lwork"::S,"lrwork"::S,"liwork"::S,"m"::S,"noits"::S_ - ,"ifail"::S,"dot"::S,"image"::S,"monit"::S,"d"::S,"x"::S,"work"::S,"rwork"::S,"iwork"::S_ - ]$Lisp,_ - ["d"::S,"work"::S,"rwork"::S,"iwork"::S,"dot"::S,"image"::S,"monit"::S]$Lisp,_ - [["double"::S,"tol"::S,["d"::S,"k"::S]$Lisp_ - ,["x"::S,"nrx"::S,"k"::S]$Lisp,["work"::S,"lwork"::S]$Lisp,["rwork"::S,"lrwork"::S]$Lisp,"dot"::S,"image"::S,"monit"::S_ - ]$Lisp_ - ,["integer"::S,"n"::S,"k"::S,"novecs"::S,"nrx"::S_ - ,"lwork"::S,"lrwork"::S,"liwork"::S,"m"::S,"noits"::S,"ifail"::S,["iwork"::S,"liwork"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["d"::S,"m"::S,"noits"::S,"x"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,kArg::Any,tolArg::Any,novecsArg::Any,nrxArg::Any,lworkArg::Any,lrworkArg::Any,liworkArg::Any,mArg::Any,noitsArg::Any,ifailArg::Any,xArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + novecsArg:Integer,nrxArg:Integer,lworkArg:Integer,_ + lrworkArg:Integer,liworkArg:Integer,mArg:Integer,_ + noitsArg:Integer,xArg:Matrix DoubleFloat,ifailArg:Integer,_ + dotArg:Union(fn:FileName,fp:Asp27(DOT)),_ + imageArg:Union(fn:FileName,fp:Asp28(IMAGE)),_ + monitArg:FileName): Result == + pushFortranOutputStack(dotFilename := aspFilename "dot")$FOP + if dotArg case fn + then outputAsFortran(dotArg.fn) + else outputAsFortran(dotArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(imageFilename := aspFilename "image")$FOP + if imageArg case fn + then outputAsFortran(imageArg.fn) + else outputAsFortran(imageArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(monitFilename := aspFilename "monit")$FOP + outputAsFortran(monitArg) + [(invokeNagman([dotFilename,imageFilename,monitFilename]$Lisp,_ + "f02fjf",_ + ["n"::S,"k"::S,"tol"::S,"novecs"::S,"nrx"::S_ + ,"lwork"::S,"lrwork"::S,"liwork"::S,"m"::S,"noits"::S_ + ,"ifail"::S,"dot"::S,"image"::S,"monit"::S,"d"::S,"x"::S,_ + "work"::S,"rwork"::S,"iwork"::S_ + ]$Lisp,_ + ["d"::S,"work"::S,"rwork"::S,"iwork"::S,"dot"::S,"image"::S,_ + "monit"::S]$Lisp,_ + [["double"::S,"tol"::S,["d"::S,"k"::S]$Lisp_ + ,["x"::S,"nrx"::S,"k"::S]$Lisp,["work"::S,"lwork"::S]$Lisp,_ + ["rwork"::S,"lrwork"::S]$Lisp,"dot"::S,"image"::S,"monit"::S_ + ]$Lisp_ + ,["integer"::S,"n"::S,"k"::S,"novecs"::S,"nrx"::S_ + ,"lwork"::S,"lrwork"::S,"liwork"::S,"m"::S,"noits"::S,"ifail"::S,_ + ["iwork"::S,"liwork"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["d"::S,"m"::S,"noits"::S,"x"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,kArg::Any,tolArg::Any,novecsArg::Any,nrxArg::Any,_ + lworkArg::Any,lrworkArg::Any,liworkArg::Any,mArg::Any,_ + noitsArg::Any,ifailArg::Any,xArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f02wef(mArg:Integer,nArg:Integer,ldaArg:Integer,_ - ncolbArg:Integer,ldbArg:Integer,wantqArg:Boolean,_ - ldqArg:Integer,wantpArg:Boolean,ldptArg:Integer,_ - aArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,ifailArg:Integer): Result == + ncolbArg:Integer,ldbArg:Integer,wantqArg:Boolean,_ + ldqArg:Integer,wantpArg:Boolean,ldptArg:Integer,_ + aArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == workLength : Integer := mArg >= nArg => wantqArg and wantpArg => @@ -64407,64 +64658,73 @@ NagEigenPackage(): Exports == Implementation where zero? ncolbArg => max(2*(mArg - 1),1) max(3*(mArg - 1),1) - [(invokeNagman(NIL$Lisp,_ - "f02wef",_ - ["m"::S,"n"::S,"lda"::S,"ncolb"::S,"ldb"::S_ - ,"wantq"::S,"ldq"::S,"wantp"::S,"ldpt"::S,"ifail"::S_ - ,"q"::S,"sv"::S,"pt"::S,"work"::S,"a"::S_ - ,"b"::S]$Lisp,_ - ["q"::S,"sv"::S,"pt"::S,"work"::S]$Lisp,_ - [["double"::S,["q"::S,"ldq"::S,"m"::S]$Lisp_ - ,["sv"::S,"m"::S]$Lisp,["pt"::S,"ldpt"::S,"n"::S]$Lisp,["work"::S,workLength]$Lisp,["a"::S,"lda"::S,"n"::S]$Lisp,["b"::S,"ldb"::S,"ncolb"::S]$Lisp_ - ]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"lda"::S,"ncolb"::S_ - ,"ldb"::S,"ldq"::S,"ldpt"::S,"ifail"::S]$Lisp_ - ,["logical"::S,"wantq"::S,"wantp"::S]$Lisp_ - ]$Lisp,_ - ["q"::S,"sv"::S,"pt"::S,"work"::S,"a"::S,"b"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,nArg::Any,ldaArg::Any,ncolbArg::Any,ldbArg::Any,wantqArg::Any,ldqArg::Any,wantpArg::Any,ldptArg::Any,ifailArg::Any,aArg::Any,bArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "f02wef",_ + ["m"::S,"n"::S,"lda"::S,"ncolb"::S,"ldb"::S_ + ,"wantq"::S,"ldq"::S,"wantp"::S,"ldpt"::S,"ifail"::S_ + ,"q"::S,"sv"::S,"pt"::S,"work"::S,"a"::S_ + ,"b"::S]$Lisp,_ + ["q"::S,"sv"::S,"pt"::S,"work"::S]$Lisp,_ + [["double"::S,["q"::S,"ldq"::S,"m"::S]$Lisp_ + ,["sv"::S,"m"::S]$Lisp,["pt"::S,"ldpt"::S,"n"::S]$Lisp,_ + ["work"::S,workLength]$Lisp,["a"::S,"lda"::S,"n"::S]$Lisp,_ + ["b"::S,"ldb"::S,"ncolb"::S]$Lisp_ + ]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"lda"::S,"ncolb"::S_ + ,"ldb"::S,"ldq"::S,"ldpt"::S,"ifail"::S]$Lisp_ + ,["logical"::S,"wantq"::S,"wantp"::S]$Lisp_ + ]$Lisp,_ + ["q"::S,"sv"::S,"pt"::S,"work"::S,"a"::S,"b"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,nArg::Any,ldaArg::Any,ncolbArg::Any,ldbArg::Any,_ + wantqArg::Any,ldqArg::Any,wantpArg::Any,ldptArg::Any,_ + ifailArg::Any,aArg::Any,bArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f02xef(mArg:Integer,nArg:Integer,ldaArg:Integer,_ - ncolbArg:Integer,ldbArg:Integer,wantqArg:Boolean,_ - ldqArg:Integer,wantpArg:Boolean,ldphArg:Integer,_ - aArg:Matrix Complex DoubleFloat,bArg:Matrix Complex DoubleFloat,ifailArg:Integer): Result == + ncolbArg:Integer,ldbArg:Integer,wantqArg:Boolean,_ + ldqArg:Integer,wantpArg:Boolean,ldphArg:Integer,_ + aArg:Matrix Complex DoubleFloat,bArg:Matrix Complex DoubleFloat,_ + ifailArg:Integer): Result == -- This segment added by hand, to deal with an assumed size array GDN tem : Integer := (min(mArg,nArg)-1) - rLen : Integer := + rLen : Integer := zero? ncolbArg and not wantqArg and not wantpArg => 2*tem zero? ncolbArg and wantpArg and not wantqArg => 3*tem not wantpArg => ncolbArg >0 or wantqArg => 3*tem 5*tem - cLen : Integer := + cLen : Integer := mArg >= nArg => wantqArg and wantpArg => 2*(nArg + max(nArg**2,ncolbArg)) wantqArg and not wantpArg => 2*(nArg + max(nArg**2+nArg,ncolbArg)) 2*(nArg + max(nArg,ncolbArg)) wantpArg => 2*(mArg**2 + mArg) 2*mArg - svLength : Integer := + svLength : Integer := min(mArg,nArg) - [(invokeNagman(NIL$Lisp,_ - "f02xef",_ - ["m"::S,"n"::S,"lda"::S,"ncolb"::S,"ldb"::S_ - ,"wantq"::S,"ldq"::S,"wantp"::S,"ldph"::S,"ifail"::S_ - ,"q"::S,"sv"::S,"ph"::S,"rwork"::S,"a"::S_ - ,"b"::S,"cwork"::S]$Lisp,_ - ["q"::S,"sv"::S,"ph"::S,"rwork"::S,"cwork"::S]$Lisp,_ - [["double"::S,["sv"::S,svLength]$Lisp,["rwork"::S,rLen]$Lisp_ - ]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"lda"::S,"ncolb"::S_ - ,"ldb"::S,"ldq"::S,"ldph"::S,"ifail"::S]$Lisp_ - ,["logical"::S,"wantq"::S,"wantp"::S]$Lisp_ - ,["double complex"::S,["q"::S,"ldq"::S,"m"::S]$Lisp,["ph"::S,"ldph"::S,"n"::S]$Lisp,["a"::S,"lda"::S,"n"::S]$Lisp,["b"::S,"ldb"::S,"ncolb"::S]$Lisp,["cwork"::S,cLen]$Lisp]$Lisp_ - ]$Lisp,_ - ["q"::S,"sv"::S,"ph"::S,"rwork"::S,"a"::S,"b"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,nArg::Any,ldaArg::Any,ncolbArg::Any,ldbArg::Any,wantqArg::Any,ldqArg::Any,wantpArg::Any,ldphArg::Any,ifailArg::Any,aArg::Any,bArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "f02xef",_ + ["m"::S,"n"::S,"lda"::S,"ncolb"::S,"ldb"::S_ + ,"wantq"::S,"ldq"::S,"wantp"::S,"ldph"::S,"ifail"::S_ + ,"q"::S,"sv"::S,"ph"::S,"rwork"::S,"a"::S_ + ,"b"::S,"cwork"::S]$Lisp,_ + ["q"::S,"sv"::S,"ph"::S,"rwork"::S,"cwork"::S]$Lisp,_ + [["double"::S,["sv"::S,svLength]$Lisp,["rwork"::S,rLen]$Lisp_ + ]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"lda"::S,"ncolb"::S_ + ,"ldb"::S,"ldq"::S,"ldph"::S,"ifail"::S]$Lisp_ + ,["logical"::S,"wantq"::S,"wantp"::S]$Lisp_ + ,["double complex"::S,["q"::S,"ldq"::S,"m"::S]$Lisp,_ + ["ph"::S,"ldph"::S,"n"::S]$Lisp,["a"::S,"lda"::S,"n"::S]$Lisp,_ + ["b"::S,"ldb"::S,"ncolb"::S]$Lisp,["cwork"::S,cLen]$Lisp]$Lisp_ + ]$Lisp,_ + ["q"::S,"sv"::S,"ph"::S,"rwork"::S,"a"::S,"b"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,nArg::Any,ldaArg::Any,ncolbArg::Any,ldbArg::Any,_ + wantqArg::Any,ldqArg::Any,wantpArg::Any,ldphArg::Any,_ + ifailArg::Any,aArg::Any,bArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result @ <>= @@ -70981,8 +71241,6 @@ NagEigenPackage(): Exports == Implementation where ++ differentiating and integrating polynomial and spline curves and ++ surfaces, once the numerical values of their coefficients have ++ been determined. -++ See \downlink{Manual Page}{manpageXXe02}. - NagFittingPackage(): Exports == Implementation where S ==> Symbol @@ -70990,7 +71248,7 @@ NagFittingPackage(): Exports == Implementation where Exports ==> with e02adf : (Integer,Integer,Integer,Matrix DoubleFloat,_ - Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result + Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result ++ e02adf(m,kplus1,nrows,x,y,w,ifail) ++ computes weighted least-squares polynomial approximations ++ to an arbitrary set of data points. @@ -71001,7 +71259,9 @@ NagFittingPackage(): Exports == Implementation where ++ representation. ++ See \downlink{Manual Page}{manpageXXe02aef}. e02agf : (Integer,Integer,Integer,DoubleFloat,_ - DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer,Matrix Integer,Integer,Integer,Integer) -> Result + DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ + Matrix DoubleFloat,Integer,Matrix DoubleFloat,Matrix DoubleFloat,_ + Integer,Matrix Integer,Integer,Integer,Integer) -> Result ++ e02agf(m,kplus1,nrows,xmin,xmax,x,y,w,mf,xf,yf,lyf,ip,lwrk,liwrk,ifail) ++ computes constrained weighted least-squares polynomial ++ approximations in Chebyshev-series form to an arbitrary set of @@ -71009,28 +71269,28 @@ NagFittingPackage(): Exports == Implementation where ++ their derivatives can be specified at selected points. ++ See \downlink{Manual Page}{manpageXXe02agf}. e02ahf : (Integer,DoubleFloat,DoubleFloat,Matrix DoubleFloat,_ - Integer,Integer,Integer,Integer,Integer) -> Result + Integer,Integer,Integer,Integer,Integer) -> Result ++ e02ahf(np1,xmin,xmax,a,ia1,la,iadif1,ladif,ifail) ++ determines the coefficients in the Chebyshev-series ++ representation of the derivative of a polynomial given in ++ Chebyshev-series form. ++ See \downlink{Manual Page}{manpageXXe02ahf}. e02ajf : (Integer,DoubleFloat,DoubleFloat,Matrix DoubleFloat,_ - Integer,Integer,DoubleFloat,Integer,Integer,Integer) -> Result + Integer,Integer,DoubleFloat,Integer,Integer,Integer) -> Result ++ e02ajf(np1,xmin,xmax,a,ia1,la,qatm1,iaint1,laint,ifail) ++ determines the coefficients in the Chebyshev-series ++ representation of the indefinite integral of a polynomial given ++ in Chebyshev-series form. ++ See \downlink{Manual Page}{manpageXXe02ajf}. e02akf : (Integer,DoubleFloat,DoubleFloat,Matrix DoubleFloat,_ - Integer,Integer,DoubleFloat,Integer) -> Result + Integer,Integer,DoubleFloat,Integer) -> Result ++ e02akf(np1,xmin,xmax,a,ia1,la,x,ifail) ++ evaluates a polynomial from its Chebyshev-series ++ representation, allowing an arbitrary index increment for ++ accessing the array of coefficients. ++ See \downlink{Manual Page}{manpageXXe02akf}. e02baf : (Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,_ - Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result + Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result ++ e02baf(m,ncap7,x,y,w,lamda,ifail) ++ computes a weighted least-squares approximation to an ++ arbitrary set of data points by a cubic splines @@ -71038,12 +71298,12 @@ NagFittingPackage(): Exports == Implementation where ++ carried out. ++ See \downlink{Manual Page}{manpageXXe02baf}. e02bbf : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,DoubleFloat,_ - Integer) -> Result + Integer) -> Result ++ e02bbf(ncap7,lamda,c,x,ifail) ++ evaluates a cubic spline representation. ++ See \downlink{Manual Page}{manpageXXe02bbf}. e02bcf : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,DoubleFloat,_ - Integer,Integer) -> Result + Integer,Integer) -> Result ++ e02bcf(ncap7,lamda,c,x,left,ifail) ++ evaluates a cubic spline and its first three derivatives ++ from its B-spline representation. @@ -71054,7 +71314,9 @@ NagFittingPackage(): Exports == Implementation where ++ B-spline representation. ++ See \downlink{Manual Page}{manpageXXe02bdf}. e02bef : (String,Integer,Matrix DoubleFloat,Matrix DoubleFloat,_ - Matrix DoubleFloat,DoubleFloat,Integer,Integer,Integer,Matrix DoubleFloat,Integer,Matrix DoubleFloat,Matrix Integer) -> Result + Matrix DoubleFloat,DoubleFloat,Integer,Integer,Integer,_ + Matrix DoubleFloat,Integer,Matrix DoubleFloat,_ + Matrix Integer) -> Result ++ e02bef(start,m,x,y,w,s,nest,lwrk,n,lamda,ifail,wrk,iwrk) ++ computes a cubic spline approximation to an arbitrary set ++ of data points. The knot are located @@ -71063,14 +71325,20 @@ NagFittingPackage(): Exports == Implementation where ++ fit. ++ See \downlink{Manual Page}{manpageXXe02bef}. e02daf : (Integer,Integer,Integer,Matrix DoubleFloat,_ - Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Matrix Integer,Integer,Integer,Integer,DoubleFloat,Matrix DoubleFloat,Integer) -> Result + Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ + Matrix DoubleFloat,Matrix Integer,Integer,Integer,Integer,_ + DoubleFloat,Matrix DoubleFloat,Integer) -> Result ++ e02daf(m,px,py,x,y,f,w,mu,point,npoint,nc,nws,eps,lamda,ifail) ++ forms a minimal, weighted least-squares bicubic spline ++ surface fit with prescribed knots to a given set of data points. ++ See \downlink{Manual Page}{manpageXXe02daf}. e02dcf : (String,Integer,Matrix DoubleFloat,Integer,_ - Matrix DoubleFloat,Matrix DoubleFloat,DoubleFloat,Integer,Integer,Integer,Integer,Integer,Matrix DoubleFloat,Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix Integer,Integer) -> Result - ++ e02dcf(start,mx,x,my,y,f,s,nxest,nyest,lwrk,liwrk,nx,lamda,ny,mu,wrk,iwrk,ifail) + Matrix DoubleFloat,Matrix DoubleFloat,DoubleFloat,Integer,_ + Integer,Integer,Integer,Integer,Matrix DoubleFloat,Integer,_ + Matrix DoubleFloat,Matrix DoubleFloat,_ + Matrix Integer,Integer) -> Result + ++ e02dcf(start,mx,x,my,y,f,s,nxest,nyest,lwrk,liwrk,nx,_ + ++ lamda,ny,mu,wrk,iwrk,ifail) ++ computes a bicubic spline approximation to a set of data ++ values, given on a rectangular grid in the x-y plane. The knots ++ of the spline are located automatically, but a single parameter @@ -71078,8 +71346,11 @@ NagFittingPackage(): Exports == Implementation where ++ fit and smoothness of fit. ++ See \downlink{Manual Page}{manpageXXe02dcf}. e02ddf : (String,Integer,Matrix DoubleFloat,Matrix DoubleFloat,_ - Matrix DoubleFloat,Matrix DoubleFloat,DoubleFloat,Integer,Integer,Integer,Integer,Integer,Matrix DoubleFloat,Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result - ++ e02ddf(start,m,x,y,f,w,s,nxest,nyest,lwrk,liwrk,nx,lamda,ny,mu,wrk,ifail) + Matrix DoubleFloat,Matrix DoubleFloat,DoubleFloat,Integer,_ + Integer,Integer,Integer,Integer,Matrix DoubleFloat,Integer,_ + Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result + ++ e02ddf(start,m,x,y,f,w,s,nxest,nyest,lwrk,liwrk,nx,_ + ++ lamda,ny,mu,wrk,ifail) ++ computes a bicubic spline approximation to a set of ++ scattered data are located ++ automatically, but a single parameter must be specified to @@ -71087,27 +71358,30 @@ NagFittingPackage(): Exports == Implementation where ++ fit. ++ See \downlink{Manual Page}{manpageXXe02ddf}. e02def : (Integer,Integer,Integer,Matrix DoubleFloat,_ - Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result + Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ + Matrix DoubleFloat,Integer) -> Result ++ e02def(m,px,py,x,y,lamda,mu,c,ifail) ++ calculates values of a bicubic spline ++ representation. ++ See \downlink{Manual Page}{manpageXXe02def}. e02dff : (Integer,Integer,Integer,Integer,_ - Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Integer,Integer,Integer) -> Result + Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ + Matrix DoubleFloat,Matrix DoubleFloat,Integer,Integer,_ + Integer) -> Result ++ e02dff(mx,my,px,py,x,y,lamda,mu,c,lwrk,liwrk,ifail) ++ calculates values of a bicubic spline ++ representation. The spline is evaluated at all points on a ++ rectangular grid. ++ See \downlink{Manual Page}{manpageXXe02dff}. e02gaf : (Integer,Integer,Integer,DoubleFloat,_ - Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result + Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result ++ e02gaf(m,la,nplus2,toler,a,b,ifail) ++ calculates an l solution to an over-determined system of - ++ 1 ++ linear equations. ++ See \downlink{Manual Page}{manpageXXe02gaf}. e02zaf : (Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,_ - Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer,Integer,Integer) -> Result + Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer,_ + Integer,Integer) -> Result ++ e02zaf(px,py,lamda,mu,m,x,y,npoint,nadres,ifail) ++ sorts two-dimensional data into rectangular panels. ++ See \downlink{Manual Page}{manpageXXe02zaf}. @@ -71129,360 +71403,427 @@ NagFittingPackage(): Exports == Implementation where e02adf(mArg:Integer,kplus1Arg:Integer,nrowsArg:Integer,_ - xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,wArg:Matrix DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e02adf",_ - ["m"::S,"kplus1"::S,"nrows"::S,"ifail"::S,"x"::S,"y"::S,"w"::S,"a"::S,"s"::S_ - ,"work1"::S,"work2"::S]$Lisp,_ - ["a"::S,"s"::S,"work1"::S,"work2"::S]$Lisp,_ - [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ - ,["w"::S,"m"::S]$Lisp,["a"::S,"nrows"::S,"kplus1"::S]$Lisp,["s"::S,"kplus1"::S]$Lisp,["work1"::S,["*"::S,3$Lisp,"m"::S]$Lisp]$Lisp_ - ,["work2"::S,["*"::S,2$Lisp,"kplus1"::S]$Lisp]$Lisp]$Lisp_ - ,["integer"::S,"m"::S,"kplus1"::S,"nrows"::S_ - ,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["a"::S,"s"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,kplus1Arg::Any,nrowsArg::Any,ifailArg::Any,xArg::Any,yArg::Any,wArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,_ + wArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e02adf",_ + ["m"::S,"kplus1"::S,"nrows"::S,"ifail"::S,"x"::S,"y"::S,_ + "w"::S,"a"::S,"s"::S_ + ,"work1"::S,"work2"::S]$Lisp,_ + ["a"::S,"s"::S,"work1"::S,"work2"::S]$Lisp,_ + [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ + ,["w"::S,"m"::S]$Lisp,["a"::S,"nrows"::S,"kplus1"::S]$Lisp,_ + ["s"::S,"kplus1"::S]$Lisp,["work1"::S,_ + ["*"::S,3$Lisp,"m"::S]$Lisp]$Lisp_ + ,["work2"::S,["*"::S,2$Lisp,"kplus1"::S]$Lisp]$Lisp]$Lisp_ + ,["integer"::S,"m"::S,"kplus1"::S,"nrows"::S_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["a"::S,"s"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,kplus1Arg::Any,nrowsArg::Any,ifailArg::Any,_ + xArg::Any,yArg::Any,wArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e02aef(nplus1Arg:Integer,aArg:Matrix DoubleFloat,xcapArg:DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e02aef",_ - ["nplus1"::S,"xcap"::S,"p"::S,"ifail"::S,"a"::S]$Lisp,_ - ["p"::S]$Lisp,_ - [["double"::S,["a"::S,"nplus1"::S]$Lisp,"xcap"::S_ - ,"p"::S]$Lisp_ - ,["integer"::S,"nplus1"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["p"::S,"ifail"::S]$Lisp,_ - [([nplus1Arg::Any,xcapArg::Any,ifailArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e02aef",_ + ["nplus1"::S,"xcap"::S,"p"::S,"ifail"::S,"a"::S]$Lisp,_ + ["p"::S]$Lisp,_ + [["double"::S,["a"::S,"nplus1"::S]$Lisp,"xcap"::S_ + ,"p"::S]$Lisp_ + ,["integer"::S,"nplus1"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["p"::S,"ifail"::S]$Lisp,_ + [([nplus1Arg::Any,xcapArg::Any,ifailArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e02agf(mArg:Integer,kplus1Arg:Integer,nrowsArg:Integer,_ - xminArg:DoubleFloat,xmaxArg:DoubleFloat,xArg:Matrix DoubleFloat,_ - yArg:Matrix DoubleFloat,wArg:Matrix DoubleFloat,mfArg:Integer,_ - xfArg:Matrix DoubleFloat,yfArg:Matrix DoubleFloat,lyfArg:Integer,_ - ipArg:Matrix Integer,lwrkArg:Integer,liwrkArg:Integer,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e02agf",_ - ["m"::S,"kplus1"::S,"nrows"::S,"xmin"::S,"xmax"::S_ - ,"mf"::S,"lyf"::S,"lwrk"::S,"liwrk"::S,"np1"::S_ - ,"ifail"::S,"x"::S,"y"::S,"w"::S,"xf"::S,"yf"::S_ - ,"ip"::S,"a"::S,"s"::S,"wrk"::S,"iwrk"::S_ - ]$Lisp,_ - ["a"::S,"s"::S,"np1"::S,"wrk"::S,"iwrk"::S]$Lisp,_ - [["double"::S,"xmin"::S,"xmax"::S,["x"::S,"m"::S]$Lisp_ - ,["y"::S,"m"::S]$Lisp,["w"::S,"m"::S]$Lisp,["xf"::S,"mf"::S]$Lisp,["yf"::S,"lyf"::S]$Lisp,["a"::S,"nrows"::S,"kplus1"::S]$Lisp_ - ,["s"::S,"kplus1"::S]$Lisp,["wrk"::S,"lwrk"::S]$Lisp]$Lisp_ - ,["integer"::S,"m"::S,"kplus1"::S,"nrows"::S_ - ,"mf"::S,"lyf"::S,["ip"::S,"mf"::S]$Lisp,"lwrk"::S,"liwrk"::S,"np1"::S,"ifail"::S,["iwrk"::S,"liwrk"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["a"::S,"s"::S,"np1"::S,"wrk"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,kplus1Arg::Any,nrowsArg::Any,xminArg::Any,xmaxArg::Any,mfArg::Any,lyfArg::Any,lwrkArg::Any,liwrkArg::Any,ifailArg::Any,xArg::Any,yArg::Any,wArg::Any,xfArg::Any,yfArg::Any,ipArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + xminArg:DoubleFloat,xmaxArg:DoubleFloat,xArg:Matrix DoubleFloat,_ + yArg:Matrix DoubleFloat,wArg:Matrix DoubleFloat,mfArg:Integer,_ + xfArg:Matrix DoubleFloat,yfArg:Matrix DoubleFloat,lyfArg:Integer,_ + ipArg:Matrix Integer,lwrkArg:Integer,liwrkArg:Integer,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e02agf",_ + ["m"::S,"kplus1"::S,"nrows"::S,"xmin"::S,"xmax"::S_ + ,"mf"::S,"lyf"::S,"lwrk"::S,"liwrk"::S,"np1"::S_ + ,"ifail"::S,"x"::S,"y"::S,"w"::S,"xf"::S,"yf"::S_ + ,"ip"::S,"a"::S,"s"::S,"wrk"::S,"iwrk"::S_ + ]$Lisp,_ + ["a"::S,"s"::S,"np1"::S,"wrk"::S,"iwrk"::S]$Lisp,_ + [["double"::S,"xmin"::S,"xmax"::S,["x"::S,"m"::S]$Lisp_ + ,["y"::S,"m"::S]$Lisp,["w"::S,"m"::S]$Lisp,["xf"::S,"mf"::S]$Lisp,_ + ["yf"::S,"lyf"::S]$Lisp,["a"::S,"nrows"::S,"kplus1"::S]$Lisp_ + ,["s"::S,"kplus1"::S]$Lisp,["wrk"::S,"lwrk"::S]$Lisp]$Lisp_ + ,["integer"::S,"m"::S,"kplus1"::S,"nrows"::S_ + ,"mf"::S,"lyf"::S,["ip"::S,"mf"::S]$Lisp,"lwrk"::S,"liwrk"::S,_ + "np1"::S,"ifail"::S,["iwrk"::S,"liwrk"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["a"::S,"s"::S,"np1"::S,"wrk"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,kplus1Arg::Any,nrowsArg::Any,xminArg::Any,_ + xmaxArg::Any,mfArg::Any,lyfArg::Any,lwrkArg::Any,liwrkArg::Any,_ + ifailArg::Any,xArg::Any,yArg::Any,wArg::Any,xfArg::Any,_ + yfArg::Any,ipArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e02ahf(np1Arg:Integer,xminArg:DoubleFloat,xmaxArg:DoubleFloat,_ - aArg:Matrix DoubleFloat,ia1Arg:Integer,laArg:Integer,_ - iadif1Arg:Integer,ladifArg:Integer,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e02ahf",_ - ["np1"::S,"xmin"::S,"xmax"::S,"ia1"::S,"la"::S_ - ,"iadif1"::S,"ladif"::S,"patm1"::S,"ifail"::S,"a"::S,"adif"::S]$Lisp,_ - ["patm1"::S,"adif"::S]$Lisp,_ - [["double"::S,"xmin"::S,"xmax"::S,["a"::S,"la"::S]$Lisp_ - ,"patm1"::S,["adif"::S,"ladif"::S]$Lisp]$Lisp_ - ,["integer"::S,"np1"::S,"ia1"::S,"la"::S,"iadif1"::S_ - ,"ladif"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["patm1"::S,"adif"::S,"ifail"::S]$Lisp,_ - [([np1Arg::Any,xminArg::Any,xmaxArg::Any,ia1Arg::Any,laArg::Any,iadif1Arg::Any,ladifArg::Any,ifailArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + aArg:Matrix DoubleFloat,ia1Arg:Integer,laArg:Integer,_ + iadif1Arg:Integer,ladifArg:Integer,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e02ahf",_ + ["np1"::S,"xmin"::S,"xmax"::S,"ia1"::S,"la"::S_ + ,"iadif1"::S,"ladif"::S,"patm1"::S,"ifail"::S,"a"::S,"adif"::S]$Lisp,_ + ["patm1"::S,"adif"::S]$Lisp,_ + [["double"::S,"xmin"::S,"xmax"::S,["a"::S,"la"::S]$Lisp_ + ,"patm1"::S,["adif"::S,"ladif"::S]$Lisp]$Lisp_ + ,["integer"::S,"np1"::S,"ia1"::S,"la"::S,"iadif1"::S_ + ,"ladif"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["patm1"::S,"adif"::S,"ifail"::S]$Lisp,_ + [([np1Arg::Any,xminArg::Any,xmaxArg::Any,ia1Arg::Any,laArg::Any,_ + iadif1Arg::Any,ladifArg::Any,ifailArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e02ajf(np1Arg:Integer,xminArg:DoubleFloat,xmaxArg:DoubleFloat,_ - aArg:Matrix DoubleFloat,ia1Arg:Integer,laArg:Integer,_ - qatm1Arg:DoubleFloat,iaint1Arg:Integer,laintArg:Integer,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e02ajf",_ - ["np1"::S,"xmin"::S,"xmax"::S,"ia1"::S,"la"::S_ - ,"qatm1"::S,"iaint1"::S,"laint"::S,"ifail"::S,"a"::S,"aint"::S]$Lisp,_ - ["aint"::S]$Lisp,_ - [["double"::S,"xmin"::S,"xmax"::S,["a"::S,"la"::S]$Lisp_ - ,"qatm1"::S,["aint"::S,"laint"::S]$Lisp]$Lisp_ - ,["integer"::S,"np1"::S,"ia1"::S,"la"::S,"iaint1"::S_ - ,"laint"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["aint"::S,"ifail"::S]$Lisp,_ - [([np1Arg::Any,xminArg::Any,xmaxArg::Any,ia1Arg::Any,laArg::Any,qatm1Arg::Any,iaint1Arg::Any,laintArg::Any,ifailArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + aArg:Matrix DoubleFloat,ia1Arg:Integer,laArg:Integer,_ + qatm1Arg:DoubleFloat,iaint1Arg:Integer,laintArg:Integer,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e02ajf",_ + ["np1"::S,"xmin"::S,"xmax"::S,"ia1"::S,"la"::S_ + ,"qatm1"::S,"iaint1"::S,"laint"::S,"ifail"::S,"a"::S,"aint"::S]$Lisp,_ + ["aint"::S]$Lisp,_ + [["double"::S,"xmin"::S,"xmax"::S,["a"::S,"la"::S]$Lisp_ + ,"qatm1"::S,["aint"::S,"laint"::S]$Lisp]$Lisp_ + ,["integer"::S,"np1"::S,"ia1"::S,"la"::S,"iaint1"::S_ + ,"laint"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["aint"::S,"ifail"::S]$Lisp,_ + [([np1Arg::Any,xminArg::Any,xmaxArg::Any,ia1Arg::Any,laArg::Any,_ + qatm1Arg::Any,iaint1Arg::Any,laintArg::Any,ifailArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e02akf(np1Arg:Integer,xminArg:DoubleFloat,xmaxArg:DoubleFloat,_ - aArg:Matrix DoubleFloat,ia1Arg:Integer,laArg:Integer,_ - xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e02akf",_ - ["np1"::S,"xmin"::S,"xmax"::S,"ia1"::S,"la"::S_ - ,"x"::S,"result"::S,"ifail"::S,"a"::S]$Lisp,_ - ["result"::S]$Lisp,_ - [["double"::S,"xmin"::S,"xmax"::S,["a"::S,"la"::S]$Lisp_ - ,"x"::S,"result"::S]$Lisp_ - ,["integer"::S,"np1"::S,"ia1"::S,"la"::S,"ifail"::S_ - ]$Lisp_ - ]$Lisp,_ - ["result"::S,"ifail"::S]$Lisp,_ - [([np1Arg::Any,xminArg::Any,xmaxArg::Any,ia1Arg::Any,laArg::Any,xArg::Any,ifailArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + aArg:Matrix DoubleFloat,ia1Arg:Integer,laArg:Integer,_ + xArg:DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e02akf",_ + ["np1"::S,"xmin"::S,"xmax"::S,"ia1"::S,"la"::S_ + ,"x"::S,"result"::S,"ifail"::S,"a"::S]$Lisp,_ + ["result"::S]$Lisp,_ + [["double"::S,"xmin"::S,"xmax"::S,["a"::S,"la"::S]$Lisp_ + ,"x"::S,"result"::S]$Lisp_ + ,["integer"::S,"np1"::S,"ia1"::S,"la"::S,"ifail"::S_ + ]$Lisp_ + ]$Lisp,_ + ["result"::S,"ifail"::S]$Lisp,_ + [([np1Arg::Any,xminArg::Any,xmaxArg::Any,ia1Arg::Any,laArg::Any,_ + xArg::Any,ifailArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e02baf(mArg:Integer,ncap7Arg:Integer,xArg:Matrix DoubleFloat,_ - yArg:Matrix DoubleFloat,wArg:Matrix DoubleFloat,lamdaArg:Matrix DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e02baf",_ - ["m"::S,"ncap7"::S,"ss"::S,"ifail"::S,"x"::S,"y"::S,"w"::S,"c"::S,"lamda"::S_ - ,"work1"::S,"work2"::S]$Lisp,_ - ["c"::S,"ss"::S,"work1"::S,"work2"::S]$Lisp,_ - [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ - ,["w"::S,"m"::S]$Lisp,["c"::S,"ncap7"::S]$Lisp,"ss"::S,["lamda"::S,"ncap7"::S]$Lisp,["work1"::S,"m"::S]$Lisp_ - ,["work2"::S,["*"::S,4$Lisp,"ncap7"::S]$Lisp]$Lisp]$Lisp_ - ,["integer"::S,"m"::S,"ncap7"::S,"ifail"::S_ - ]$Lisp_ - ]$Lisp,_ - ["c"::S,"ss"::S,"lamda"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,ncap7Arg::Any,ifailArg::Any,xArg::Any,yArg::Any,wArg::Any,lamdaArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result - - e02bbf(ncap7Arg:Integer,lamdaArg:Matrix DoubleFloat,cArg:Matrix DoubleFloat,_ - xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e02bbf",_ - ["ncap7"::S,"x"::S,"s"::S,"ifail"::S,"lamda"::S,"c"::S]$Lisp,_ - ["s"::S]$Lisp,_ - [["double"::S,["lamda"::S,"ncap7"::S]$Lisp_ - ,["c"::S,"ncap7"::S]$Lisp,"x"::S,"s"::S]$Lisp_ - ,["integer"::S,"ncap7"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s"::S,"ifail"::S]$Lisp,_ - [([ncap7Arg::Any,xArg::Any,ifailArg::Any,lamdaArg::Any,cArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result - - e02bcf(ncap7Arg:Integer,lamdaArg:Matrix DoubleFloat,cArg:Matrix DoubleFloat,_ - xArg:DoubleFloat,leftArg:Integer,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e02bcf",_ - ["ncap7"::S,"x"::S,"left"::S,"ifail"::S,"lamda"::S,"c"::S,"s"::S]$Lisp,_ - ["s"::S]$Lisp,_ - [["double"::S,["lamda"::S,"ncap7"::S]$Lisp_ - ,["c"::S,"ncap7"::S]$Lisp,"x"::S,["s"::S,4$Lisp]$Lisp]$Lisp_ - ,["integer"::S,"ncap7"::S,"left"::S,"ifail"::S_ - ]$Lisp_ - ]$Lisp,_ - ["s"::S,"ifail"::S]$Lisp,_ - [([ncap7Arg::Any,xArg::Any,leftArg::Any,ifailArg::Any,lamdaArg::Any,cArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result - - e02bdf(ncap7Arg:Integer,lamdaArg:Matrix DoubleFloat,cArg:Matrix DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e02bdf",_ - ["ncap7"::S,"defint"::S,"ifail"::S,"lamda"::S,"c"::S]$Lisp,_ - ["defint"::S]$Lisp,_ - [["double"::S,["lamda"::S,"ncap7"::S]$Lisp_ - ,["c"::S,"ncap7"::S]$Lisp,"defint"::S]$Lisp_ - ,["integer"::S,"ncap7"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["defint"::S,"ifail"::S]$Lisp,_ - [([ncap7Arg::Any,ifailArg::Any,lamdaArg::Any,cArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + yArg:Matrix DoubleFloat,wArg:Matrix DoubleFloat,_ + lamdaArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e02baf",_ + ["m"::S,"ncap7"::S,"ss"::S,"ifail"::S,"x"::S,"y"::S,"w"::S,_ + "c"::S,"lamda"::S_ + ,"work1"::S,"work2"::S]$Lisp,_ + ["c"::S,"ss"::S,"work1"::S,"work2"::S]$Lisp,_ + [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ + ,["w"::S,"m"::S]$Lisp,["c"::S,"ncap7"::S]$Lisp,"ss"::S,_ + ["lamda"::S,"ncap7"::S]$Lisp,["work1"::S,"m"::S]$Lisp_ + ,["work2"::S,["*"::S,4$Lisp,"ncap7"::S]$Lisp]$Lisp]$Lisp_ + ,["integer"::S,"m"::S,"ncap7"::S,"ifail"::S_ + ]$Lisp_ + ]$Lisp,_ + ["c"::S,"ss"::S,"lamda"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,ncap7Arg::Any,ifailArg::Any,xArg::Any,yArg::Any,_ + wArg::Any,lamdaArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result + + e02bbf(ncap7Arg:Integer,lamdaArg:Matrix DoubleFloat,_ + cArg:Matrix DoubleFloat,xArg:DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e02bbf",_ + ["ncap7"::S,"x"::S,"s"::S,"ifail"::S,"lamda"::S,"c"::S]$Lisp,_ + ["s"::S]$Lisp,_ + [["double"::S,["lamda"::S,"ncap7"::S]$Lisp_ + ,["c"::S,"ncap7"::S]$Lisp,"x"::S,"s"::S]$Lisp_ + ,["integer"::S,"ncap7"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s"::S,"ifail"::S]$Lisp,_ + [([ncap7Arg::Any,xArg::Any,ifailArg::Any,lamdaArg::Any,cArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result + + e02bcf(ncap7Arg:Integer,lamdaArg:Matrix DoubleFloat,_ + cArg:Matrix DoubleFloat,_ + xArg:DoubleFloat,leftArg:Integer,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e02bcf",_ + ["ncap7"::S,"x"::S,"left"::S,"ifail"::S,"lamda"::S,_ + "c"::S,"s"::S]$Lisp,_ + ["s"::S]$Lisp,_ + [["double"::S,["lamda"::S,"ncap7"::S]$Lisp_ + ,["c"::S,"ncap7"::S]$Lisp,"x"::S,["s"::S,4$Lisp]$Lisp]$Lisp_ + ,["integer"::S,"ncap7"::S,"left"::S,"ifail"::S_ + ]$Lisp_ + ]$Lisp,_ + ["s"::S,"ifail"::S]$Lisp,_ + [([ncap7Arg::Any,xArg::Any,leftArg::Any,ifailArg::Any,_ + lamdaArg::Any,cArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result + + e02bdf(ncap7Arg:Integer,lamdaArg:Matrix DoubleFloat,_ + cArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e02bdf",_ + ["ncap7"::S,"defint"::S,"ifail"::S,"lamda"::S,"c"::S]$Lisp,_ + ["defint"::S]$Lisp,_ + [["double"::S,["lamda"::S,"ncap7"::S]$Lisp_ + ,["c"::S,"ncap7"::S]$Lisp,"defint"::S]$Lisp_ + ,["integer"::S,"ncap7"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["defint"::S,"ifail"::S]$Lisp,_ + [([ncap7Arg::Any,ifailArg::Any,lamdaArg::Any,cArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e02bef(startArg:String,mArg:Integer,xArg:Matrix DoubleFloat,_ - yArg:Matrix DoubleFloat,wArg:Matrix DoubleFloat,sArg:DoubleFloat,_ - nestArg:Integer,lwrkArg:Integer,nArg:Integer,_ - lamdaArg:Matrix DoubleFloat,ifailArg:Integer,wrkArg:Matrix DoubleFloat,_ - iwrkArg:Matrix Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e02bef",_ - ["start"::S,"m"::S,"s"::S,"nest"::S,"lwrk"::S_ - ,"fp"::S,"n"::S,"ifail"::S,"x"::S,"y"::S,"w"::S,"c"::S,"lamda"::S_ - ,"wrk"::S,"iwrk"::S]$Lisp,_ - ["c"::S,"fp"::S]$Lisp,_ - [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ - ,["w"::S,"m"::S]$Lisp,"s"::S,["c"::S,"nest"::S]$Lisp,"fp"::S,["lamda"::S,"nest"::S]$Lisp,["wrk"::S,"lwrk"::S]$Lisp_ - ]$Lisp_ - ,["integer"::S,"m"::S,"nest"::S,"lwrk"::S,"n"::S_ - ,"ifail"::S,["iwrk"::S,"nest"::S]$Lisp]$Lisp_ - ,["character"::S,"start"::S]$Lisp_ - ]$Lisp,_ - ["c"::S,"fp"::S,"n"::S,"lamda"::S,"ifail"::S,"wrk"::S,"iwrk"::S]$Lisp,_ - [([startArg::Any,mArg::Any,sArg::Any,nestArg::Any,lwrkArg::Any,nArg::Any,ifailArg::Any,xArg::Any,yArg::Any,wArg::Any,lamdaArg::Any,wrkArg::Any,iwrkArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + yArg:Matrix DoubleFloat,wArg:Matrix DoubleFloat,sArg:DoubleFloat,_ + nestArg:Integer,lwrkArg:Integer,nArg:Integer,_ + lamdaArg:Matrix DoubleFloat,ifailArg:Integer,_ + wrkArg:Matrix DoubleFloat,_ + iwrkArg:Matrix Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e02bef",_ + ["start"::S,"m"::S,"s"::S,"nest"::S,"lwrk"::S_ + ,"fp"::S,"n"::S,"ifail"::S,"x"::S,"y"::S,"w"::S,"c"::S,"lamda"::S_ + ,"wrk"::S,"iwrk"::S]$Lisp,_ + ["c"::S,"fp"::S]$Lisp,_ + [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ + ,["w"::S,"m"::S]$Lisp,"s"::S,["c"::S,"nest"::S]$Lisp,_ + "fp"::S,["lamda"::S,"nest"::S]$Lisp,["wrk"::S,"lwrk"::S]$Lisp_ + ]$Lisp_ + ,["integer"::S,"m"::S,"nest"::S,"lwrk"::S,"n"::S_ + ,"ifail"::S,["iwrk"::S,"nest"::S]$Lisp]$Lisp_ + ,["character"::S,"start"::S]$Lisp_ + ]$Lisp,_ + ["c"::S,"fp"::S,"n"::S,"lamda"::S,"ifail"::S,"wrk"::S,"iwrk"::S]$Lisp,_ + [([startArg::Any,mArg::Any,sArg::Any,nestArg::Any,lwrkArg::Any,_ + nArg::Any,ifailArg::Any,xArg::Any,yArg::Any,wArg::Any,_ + lamdaArg::Any,wrkArg::Any,iwrkArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e02daf(mArg:Integer,pxArg:Integer,pyArg:Integer,_ - xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,fArg:Matrix DoubleFloat,_ - wArg:Matrix DoubleFloat,muArg:Matrix DoubleFloat,pointArg:Matrix Integer,_ - npointArg:Integer,ncArg:Integer,nwsArg:Integer,_ - epsArg:DoubleFloat,lamdaArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e02daf",_ - ["m"::S,"px"::S,"py"::S,"npoint"::S,"nc"::S_ - ,"nws"::S,"eps"::S,"sigma"::S,"rank"::S,"ifail"::S_ - ,"x"::S,"y"::S,"f"::S,"w"::S,"mu"::S_ - ,"point"::S,"dl"::S,"c"::S,"lamda"::S,"ws"::S_ - ]$Lisp,_ - ["dl"::S,"c"::S,"sigma"::S,"rank"::S,"ws"::S]$Lisp,_ - [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ - ,["f"::S,"m"::S]$Lisp,["w"::S,"m"::S]$Lisp,["mu"::S,"py"::S]$Lisp,"eps"::S,["dl"::S,"nc"::S]$Lisp,["c"::S,"nc"::S]$Lisp_ - ,"sigma"::S,["lamda"::S,"px"::S]$Lisp,["ws"::S,"nws"::S]$Lisp]$Lisp_ - ,["integer"::S,"m"::S,"px"::S,"py"::S,["point"::S,"npoint"::S]$Lisp_ - ,"npoint"::S,"nc"::S,"nws"::S,"rank"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["dl"::S,"c"::S,"sigma"::S,"rank"::S,"lamda"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,pxArg::Any,pyArg::Any,npointArg::Any,ncArg::Any,nwsArg::Any,epsArg::Any,ifailArg::Any,xArg::Any,yArg::Any,fArg::Any,wArg::Any,muArg::Any,pointArg::Any,lamdaArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,_ + fArg:Matrix DoubleFloat,_ + wArg:Matrix DoubleFloat,muArg:Matrix DoubleFloat,_ + pointArg:Matrix Integer,_ + npointArg:Integer,ncArg:Integer,nwsArg:Integer,_ + epsArg:DoubleFloat,lamdaArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e02daf",_ + ["m"::S,"px"::S,"py"::S,"npoint"::S,"nc"::S_ + ,"nws"::S,"eps"::S,"sigma"::S,"rank"::S,"ifail"::S_ + ,"x"::S,"y"::S,"f"::S,"w"::S,"mu"::S_ + ,"point"::S,"dl"::S,"c"::S,"lamda"::S,"ws"::S_ + ]$Lisp,_ + ["dl"::S,"c"::S,"sigma"::S,"rank"::S,"ws"::S]$Lisp,_ + [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ + ,["f"::S,"m"::S]$Lisp,["w"::S,"m"::S]$Lisp,_ + ["mu"::S,"py"::S]$Lisp,"eps"::S,["dl"::S,"nc"::S]$Lisp,_ + ["c"::S,"nc"::S]$Lisp_ + ,"sigma"::S,["lamda"::S,"px"::S]$Lisp,["ws"::S,"nws"::S]$Lisp]$Lisp_ + ,["integer"::S,"m"::S,"px"::S,"py"::S,["point"::S,"npoint"::S]$Lisp_ + ,"npoint"::S,"nc"::S,"nws"::S,"rank"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["dl"::S,"c"::S,"sigma"::S,"rank"::S,"lamda"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,pxArg::Any,pyArg::Any,npointArg::Any,ncArg::Any,_ + nwsArg::Any,epsArg::Any,ifailArg::Any,xArg::Any,yArg::Any,_ + fArg::Any,wArg::Any,muArg::Any,pointArg::Any,lamdaArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e02dcf(startArg:String,mxArg:Integer,xArg:Matrix DoubleFloat,_ - myArg:Integer,yArg:Matrix DoubleFloat,fArg:Matrix DoubleFloat,_ - sArg:DoubleFloat,nxestArg:Integer,nyestArg:Integer,_ - lwrkArg:Integer,liwrkArg:Integer,nxArg:Integer,_ - lamdaArg:Matrix DoubleFloat,nyArg:Integer,muArg:Matrix DoubleFloat,_ - wrkArg:Matrix DoubleFloat,iwrkArg:Matrix Integer,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e02dcf",_ - ["start"::S,"mx"::S,"my"::S,"s"::S,"nxest"::S_ - ,"nyest"::S,"lwrk"::S,"liwrk"::S,"fp"::S,"nx"::S_ - ,"ny"::S,"ifail"::S,"x"::S,"y"::S,"f"::S,"c"::S,"lamda"::S_ - ,"mu"::S,"wrk"::S,"iwrk"::S]$Lisp,_ - ["c"::S,"fp"::S]$Lisp,_ - [["double"::S,["x"::S,"mx"::S]$Lisp,["y"::S,"my"::S]$Lisp_ - ,["f"::S,["*"::S,"mx"::S,"my"::S]$Lisp]$Lisp,"s"::S,["c"::S,["*"::S,["-"::S,"nxest"::S,4$Lisp]$Lisp,["-"::S,"nyest"::S,4$Lisp]$Lisp]$Lisp]$Lisp_ - ,"fp"::S,["lamda"::S,"nxest"::S]$Lisp,["mu"::S,"nyest"::S]$Lisp,["wrk"::S,"lwrk"::S]$Lisp_ - ]$Lisp_ - ,["integer"::S,"mx"::S,"my"::S,"nxest"::S,"nyest"::S_ - ,"lwrk"::S,"liwrk"::S,"nx"::S,"ny"::S,["iwrk"::S,"liwrk"::S]$Lisp,"ifail"::S]$Lisp_ - ,["character"::S,"start"::S]$Lisp_ - ]$Lisp,_ - ["c"::S,"fp"::S,"nx"::S,"lamda"::S,"ny"::S,"mu"::S,"wrk"::S,"iwrk"::S,"ifail"::S]$Lisp,_ - [([startArg::Any,mxArg::Any,myArg::Any,sArg::Any,nxestArg::Any,nyestArg::Any,lwrkArg::Any,liwrkArg::Any,nxArg::Any,nyArg::Any,ifailArg::Any,xArg::Any,yArg::Any,fArg::Any,lamdaArg::Any,muArg::Any,wrkArg::Any,iwrkArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + myArg:Integer,yArg:Matrix DoubleFloat,fArg:Matrix DoubleFloat,_ + sArg:DoubleFloat,nxestArg:Integer,nyestArg:Integer,_ + lwrkArg:Integer,liwrkArg:Integer,nxArg:Integer,_ + lamdaArg:Matrix DoubleFloat,nyArg:Integer,muArg:Matrix DoubleFloat,_ + wrkArg:Matrix DoubleFloat,iwrkArg:Matrix Integer,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e02dcf",_ + ["start"::S,"mx"::S,"my"::S,"s"::S,"nxest"::S_ + ,"nyest"::S,"lwrk"::S,"liwrk"::S,"fp"::S,"nx"::S_ + ,"ny"::S,"ifail"::S,"x"::S,"y"::S,"f"::S,"c"::S,"lamda"::S_ + ,"mu"::S,"wrk"::S,"iwrk"::S]$Lisp,_ + ["c"::S,"fp"::S]$Lisp,_ + [["double"::S,["x"::S,"mx"::S]$Lisp,["y"::S,"my"::S]$Lisp_ + ,["f"::S,["*"::S,"mx"::S,"my"::S]$Lisp]$Lisp,"s"::S,_ + ["c"::S,["*"::S,["-"::S,"nxest"::S,4$Lisp]$Lisp,_ + ["-"::S,"nyest"::S,4$Lisp]$Lisp]$Lisp]$Lisp_ + ,"fp"::S,["lamda"::S,"nxest"::S]$Lisp,_ + ["mu"::S,"nyest"::S]$Lisp,["wrk"::S,"lwrk"::S]$Lisp_ + ]$Lisp_ + ,["integer"::S,"mx"::S,"my"::S,"nxest"::S,"nyest"::S_ + ,"lwrk"::S,"liwrk"::S,"nx"::S,"ny"::S,["iwrk"::S,"liwrk"::S]$Lisp,_ + "ifail"::S]$Lisp_ + ,["character"::S,"start"::S]$Lisp_ + ]$Lisp,_ + ["c"::S,"fp"::S,"nx"::S,"lamda"::S,"ny"::S,"mu"::S,"wrk"::S,_ + "iwrk"::S,"ifail"::S]$Lisp,_ + [([startArg::Any,mxArg::Any,myArg::Any,sArg::Any,nxestArg::Any,_ + nyestArg::Any,lwrkArg::Any,liwrkArg::Any,nxArg::Any,nyArg::Any,_ + ifailArg::Any,xArg::Any,yArg::Any,fArg::Any,lamdaArg::Any,_ + muArg::Any,wrkArg::Any,iwrkArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e02ddf(startArg:String,mArg:Integer,xArg:Matrix DoubleFloat,_ - yArg:Matrix DoubleFloat,fArg:Matrix DoubleFloat,wArg:Matrix DoubleFloat,_ - sArg:DoubleFloat,nxestArg:Integer,nyestArg:Integer,_ - lwrkArg:Integer,liwrkArg:Integer,nxArg:Integer,_ - lamdaArg:Matrix DoubleFloat,nyArg:Integer,muArg:Matrix DoubleFloat,_ - wrkArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e02ddf",_ - ["start"::S,"m"::S,"s"::S,"nxest"::S,"nyest"::S_ - ,"lwrk"::S,"liwrk"::S,"fp"::S,"rank"::S,"nx"::S_ - ,"ny"::S,"ifail"::S,"x"::S,"y"::S,"f"::S,"w"::S,"c"::S_ - ,"iwrk"::S,"lamda"::S,"mu"::S,"wrk"::S]$Lisp,_ - ["c"::S,"fp"::S,"rank"::S,"iwrk"::S]$Lisp,_ - [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ - ,["f"::S,"m"::S]$Lisp,["w"::S,"m"::S]$Lisp,"s"::S,["c"::S,["*"::S,["-"::S,"nxest"::S,4$Lisp]$Lisp,["-"::S,"nyest"::S,4$Lisp]$Lisp]$Lisp]$Lisp_ - ,"fp"::S,["lamda"::S,"nxest"::S]$Lisp,["mu"::S,"nyest"::S]$Lisp,["wrk"::S,"lwrk"::S]$Lisp_ - ]$Lisp_ - ,["integer"::S,"m"::S,"nxest"::S,"nyest"::S_ - ,"lwrk"::S,"liwrk"::S,"rank"::S,["iwrk"::S,"liwrk"::S]$Lisp,"nx"::S,"ny"::S,"ifail"::S]$Lisp_ - ,["character"::S,"start"::S]$Lisp_ - ]$Lisp,_ - ["c"::S,"fp"::S,"rank"::S,"iwrk"::S,"nx"::S,"lamda"::S,"ny"::S,"mu"::S,"wrk"::S,"ifail"::S]$Lisp,_ - [([startArg::Any,mArg::Any,sArg::Any,nxestArg::Any,nyestArg::Any,lwrkArg::Any,liwrkArg::Any,nxArg::Any,nyArg::Any,ifailArg::Any,xArg::Any,yArg::Any,fArg::Any,wArg::Any,lamdaArg::Any,muArg::Any,wrkArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + yArg:Matrix DoubleFloat,fArg:Matrix DoubleFloat,_ + wArg:Matrix DoubleFloat,_ + sArg:DoubleFloat,nxestArg:Integer,nyestArg:Integer,_ + lwrkArg:Integer,liwrkArg:Integer,nxArg:Integer,_ + lamdaArg:Matrix DoubleFloat,nyArg:Integer,muArg:Matrix DoubleFloat,_ + wrkArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e02ddf",_ + ["start"::S,"m"::S,"s"::S,"nxest"::S,"nyest"::S_ + ,"lwrk"::S,"liwrk"::S,"fp"::S,"rank"::S,"nx"::S_ + ,"ny"::S,"ifail"::S,"x"::S,"y"::S,"f"::S,"w"::S,"c"::S_ + ,"iwrk"::S,"lamda"::S,"mu"::S,"wrk"::S]$Lisp,_ + ["c"::S,"fp"::S,"rank"::S,"iwrk"::S]$Lisp,_ + [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ + ,["f"::S,"m"::S]$Lisp,["w"::S,"m"::S]$Lisp,"s"::S,_ + ["c"::S,["*"::S,["-"::S,"nxest"::S,4$Lisp]$Lisp,_ + ["-"::S,"nyest"::S,4$Lisp]$Lisp]$Lisp]$Lisp_ + ,"fp"::S,["lamda"::S,"nxest"::S]$Lisp,["mu"::S,"nyest"::S]$Lisp,_ + ["wrk"::S,"lwrk"::S]$Lisp_ + ]$Lisp_ + ,["integer"::S,"m"::S,"nxest"::S,"nyest"::S_ + ,"lwrk"::S,"liwrk"::S,"rank"::S,["iwrk"::S,"liwrk"::S]$Lisp,_ + "nx"::S,"ny"::S,"ifail"::S]$Lisp_ + ,["character"::S,"start"::S]$Lisp_ + ]$Lisp,_ + ["c"::S,"fp"::S,"rank"::S,"iwrk"::S,"nx"::S,"lamda"::S,"ny"::S,_ + "mu"::S,"wrk"::S,"ifail"::S]$Lisp,_ + [([startArg::Any,mArg::Any,sArg::Any,nxestArg::Any,nyestArg::Any,_ + lwrkArg::Any,liwrkArg::Any,nxArg::Any,nyArg::Any,ifailArg::Any,_ + xArg::Any,yArg::Any,fArg::Any,wArg::Any,lamdaArg::Any,muArg::Any,_ + wrkArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e02def(mArg:Integer,pxArg:Integer,pyArg:Integer,_ - xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,lamdaArg:Matrix DoubleFloat,_ - muArg:Matrix DoubleFloat,cArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e02def",_ - ["m"::S,"px"::S,"py"::S,"ifail"::S,"x"::S,"y"::S,"lamda"::S,"mu"::S,"c"::S_ - ,"ff"::S,"wrk"::S,"iwrk"::S]$Lisp,_ - ["ff"::S,"wrk"::S,"iwrk"::S]$Lisp,_ - [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ - ,["lamda"::S,"px"::S]$Lisp,["mu"::S,"py"::S]$Lisp,["c"::S,["*"::S,["-"::S,"px"::S,4$Lisp]$Lisp,["-"::S,"py"::S,4$Lisp]$Lisp]$Lisp]$Lisp_ - ,["ff"::S,"m"::S]$Lisp,["wrk"::S,["-"::S,"py"::S,4$Lisp]$Lisp]$Lisp]$Lisp_ - ,["integer"::S,"m"::S,"px"::S,"py"::S,"ifail"::S_ - ,["iwrk"::S,["-"::S,"py"::S,4$Lisp]$Lisp]$Lisp]$Lisp_ - ]$Lisp,_ - ["ff"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,pxArg::Any,pyArg::Any,ifailArg::Any,xArg::Any,yArg::Any,lamdaArg::Any,muArg::Any,cArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,_ + lamdaArg:Matrix DoubleFloat,_ + muArg:Matrix DoubleFloat,cArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e02def",_ + ["m"::S,"px"::S,"py"::S,"ifail"::S,"x"::S,"y"::S,"lamda"::S,_ + "mu"::S,"c"::S_ + ,"ff"::S,"wrk"::S,"iwrk"::S]$Lisp,_ + ["ff"::S,"wrk"::S,"iwrk"::S]$Lisp,_ + [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ + ,["lamda"::S,"px"::S]$Lisp,["mu"::S,"py"::S]$Lisp,_ + ["c"::S,["*"::S,["-"::S,"px"::S,4$Lisp]$Lisp,_ + ["-"::S,"py"::S,4$Lisp]$Lisp]$Lisp]$Lisp_ + ,["ff"::S,"m"::S]$Lisp,["wrk"::S,_ + ["-"::S,"py"::S,4$Lisp]$Lisp]$Lisp]$Lisp_ + ,["integer"::S,"m"::S,"px"::S,"py"::S,"ifail"::S_ + ,["iwrk"::S,["-"::S,"py"::S,4$Lisp]$Lisp]$Lisp]$Lisp_ + ]$Lisp,_ + ["ff"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,pxArg::Any,pyArg::Any,ifailArg::Any,xArg::Any,_ + yArg::Any,lamdaArg::Any,muArg::Any,cArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e02dff(mxArg:Integer,myArg:Integer,pxArg:Integer,_ - pyArg:Integer,xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,_ - lamdaArg:Matrix DoubleFloat,muArg:Matrix DoubleFloat,cArg:Matrix DoubleFloat,_ - lwrkArg:Integer,liwrkArg:Integer,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e02dff",_ - ["mx"::S,"my"::S,"px"::S,"py"::S,"lwrk"::S_ - ,"liwrk"::S,"ifail"::S,"x"::S,"y"::S,"lamda"::S,"mu"::S,"c"::S_ - ,"ff"::S,"wrk"::S,"iwrk"::S]$Lisp,_ - ["ff"::S,"wrk"::S,"iwrk"::S]$Lisp,_ - [["double"::S,["x"::S,"mx"::S]$Lisp,["y"::S,"my"::S]$Lisp_ - ,["lamda"::S,"px"::S]$Lisp,["mu"::S,"py"::S]$Lisp,["c"::S,["*"::S,["-"::S,"px"::S,4$Lisp]$Lisp,["-"::S,"py"::S,4$Lisp]$Lisp]$Lisp]$Lisp_ - ,["ff"::S,["*"::S,"mx"::S,"my"::S]$Lisp]$Lisp,["wrk"::S,"lwrk"::S]$Lisp]$Lisp_ - ,["integer"::S,"mx"::S,"my"::S,"px"::S,"py"::S_ - ,"lwrk"::S,"liwrk"::S,"ifail"::S,["iwrk"::S,"liwrk"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["ff"::S,"ifail"::S]$Lisp,_ - [([mxArg::Any,myArg::Any,pxArg::Any,pyArg::Any,lwrkArg::Any,liwrkArg::Any,ifailArg::Any,xArg::Any,yArg::Any,lamdaArg::Any,muArg::Any,cArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + pyArg:Integer,xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,_ + lamdaArg:Matrix DoubleFloat,muArg:Matrix DoubleFloat,_ + cArg:Matrix DoubleFloat,_ + lwrkArg:Integer,liwrkArg:Integer,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e02dff",_ + ["mx"::S,"my"::S,"px"::S,"py"::S,"lwrk"::S_ + ,"liwrk"::S,"ifail"::S,"x"::S,"y"::S,"lamda"::S,"mu"::S,"c"::S_ + ,"ff"::S,"wrk"::S,"iwrk"::S]$Lisp,_ + ["ff"::S,"wrk"::S,"iwrk"::S]$Lisp,_ + [["double"::S,["x"::S,"mx"::S]$Lisp,["y"::S,"my"::S]$Lisp_ + ,["lamda"::S,"px"::S]$Lisp,["mu"::S,"py"::S]$Lisp,_ + ["c"::S,["*"::S,["-"::S,"px"::S,4$Lisp]$Lisp,_ + ["-"::S,"py"::S,4$Lisp]$Lisp]$Lisp]$Lisp_ + ,["ff"::S,["*"::S,"mx"::S,"my"::S]$Lisp]$Lisp,_ + ["wrk"::S,"lwrk"::S]$Lisp]$Lisp_ + ,["integer"::S,"mx"::S,"my"::S,"px"::S,"py"::S_ + ,"lwrk"::S,"liwrk"::S,"ifail"::S,["iwrk"::S,"liwrk"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["ff"::S,"ifail"::S]$Lisp,_ + [([mxArg::Any,myArg::Any,pxArg::Any,pyArg::Any,lwrkArg::Any,_ + liwrkArg::Any,ifailArg::Any,xArg::Any,yArg::Any,lamdaArg::Any,_ + muArg::Any,cArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e02gaf(mArg:Integer,laArg:Integer,nplus2Arg:Integer,_ - tolerArg:DoubleFloat,aArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e02gaf",_ - ["m"::S,"la"::S,"nplus2"::S,"toler"::S,"resid"::S_ - ,"irank"::S,"iter"::S,"ifail"::S,"x"::S,"a"::S,"b"::S,"iwork"::S]$Lisp,_ - ["x"::S,"resid"::S,"irank"::S,"iter"::S,"iwork"::S]$Lisp,_ - [["double"::S,"toler"::S,["x"::S,"nplus2"::S]$Lisp_ - ,"resid"::S,["a"::S,"la"::S,"nplus2"::S]$Lisp,["b"::S,"m"::S]$Lisp]$Lisp_ - ,["integer"::S,"m"::S,"la"::S,"nplus2"::S,"irank"::S_ - ,"iter"::S,"ifail"::S,["iwork"::S,"m"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["x"::S,"resid"::S,"irank"::S,"iter"::S,"a"::S,"b"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,laArg::Any,nplus2Arg::Any,tolerArg::Any,ifailArg::Any,aArg::Any,bArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + tolerArg:DoubleFloat,aArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e02gaf",_ + ["m"::S,"la"::S,"nplus2"::S,"toler"::S,"resid"::S, + "irank"::S,"iter"::S,"ifail"::S,"x"::S,"a"::S,"b"::S,"iwork"::S]$Lisp,_ + ["x"::S,"resid"::S,"irank"::S,"iter"::S,"iwork"::S]$Lisp,_ + [["double"::S,"toler"::S,["x"::S,"nplus2"::S]$Lisp, + "resid"::S,["a"::S,"la"::S,"nplus2"::S]$Lisp,_ + ["b"::S,"m"::S]$Lisp]$Lisp_ + ,["integer"::S,"m"::S,"la"::S,"nplus2"::S,"irank"::S_ + ,"iter"::S,"ifail"::S,["iwork"::S,"m"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["x"::S,"resid"::S,"irank"::S,"iter"::S,"a"::S,"b"::S,_ + "ifail"::S]$Lisp,_ + [([mArg::Any,laArg::Any,nplus2Arg::Any,tolerArg::Any,_ + ifailArg::Any,aArg::Any,bArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e02zaf(pxArg:Integer,pyArg:Integer,lamdaArg:Matrix DoubleFloat,_ - muArg:Matrix DoubleFloat,mArg:Integer,xArg:Matrix DoubleFloat,_ - yArg:Matrix DoubleFloat,npointArg:Integer,nadresArg:Integer,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e02zaf",_ - ["px"::S,"py"::S,"m"::S,"npoint"::S,"nadres"::S_ - ,"ifail"::S,"lamda"::S,"mu"::S,"x"::S,"y"::S,"point"::S_ - ,"adres"::S]$Lisp,_ - ["point"::S,"adres"::S]$Lisp,_ - [["double"::S,["lamda"::S,"px"::S]$Lisp,["mu"::S,"py"::S]$Lisp_ - ,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp]$Lisp_ - ,["integer"::S,"px"::S,"py"::S,"m"::S,"npoint"::S_ - ,"nadres"::S,["point"::S,"npoint"::S]$Lisp,"ifail"::S,["adres"::S,"nadres"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["point"::S,"ifail"::S]$Lisp,_ - [([pxArg::Any,pyArg::Any,mArg::Any,npointArg::Any,nadresArg::Any,ifailArg::Any,lamdaArg::Any,muArg::Any,xArg::Any,yArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + muArg:Matrix DoubleFloat,mArg:Integer,xArg:Matrix DoubleFloat,_ + yArg:Matrix DoubleFloat,npointArg:Integer,nadresArg:Integer,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e02zaf",_ + ["px"::S,"py"::S,"m"::S,"npoint"::S,"nadres"::S_ + ,"ifail"::S,"lamda"::S,"mu"::S,"x"::S,"y"::S,"point"::S_ + ,"adres"::S]$Lisp,_ + ["point"::S,"adres"::S]$Lisp,_ + [["double"::S,["lamda"::S,"px"::S]$Lisp,["mu"::S,"py"::S]$Lisp_ + ,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp]$Lisp_ + ,["integer"::S,"px"::S,"py"::S,"m"::S,"npoint"::S_ + ,"nadres"::S,["point"::S,"npoint"::S]$Lisp,"ifail"::S,_ + ["adres"::S,"nadres"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["point"::S,"ifail"::S]$Lisp,_ + [([pxArg::Any,pyArg::Any,mArg::Any,npointArg::Any,nadresArg::Any,_ + ifailArg::Any,lamdaArg::Any,muArg::Any,xArg::Any,yArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result @ <>= @@ -74767,34 +75108,34 @@ NagFittingPackage(): Exports == Implementation where ++ Date Created: Jan 1994 ++ Date Last Updated: Thu May 12 17:45:31 1994 ++ Description: -++ This package uses the NAG Library to solve the matrix equation -++ \axiom{AX=B}, where \axiom{B} +++ This package uses the NAG Library to solve the matrix equation \br +++ \tab{5}\axiom{AX=B}, where \axiom{B}\br ++ may be a single vector or a matrix of multiple right-hand sides. ++ The matrix \axiom{A} may be real, complex, symmetric, Hermitian positive- ++ definite, or sparse. It may also be rectangular, in which case a ++ least-squares solution is obtained. -++ See \downlink{Manual Page}{manpageXXf04}. + NagLinearEquationSolvingPackage(): Exports == Implementation where S ==> Symbol FOP ==> FortranOutputStackPackage Exports ==> with f04adf : (Integer,Matrix Complex DoubleFloat,Integer,Integer,_ - Integer,Integer,Matrix Complex DoubleFloat,Integer) -> Result + Integer,Integer,Matrix Complex DoubleFloat,Integer) -> Result ++ f04adf(ia,b,ib,n,m,ic,a,ifail) ++ calculates the approximate solution of a set of complex ++ linear equations with multiple right-hand sides, using an LU ++ factorization with partial pivoting. ++ See \downlink{Manual Page}{manpageXXf04adf}. f04arf : (Integer,Matrix DoubleFloat,Integer,Matrix DoubleFloat,_ - Integer) -> Result + Integer) -> Result ++ f04arf(ia,b,n,a,ifail) ++ calculates the approximate solution of a set of real ++ linear equations with a single right-hand side, using an LU ++ factorization with partial pivoting. ++ See \downlink{Manual Page}{manpageXXf04arf}. f04asf : (Integer,Matrix DoubleFloat,Integer,Matrix DoubleFloat,_ - Integer) -> Result + Integer) -> Result ++ f04asf(ia,b,n,a,ifail) ++ calculates the accurate solution of a set of real ++ symmetric positive-definite linear equations with a single right- @@ -74802,14 +75143,14 @@ NagLinearEquationSolvingPackage(): Exports == Implementation where ++ refinement. ++ See \downlink{Manual Page}{manpageXXf04asf}. f04atf : (Matrix DoubleFloat,Integer,Matrix DoubleFloat,Integer,_ - Integer,Integer) -> Result + Integer,Integer) -> Result ++ f04atf(a,ia,b,n,iaa,ifail) ++ calculates the accurate solution of a set of real linear ++ equations with a single right-hand side, using an LU ++ factorization with partial pivoting, and iterative refinement. ++ See \downlink{Manual Page}{manpageXXf04atf}. f04axf : (Integer,Matrix DoubleFloat,Integer,Matrix Integer,_ - Matrix Integer,Integer,Matrix Integer,Matrix DoubleFloat) -> Result + Matrix Integer,Integer,Matrix Integer,Matrix DoubleFloat) -> Result ++ f04axf(n,a,licn,icn,ikeep,mtype,idisp,rhs) ++ calculates the approximate solution of a set of real ++ sparse linear equations with a single right-hand side, Ax=b or @@ -74817,13 +75158,13 @@ NagLinearEquationSolvingPackage(): Exports == Implementation where ++ A x=b, where A has been factorized by F01BRF or F01BSF. ++ See \downlink{Manual Page}{manpageXXf04axf}. f04faf : (Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,_ - Matrix DoubleFloat,Integer) -> Result + Matrix DoubleFloat,Integer) -> Result ++ f04faf(job,n,d,e,b,ifail) ++ calculates the approximate solution of a set of real ++ symmetric positive-definite tridiagonal linear equations. ++ See \downlink{Manual Page}{manpageXXf04faf}. f04jgf : (Integer,Integer,Integer,DoubleFloat,_ - Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result + Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result ++ f04jgf(m,n,nra,tol,lwork,a,b,ifail) ++ finds the solution of a linear least-squares problem, Ax=b ++ , where A is a real m by n (m>=n) matrix and b is an m element @@ -74831,20 +75172,27 @@ NagLinearEquationSolvingPackage(): Exports == Implementation where ++ the minimal least-squares solution is returned. ++ See \downlink{Manual Page}{manpageXXf04jgf}. f04maf : (Integer,Integer,Matrix DoubleFloat,Integer,_ - Matrix Integer,Integer,Matrix Integer,Matrix DoubleFloat,Matrix Integer,Matrix Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix Integer,Integer) -> Result - ++ f04maf(n,nz,avals,licn,irn,lirn,icn,wkeep,ikeep,inform,b,acc,noits,ifail) + Matrix Integer,Integer,Matrix Integer,Matrix DoubleFloat,_ + Matrix Integer,Matrix Integer,Matrix DoubleFloat,Matrix DoubleFloat,_ + Matrix Integer,Integer) -> Result + ++ f04maf(n,nz,avals,licn,irn,lirn,icn,wkeep,ikeep, + ++ inform,b,acc,noits,ifail) ++ e a sparse symmetric positive-definite system of linear ++ equations, Ax=b, using a pre-conditioned conjugate gradient ++ method, where A has been factorized by F01MAF. ++ See \downlink{Manual Page}{manpageXXf04maf}. f04mbf : (Integer,Matrix DoubleFloat,Boolean,DoubleFloat,_ - Integer,Integer,Integer,Integer,DoubleFloat,Integer,Union(fn:FileName,fp:Asp28(APROD)),Union(fn:FileName,fp:Asp34(MSOLVE))) -> Result - ++ f04mbf(n,b,precon,shift,itnlim,msglvl,lrwork,liwork,rtol,ifail,aprod,msolve) + Integer,Integer,Integer,Integer,DoubleFloat,Integer,_ + Union(fn:FileName,fp:Asp28(APROD)),_ + Union(fn:FileName,fp:Asp34(MSOLVE))) -> Result + ++ f04mbf(n,b,precon,shift,itnlim,msglvl,lrwork,_ + ++ liwork,rtol,ifail,aprod,msolve) ++ solves a system of real sparse symmetric linear equations ++ using a Lanczos algorithm. ++ See \downlink{Manual Page}{manpageXXf04mbf}. f04mcf : (Integer,Matrix DoubleFloat,Integer,Matrix DoubleFloat,_ - Matrix Integer,Integer,Matrix DoubleFloat,Integer,Integer,Integer,Integer) -> Result + Matrix Integer,Integer,Matrix DoubleFloat,Integer,Integer,_ + Integer,Integer) -> Result ++ f04mcf(n,al,lal,d,nrow,ir,b,nrb,iselct,nrx,ifail) ++ computes the approximate solution of a system of real ++ linear equations with multiple right-hand sides, AX=B, where A @@ -74853,8 +75201,11 @@ NagLinearEquationSolvingPackage(): Exports == Implementation where ++ also be solved. ++ See \downlink{Manual Page}{manpageXXf04mcf}. f04qaf : (Integer,Integer,DoubleFloat,DoubleFloat,_ - DoubleFloat,DoubleFloat,Integer,Integer,Integer,Integer,Matrix DoubleFloat,Integer,Union(fn:FileName,fp:Asp30(APROD))) -> Result - ++ f04qaf(m,n,damp,atol,btol,conlim,itnlim,msglvl,lrwork,liwork,b,ifail,aprod) + DoubleFloat,DoubleFloat,Integer,Integer,Integer,Integer,_ + Matrix DoubleFloat,Integer,Union(fn:FileName,_ + fp:Asp30(APROD))) -> Result + ++ f04qaf(m,n,damp,atol,btol,conlim,itnlim,msglvl, + ++ lrwork,liwork,b,ifail,aprod) ++ solves sparse unsymmetric equations, sparse linear least- ++ squares problems and sparse damped linear least-squares problems, ++ using a Lanczos algorithm. @@ -74879,240 +75230,269 @@ NagLinearEquationSolvingPackage(): Exports == Implementation where f04adf(iaArg:Integer,bArg:Matrix Complex DoubleFloat,ibArg:Integer,_ - nArg:Integer,mArg:Integer,icArg:Integer,_ - aArg:Matrix Complex DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f04adf",_ - ["ia"::S,"ib"::S,"n"::S,"m"::S,"ic"::S_ - ,"ifail"::S,"b"::S,"c"::S,"a"::S,"wkspce"::S]$Lisp,_ - ["c"::S,"wkspce"::S]$Lisp,_ - [["double"::S,["wkspce"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"ia"::S,"ib"::S,"n"::S,"m"::S_ - ,"ic"::S,"ifail"::S]$Lisp_ - ,["double complex"::S,["b"::S,"ib"::S,"m"::S]$Lisp,["c"::S,"ic"::S,"m"::S]$Lisp,["a"::S,"ia"::S,"n"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["c"::S,"a"::S,"ifail"::S]$Lisp,_ - [([iaArg::Any,ibArg::Any,nArg::Any,mArg::Any,icArg::Any,ifailArg::Any,bArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + nArg:Integer,mArg:Integer,icArg:Integer,_ + aArg:Matrix Complex DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f04adf",_ + ["ia"::S,"ib"::S,"n"::S,"m"::S,"ic"::S_ + ,"ifail"::S,"b"::S,"c"::S,"a"::S,"wkspce"::S]$Lisp,_ + ["c"::S,"wkspce"::S]$Lisp,_ + [["double"::S,["wkspce"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"ia"::S,"ib"::S,"n"::S,"m"::S_ + ,"ic"::S,"ifail"::S]$Lisp_ + ,["double complex"::S,["b"::S,"ib"::S,"m"::S]$Lisp,_ + ["c"::S,"ic"::S,"m"::S]$Lisp,["a"::S,"ia"::S,"n"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["c"::S,"a"::S,"ifail"::S]$Lisp,_ + [([iaArg::Any,ibArg::Any,nArg::Any,mArg::Any,icArg::Any,_ + ifailArg::Any,bArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f04arf(iaArg:Integer,bArg:Matrix DoubleFloat,nArg:Integer,_ - aArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f04arf",_ - ["ia"::S,"n"::S,"ifail"::S,"b"::S,"c"::S,"a"::S,"wkspce"::S]$Lisp,_ - ["c"::S,"wkspce"::S]$Lisp,_ - [["double"::S,["b"::S,"n"::S]$Lisp,["c"::S,"n"::S]$Lisp_ - ,["a"::S,"ia"::S,"n"::S]$Lisp,["wkspce"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"ia"::S,"n"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["c"::S,"a"::S,"ifail"::S]$Lisp,_ - [([iaArg::Any,nArg::Any,ifailArg::Any,bArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + aArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f04arf",_ + ["ia"::S,"n"::S,"ifail"::S,"b"::S,"c"::S,"a"::S,"wkspce"::S]$Lisp,_ + ["c"::S,"wkspce"::S]$Lisp,_ + [["double"::S,["b"::S,"n"::S]$Lisp,["c"::S,"n"::S]$Lisp_ + ,["a"::S,"ia"::S,"n"::S]$Lisp,["wkspce"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"ia"::S,"n"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["c"::S,"a"::S,"ifail"::S]$Lisp,_ + [([iaArg::Any,nArg::Any,ifailArg::Any,bArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f04asf(iaArg:Integer,bArg:Matrix DoubleFloat,nArg:Integer,_ - aArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f04asf",_ - ["ia"::S,"n"::S,"ifail"::S,"b"::S,"c"::S,"a"::S,"wk1"::S,"wk2"::S_ - ]$Lisp,_ - ["c"::S,"wk1"::S,"wk2"::S]$Lisp,_ - [["double"::S,["b"::S,"n"::S]$Lisp,["c"::S,"n"::S]$Lisp_ - ,["a"::S,"ia"::S,"n"::S]$Lisp,["wk1"::S,"n"::S]$Lisp,["wk2"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"ia"::S,"n"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["c"::S,"a"::S,"ifail"::S]$Lisp,_ - [([iaArg::Any,nArg::Any,ifailArg::Any,bArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + aArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f04asf",_ + ["ia"::S,"n"::S,"ifail"::S,"b"::S,"c"::S,"a"::S,"wk1"::S,"wk2"::S_ + ]$Lisp,_ + ["c"::S,"wk1"::S,"wk2"::S]$Lisp,_ + [["double"::S,["b"::S,"n"::S]$Lisp,["c"::S,"n"::S]$Lisp,_ + ["a"::S,"ia"::S,"n"::S]$Lisp,["wk1"::S,"n"::S]$Lisp,_ + ["wk2"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"ia"::S,"n"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["c"::S,"a"::S,"ifail"::S]$Lisp,_ + [([iaArg::Any,nArg::Any,ifailArg::Any,bArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f04atf(aArg:Matrix DoubleFloat,iaArg:Integer,bArg:Matrix DoubleFloat,_ - nArg:Integer,iaaArg:Integer,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f04atf",_ - ["ia"::S,"n"::S,"iaa"::S,"ifail"::S,"a"::S,"b"::S,"c"::S,"aa"::S,"wks1"::S_ - ,"wks2"::S]$Lisp,_ - ["c"::S,"aa"::S,"wks1"::S,"wks2"::S]$Lisp,_ - [["double"::S,["a"::S,"ia"::S,"n"::S]$Lisp_ - ,["b"::S,"n"::S]$Lisp,["c"::S,"n"::S]$Lisp,["aa"::S,"iaa"::S,"n"::S]$Lisp,["wks1"::S,"n"::S]$Lisp,["wks2"::S,"n"::S]$Lisp_ - ]$Lisp_ - ,["integer"::S,"ia"::S,"n"::S,"iaa"::S,"ifail"::S_ - ]$Lisp_ - ]$Lisp,_ - ["c"::S,"aa"::S,"ifail"::S]$Lisp,_ - [([iaArg::Any,nArg::Any,iaaArg::Any,ifailArg::Any,aArg::Any,bArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + nArg:Integer,iaaArg:Integer,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f04atf",_ + ["ia"::S,"n"::S,"iaa"::S,"ifail"::S,"a"::S,"b"::S,"c"::S,_ + "aa"::S,"wks1"::S,"wks2"::S]$Lisp,_ + ["c"::S,"aa"::S,"wks1"::S,"wks2"::S]$Lisp,_ + [["double"::S,["a"::S,"ia"::S,"n"::S]$Lisp_ + ,["b"::S,"n"::S]$Lisp,["c"::S,"n"::S]$Lisp,_ + ["aa"::S,"iaa"::S,"n"::S]$Lisp,["wks1"::S,"n"::S]$Lisp,_ + ["wks2"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"ia"::S,"n"::S,"iaa"::S,"ifail"::S]$Lisp]$Lisp,_ + ["c"::S,"aa"::S,"ifail"::S]$Lisp,_ + [([iaArg::Any,nArg::Any,iaaArg::Any,ifailArg::Any,_ + aArg::Any,bArg::Any])@List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f04axf(nArg:Integer,aArg:Matrix DoubleFloat,licnArg:Integer,_ - icnArg:Matrix Integer,ikeepArg:Matrix Integer,mtypeArg:Integer,_ - idispArg:Matrix Integer,rhsArg:Matrix DoubleFloat): Result == - [(invokeNagman(NIL$Lisp,_ - "f04axf",_ - ["n"::S,"licn"::S,"mtype"::S,"resid"::S,"a"::S,"icn"::S,"ikeep"::S,"idisp"::S,"rhs"::S_ - ,"w"::S]$Lisp,_ - ["resid"::S,"w"::S]$Lisp,_ - [["double"::S,["a"::S,"licn"::S]$Lisp,"resid"::S_ - ,["rhs"::S,"n"::S]$Lisp,["w"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"n"::S,"licn"::S,["icn"::S,"licn"::S]$Lisp_ - ,["ikeep"::S,["*"::S,"n"::S,5$Lisp]$Lisp]$Lisp,"mtype"::S,["idisp"::S,2$Lisp]$Lisp]$Lisp_ - ]$Lisp,_ - ["resid"::S,"rhs"::S]$Lisp,_ - [([nArg::Any,licnArg::Any,mtypeArg::Any,aArg::Any,icnArg::Any,ikeepArg::Any,idispArg::Any,rhsArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + icnArg:Matrix Integer,ikeepArg:Matrix Integer,mtypeArg:Integer,_ + idispArg:Matrix Integer,rhsArg:Matrix DoubleFloat): Result == + [(invokeNagman(NIL$Lisp,_ + "f04axf",_ + ["n"::S,"licn"::S,"mtype"::S,"resid"::S,"a"::S,"icn"::S,_ + "ikeep"::S,"idisp"::S,"rhs"::S,"w"::S]$Lisp,_ + ["resid"::S,"w"::S]$Lisp,_ + [["double"::S,["a"::S,"licn"::S]$Lisp,"resid"::S_ + ,["rhs"::S,"n"::S]$Lisp,["w"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"licn"::S,["icn"::S,"licn"::S]$Lisp_ + ,["ikeep"::S,["*"::S,"n"::S,5$Lisp]$Lisp]$Lisp,_ + "mtype"::S,["idisp"::S,2$Lisp]$Lisp]$Lisp_ + ]$Lisp,_ + ["resid"::S,"rhs"::S]$Lisp,_ + [([nArg::Any,licnArg::Any,mtypeArg::Any,aArg::Any,icnArg::Any,_ + ikeepArg::Any,idispArg::Any,rhsArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f04faf(jobArg:Integer,nArg:Integer,dArg:Matrix DoubleFloat,_ - eArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f04faf",_ - ["job"::S,"n"::S,"ifail"::S,"d"::S,"e"::S,"b"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,["d"::S,"n"::S]$Lisp,["e"::S,"n"::S]$Lisp_ - ,["b"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"job"::S,"n"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["d"::S,"e"::S,"b"::S,"ifail"::S]$Lisp,_ - [([jobArg::Any,nArg::Any,ifailArg::Any,dArg::Any,eArg::Any,bArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + eArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f04faf",_ + ["job"::S,"n"::S,"ifail"::S,"d"::S,"e"::S,"b"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,["d"::S,"n"::S]$Lisp,["e"::S,"n"::S]$Lisp_ + ,["b"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"job"::S,"n"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["d"::S,"e"::S,"b"::S,"ifail"::S]$Lisp,_ + [([jobArg::Any,nArg::Any,ifailArg::Any,dArg::Any,eArg::Any,bArg::Any])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f04jgf(mArg:Integer,nArg:Integer,nraArg:Integer,_ - tolArg:DoubleFloat,lworkArg:Integer,aArg:Matrix DoubleFloat,_ - bArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f04jgf",_ - ["m"::S,"n"::S,"nra"::S,"tol"::S,"lwork"::S_ - ,"svd"::S,"sigma"::S,"irank"::S,"ifail"::S,"work"::S,"a"::S,"b"::S]$Lisp,_ - ["svd"::S,"sigma"::S,"irank"::S,"work"::S]$Lisp,_ - [["double"::S,"tol"::S,"sigma"::S,["work"::S,"lwork"::S]$Lisp_ - ,["a"::S,"nra"::S,"n"::S]$Lisp,["b"::S,"m"::S]$Lisp]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"nra"::S,"lwork"::S_ - ,"irank"::S,"ifail"::S]$Lisp_ - ,["logical"::S,"svd"::S]$Lisp_ - ]$Lisp,_ - ["svd"::S,"sigma"::S,"irank"::S,"work"::S,"a"::S,"b"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,nArg::Any,nraArg::Any,tolArg::Any,lworkArg::Any,ifailArg::Any,aArg::Any,bArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + tolArg:DoubleFloat,lworkArg:Integer,aArg:Matrix DoubleFloat,_ + bArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f04jgf",_ + ["m"::S,"n"::S,"nra"::S,"tol"::S,"lwork"::S_ + ,"svd"::S,"sigma"::S,"irank"::S,"ifail"::S,"work"::S,_ + "a"::S,"b"::S]$Lisp,_ + ["svd"::S,"sigma"::S,"irank"::S,"work"::S]$Lisp,_ + [["double"::S,"tol"::S,"sigma"::S,["work"::S,"lwork"::S]$Lisp_ + ,["a"::S,"nra"::S,"n"::S]$Lisp,["b"::S,"m"::S]$Lisp]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"nra"::S,"lwork"::S_ + ,"irank"::S,"ifail"::S]$Lisp_ + ,["logical"::S,"svd"::S]$Lisp_ + ]$Lisp,_ + ["svd"::S,"sigma"::S,"irank"::S,"work"::S,"a"::S,_ + "b"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,nArg::Any,nraArg::Any,tolArg::Any,lworkArg::Any,_ + ifailArg::Any,aArg::Any,bArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f04maf(nArg:Integer,nzArg:Integer,avalsArg:Matrix DoubleFloat,_ - licnArg:Integer,irnArg:Matrix Integer,lirnArg:Integer,_ - icnArg:Matrix Integer,wkeepArg:Matrix DoubleFloat,ikeepArg:Matrix Integer,_ - informArg:Matrix Integer,bArg:Matrix DoubleFloat,accArg:Matrix DoubleFloat,_ - noitsArg:Matrix Integer,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f04maf",_ - ["n"::S,"nz"::S,"licn"::S,"lirn"::S,"ifail"::S_ - ,"avals"::S,"irn"::S,"icn"::S,"wkeep"::S,"ikeep"::S_ - ,"inform"::S,"work"::S,"b"::S,"acc"::S,"noits"::S_ - ]$Lisp,_ - ["work"::S]$Lisp,_ - [["double"::S,["avals"::S,"licn"::S]$Lisp,["wkeep"::S,["*"::S,3$Lisp,"n"::S]$Lisp]$Lisp_ - ,["work"::S,["*"::S,3$Lisp,"n"::S]$Lisp]$Lisp,["b"::S,"n"::S]$Lisp,["acc"::S,2$Lisp]$Lisp_ - ]$Lisp_ - ,["integer"::S,"n"::S,"nz"::S,"licn"::S,["irn"::S,"lirn"::S]$Lisp_ - ,"lirn"::S,["icn"::S,"licn"::S]$Lisp,["ikeep"::S,["*"::S,2$Lisp,"n"::S]$Lisp]$Lisp,["inform"::S,4$Lisp]$Lisp_ - ,["noits"::S,2$Lisp]$Lisp,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["work"::S,"b"::S,"acc"::S,"noits"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,nzArg::Any,licnArg::Any,lirnArg::Any,ifailArg::Any,avalsArg::Any,irnArg::Any,icnArg::Any,wkeepArg::Any,ikeepArg::Any,informArg::Any,bArg::Any,accArg::Any,noitsArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + licnArg:Integer,irnArg:Matrix Integer,lirnArg:Integer,_ + icnArg:Matrix Integer,wkeepArg:Matrix DoubleFloat,_ + ikeepArg:Matrix Integer,_ + informArg:Matrix Integer,bArg:Matrix DoubleFloat,_ + accArg:Matrix DoubleFloat,_ + noitsArg:Matrix Integer,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,"f04maf",_ + ["n"::S,"nz"::S,"licn"::S,"lirn"::S,"ifail"::S_ + ,"avals"::S,"irn"::S,"icn"::S,"wkeep"::S,"ikeep"::S_ + ,"inform"::S,"work"::S,"b"::S,"acc"::S,"noits"::S]$Lisp,_ + ["work"::S]$Lisp,_ + [["double"::S,["avals"::S,"licn"::S]$Lisp,_ + ["wkeep"::S,["*"::S,3$Lisp,"n"::S]$Lisp]$Lisp_ + ,["work"::S,["*"::S,3$Lisp,"n"::S]$Lisp]$Lisp,_ + ["b"::S,"n"::S]$Lisp,["acc"::S,2$Lisp]$Lisp_ + ]$Lisp_ + ,["integer"::S,"n"::S,"nz"::S,"licn"::S,["irn"::S,"lirn"::S]$Lisp_ + ,"lirn"::S,["icn"::S,"licn"::S]$Lisp,["ikeep"::S,_ + ["*"::S,2$Lisp,"n"::S]$Lisp]$Lisp,["inform"::S,4$Lisp]$Lisp_ + ,["noits"::S,2$Lisp]$Lisp,"ifail"::S]$Lisp]$Lisp,_ + ["work"::S,"b"::S,"acc"::S,"noits"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,nzArg::Any,licnArg::Any,lirnArg::Any,_ + ifailArg::Any,avalsArg::Any,irnArg::Any,icnArg::Any,wkeepArg::Any,_ + ikeepArg::Any,informArg::Any,bArg::Any,accArg::Any,noitsArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f04mbf(nArg:Integer,bArg:Matrix DoubleFloat,preconArg:Boolean,_ - shiftArg:DoubleFloat,itnlimArg:Integer,msglvlArg:Integer,_ - lrworkArg:Integer,liworkArg:Integer,rtolArg:DoubleFloat,_ - ifailArg:Integer,aprodArg:Union(fn:FileName,fp:Asp28(APROD)),msolveArg:Union(fn:FileName,fp:Asp34(MSOLVE))): Result == + shiftArg:DoubleFloat,itnlimArg:Integer,msglvlArg:Integer,_ + lrworkArg:Integer,liworkArg:Integer,rtolArg:DoubleFloat,_ + ifailArg:Integer,aprodArg:Union(fn:FileName,fp:Asp28(APROD)),_ + msolveArg:Union(fn:FileName,fp:Asp34(MSOLVE))): Result == -- if both asps are AXIOM generated we do not need lrwork liwork -- and will set to 1. -- else believe the user but check that they are >0. if (aprodArg case fp) and (msolveArg case fp) - then - lrworkArg:=1 - liworkArg:=1 - else - lrworkArg:=max(1,lrworkArg) - liworkArg:=max(1,liworkArg) - pushFortranOutputStack(aprodFilename := aspFilename "aprod")$FOP - if aprodArg case fn - then outputAsFortran(aprodArg.fn) - else outputAsFortran(aprodArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(msolveFilename := aspFilename "msolve")$FOP - if msolveArg case fn - then outputAsFortran(msolveArg.fn) - else outputAsFortran(msolveArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([aprodFilename,msolveFilename]$Lisp,_ - "f04mbf",_ - ["n"::S,"precon"::S,"shift"::S,"itnlim"::S,"msglvl"::S_ - ,"lrwork"::S,"liwork"::S,"itn"::S,"anorm"::S,"acond"::S_ - ,"rnorm"::S,"xnorm"::S,"inform"::S,"rtol"::S,"ifail"::S_ - ,"aprod"::S,"msolve"::S,"b"::S,"x"::S,"work"::S,"rwork"::S,"iwork"::S_ - ]$Lisp,_ - ["x"::S,"itn"::S,"anorm"::S,"acond"::S,"rnorm"::S,"xnorm"::S,"inform"::S,"work"::S,"rwork"::S,"iwork"::S,"aprod"::S,"msolve"::S]$Lisp,_ - [["double"::S,["b"::S,"n"::S]$Lisp,"shift"::S_ - ,["x"::S,"n"::S]$Lisp,"anorm"::S,"acond"::S,"rnorm"::S,"xnorm"::S,"rtol"::S,["work"::S,"n"::S,5$Lisp]$Lisp,["rwork"::S,"lrwork"::S]$Lisp_ - ,"aprod"::S,"msolve"::S]$Lisp_ - ,["integer"::S,"n"::S,"itnlim"::S,"msglvl"::S_ - ,"lrwork"::S,"liwork"::S,"itn"::S,"inform"::S,"ifail"::S,["iwork"::S,"liwork"::S]$Lisp]$Lisp_ - ,["logical"::S,"precon"::S]$Lisp_ - ]$Lisp,_ - ["x"::S,"itn"::S,"anorm"::S,"acond"::S,"rnorm"::S,"xnorm"::S,"inform"::S,"rtol"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,preconArg::Any,shiftArg::Any,itnlimArg::Any,msglvlArg::Any,lrworkArg::Any,liworkArg::Any,rtolArg::Any,ifailArg::Any,bArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + then + lrworkArg:=1 + liworkArg:=1 + else + lrworkArg:=max(1,lrworkArg) + liworkArg:=max(1,liworkArg) + pushFortranOutputStack(aprodFilename := aspFilename "aprod")$FOP + if aprodArg case fn + then outputAsFortran(aprodArg.fn) + else outputAsFortran(aprodArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(msolveFilename := aspFilename "msolve")$FOP + if msolveArg case fn + then outputAsFortran(msolveArg.fn) + else outputAsFortran(msolveArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([aprodFilename,msolveFilename]$Lisp,_ + "f04mbf",_ + ["n"::S,"precon"::S,"shift"::S,"itnlim"::S,"msglvl"::S_ + ,"lrwork"::S,"liwork"::S,"itn"::S,"anorm"::S,"acond"::S_ + ,"rnorm"::S,"xnorm"::S,"inform"::S,"rtol"::S,"ifail"::S_ + ,"aprod"::S,"msolve"::S,"b"::S,"x"::S,"work"::S,"rwork"::S,"iwork"::S_ + ]$Lisp,["x"::S,"itn"::S,"anorm"::S,"acond"::S,"rnorm"::S,"xnorm"::S,_ + "inform"::S,"work"::S,"rwork"::S,"iwork"::S,"aprod"::S,_ + "msolve"::S]$Lisp,[["double"::S,["b"::S,"n"::S]$Lisp,"shift"::S_ + ,["x"::S,"n"::S]$Lisp,"anorm"::S,"acond"::S,"rnorm"::S,"xnorm"::S,_ + "rtol"::S,["work"::S,"n"::S,5$Lisp]$Lisp,_ + ["rwork"::S,"lrwork"::S]$Lisp_ + ,"aprod"::S,"msolve"::S]$Lisp_ + ,["integer"::S,"n"::S,"itnlim"::S,"msglvl"::S_ + ,"lrwork"::S,"liwork"::S,"itn"::S,"inform"::S,"ifail"::S,_ + ["iwork"::S,"liwork"::S]$Lisp]$Lisp_ + ,["logical"::S,"precon"::S]$Lisp_ + ]$Lisp,_ + ["x"::S,"itn"::S,"anorm"::S,"acond"::S,"rnorm"::S,"xnorm"::S,_ + "inform"::S,"rtol"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,preconArg::Any,shiftArg::Any,itnlimArg::Any,_ + msglvlArg::Any,lrworkArg::Any,liworkArg::Any,rtolArg::Any,_ + ifailArg::Any,bArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f04mcf(nArg:Integer,alArg:Matrix DoubleFloat,lalArg:Integer,_ - dArg:Matrix DoubleFloat,nrowArg:Matrix Integer,irArg:Integer,_ - bArg:Matrix DoubleFloat,nrbArg:Integer,iselctArg:Integer,_ - nrxArg:Integer,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f04mcf",_ - ["n"::S,"lal"::S,"ir"::S,"nrb"::S,"iselct"::S_ - ,"nrx"::S,"ifail"::S,"al"::S,"d"::S,"nrow"::S,"b"::S,"x"::S_ - ]$Lisp,_ - ["x"::S]$Lisp,_ - [["double"::S,["al"::S,"lal"::S]$Lisp,["d"::S,"n"::S]$Lisp_ - ,["b"::S,"nrb"::S,"ir"::S]$Lisp,["x"::S,"nrx"::S,"ir"::S]$Lisp]$Lisp_ - ,["integer"::S,"n"::S,"lal"::S,["nrow"::S,"n"::S]$Lisp_ - ,"ir"::S,"nrb"::S,"iselct"::S,"nrx"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["x"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,lalArg::Any,irArg::Any,nrbArg::Any,iselctArg::Any,nrxArg::Any,ifailArg::Any,alArg::Any,dArg::Any,nrowArg::Any,bArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + dArg:Matrix DoubleFloat,nrowArg:Matrix Integer,irArg:Integer,_ + bArg:Matrix DoubleFloat,nrbArg:Integer,iselctArg:Integer,_ + nrxArg:Integer,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f04mcf",_ + ["n"::S,"lal"::S,"ir"::S,"nrb"::S,"iselct"::S_ + ,"nrx"::S,"ifail"::S,"al"::S,"d"::S,"nrow"::S,"b"::S,"x"::S_ + ]$Lisp,_ + ["x"::S]$Lisp,_ + [["double"::S,["al"::S,"lal"::S]$Lisp,["d"::S,"n"::S]$Lisp_ + ,["b"::S,"nrb"::S,"ir"::S]$Lisp,["x"::S,"nrx"::S,"ir"::S]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"lal"::S,["nrow"::S,"n"::S]$Lisp_ + ,"ir"::S,"nrb"::S,"iselct"::S,"nrx"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["x"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,lalArg::Any,irArg::Any,nrbArg::Any,iselctArg::Any,_ + nrxArg::Any,ifailArg::Any,alArg::Any,dArg::Any,nrowArg::Any,_ + bArg::Any ])@List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f04qaf(mArg:Integer,nArg:Integer,dampArg:DoubleFloat,_ - atolArg:DoubleFloat,btolArg:DoubleFloat,conlimArg:DoubleFloat,_ - itnlimArg:Integer,msglvlArg:Integer,lrworkArg:Integer,_ - liworkArg:Integer,bArg:Matrix DoubleFloat,ifailArg:Integer,_ - aprodArg:Union(fn:FileName,fp:Asp30(APROD))): Result == - pushFortranOutputStack(aprodFilename := aspFilename "aprod")$FOP - if aprodArg case fn - then outputAsFortran(aprodArg.fn) - else outputAsFortran(aprodArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([aprodFilename]$Lisp,_ - "f04qaf",_ - ["m"::S,"n"::S,"damp"::S,"atol"::S,"btol"::S_ - ,"conlim"::S,"itnlim"::S,"msglvl"::S,"lrwork"::S,"liwork"::S_ - ,"itn"::S,"anorm"::S,"acond"::S,"rnorm"::S,"arnorm"::S_ - ,"xnorm"::S,"inform"::S,"ifail"::S,"aprod"::S,"x"::S,"se"::S,"b"::S,"work"::S,"rwork"::S_ - ,"iwork"::S]$Lisp,_ - ["x"::S,"se"::S,"itn"::S,"anorm"::S,"acond"::S,"rnorm"::S,"arnorm"::S,"xnorm"::S,"inform"::S,"work"::S,"rwork"::S,"iwork"::S,"aprod"::S]$Lisp,_ - [["double"::S,"damp"::S,"atol"::S,"btol"::S_ - ,"conlim"::S,["x"::S,"n"::S]$Lisp,["se"::S,"n"::S]$Lisp,"anorm"::S,"acond"::S,"rnorm"::S,"arnorm"::S,"xnorm"::S,["b"::S,"m"::S]$Lisp_ - ,["work"::S,"n"::S,2$Lisp]$Lisp,["rwork"::S,"lrwork"::S]$Lisp,"aprod"::S]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"itnlim"::S,"msglvl"::S_ - ,"lrwork"::S,"liwork"::S,"itn"::S,"inform"::S,"ifail"::S,["iwork"::S,"liwork"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["x"::S,"se"::S,"itn"::S,"anorm"::S,"acond"::S,"rnorm"::S,"arnorm"::S,"xnorm"::S,"inform"::S,"b"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,nArg::Any,dampArg::Any,atolArg::Any,btolArg::Any,conlimArg::Any,itnlimArg::Any,msglvlArg::Any,lrworkArg::Any,liworkArg::Any,ifailArg::Any,bArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + atolArg:DoubleFloat,btolArg:DoubleFloat,conlimArg:DoubleFloat,_ + itnlimArg:Integer,msglvlArg:Integer,lrworkArg:Integer,_ + liworkArg:Integer,bArg:Matrix DoubleFloat,ifailArg:Integer,_ + aprodArg:Union(fn:FileName,fp:Asp30(APROD))): Result == + pushFortranOutputStack(aprodFilename := aspFilename "aprod")$FOP + if aprodArg case fn + then outputAsFortran(aprodArg.fn) + else outputAsFortran(aprodArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([aprodFilename]$Lisp,_ + "f04qaf",_ + ["m"::S,"n"::S,"damp"::S,"atol"::S,"btol"::S_ + ,"conlim"::S,"itnlim"::S,"msglvl"::S,"lrwork"::S,"liwork"::S_ + ,"itn"::S,"anorm"::S,"acond"::S,"rnorm"::S,"arnorm"::S_ + ,"xnorm"::S,"inform"::S,"ifail"::S,"aprod"::S,"x"::S,"se"::S,_ + "b"::S,"work"::S,"rwork"::S_ + ,"iwork"::S]$Lisp,_ + ["x"::S,"se"::S,"itn"::S,"anorm"::S,"acond"::S,"rnorm"::S,_ + "arnorm"::S,"xnorm"::S,"inform"::S,"work"::S,"rwork"::S,_ + "iwork"::S,"aprod"::S]$Lisp,_ + [["double"::S,"damp"::S,"atol"::S,"btol"::S_ + ,"conlim"::S,["x"::S,"n"::S]$Lisp,["se"::S,"n"::S]$Lisp,_ + "anorm"::S,"acond"::S,"rnorm"::S,"arnorm"::S,"xnorm"::S,_ + ["b"::S,"m"::S]$Lisp_ + ,["work"::S,"n"::S,2$Lisp]$Lisp,["rwork"::S,"lrwork"::S]$Lisp,_ + "aprod"::S]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"itnlim"::S,"msglvl"::S_ + ,"lrwork"::S,"liwork"::S,"itn"::S,"inform"::S,"ifail"::S,_ + ["iwork"::S,"liwork"::S]$Lisp]$Lisp]$Lisp,_ + ["x"::S,"se"::S,"itn"::S,"anorm"::S,"acond"::S,"rnorm"::S,_ + "arnorm"::S,"xnorm"::S,"inform"::S,"b"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,nArg::Any,dampArg::Any,atolArg::Any,btolArg::Any,_ + conlimArg::Any,itnlimArg::Any,msglvlArg::Any,lrworkArg::Any,_ + liworkArg::Any,ifailArg::Any,bArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result @ <>= @@ -75149,7 +75529,9 @@ NagLinearEquationSolvingPackage(): Exports == Implementation where ++ Keywords: ++ Examples: ++ References: -++ Description: Support functions for the NAG Library Link functions +++ Description: +++ Support functions for the NAG Library Link functions + NAGLinkSupportPackage() : exports == implementation where exports ==> with @@ -75161,14 +75543,14 @@ NAGLinkSupportPackage() : exports == implementation where aspFilename : String -> String ++ aspFilename("f") returns a String consisting of "f" suffixed with ++ an extension identifying the current AXIOM session. - dimensionsOf : (Symbol, Matrix DoubleFloat) -> SExpression - ++ dimensionsOf(s,m) \undocumented{} - dimensionsOf : (Symbol, Matrix Integer) -> SExpression - ++ dimensionsOf(s,m) \undocumented{} + dimensionsOf : (Symbol, Matrix DoubleFloat) -> SExpression + ++ dimensionsOf(s,m) \undocumented{} + dimensionsOf : (Symbol, Matrix Integer) -> SExpression + ++ dimensionsOf(s,m) \undocumented{} checkPrecision : () -> Boolean - ++ checkPrecision() \undocumented{} + ++ checkPrecision() \undocumented{} restorePrecision : () -> Void - ++ restorePrecision() \undocumented{} + ++ restorePrecision() \undocumented{} implementation ==> add makeAs: (Symbol,Symbol) -> Symbol @@ -75179,10 +75561,12 @@ NAGLinkSupportPackage() : exports == implementation where import Symbol checkPrecision():Boolean == - (_$fortranPrecision$Lisp = "single"::Symbol) and (_$nagEnforceDouble$Lisp) => + (_$fortranPrecision$Lisp = "single"::Symbol) and _ + (_$nagEnforceDouble$Lisp) => systemCommand("set fortran precision double")$MoreSystemCommands if _$nagMessages$Lisp then - print("*** Warning: Resetting fortran precision to double")$PrintPackage + print("*** Warning: Resetting fortran precision to double")_ + $PrintPackage true false @@ -79078,7 +79462,6 @@ NAGLinkSupportPackage() : exports == implementation where ++ This package uses the NAG Library to calculate the numerical value of ++ definite integrals in one or more dimensions and to evaluate ++ weights and abscissae of integration rules. -++ See \downlink{Manual Page}{manpageXXd01}. NagIntegrationPackage(): Exports == Implementation where S ==> Symbol @@ -79086,14 +79469,14 @@ NagIntegrationPackage(): Exports == Implementation where Exports ==> with d01ajf : (DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat,_ - Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(F))) -> Result + Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(F))) -> Result ++ d01ajf(a,b,epsabs,epsrel,lw,liw,ifail,f) ++ is a general-purpose integrator which calculates an ++ approximation to the integral of a function f(x) over a finite ++ interval [a,b]: ++ See \downlink{Manual Page}{manpageXXd01ajf}. d01akf : (DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat,_ - Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(F))) -> Result + Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(F))) -> Result ++ d01akf(a,b,epsabs,epsrel,lw,liw,ifail,f) ++ is an adaptive integrator, especially suited to ++ oscillating, non-singular integrands, which calculates an @@ -79101,45 +79484,50 @@ NagIntegrationPackage(): Exports == Implementation where ++ interval [a,b]: ++ See \downlink{Manual Page}{manpageXXd01akf}. d01alf : (DoubleFloat,DoubleFloat,Integer,Matrix DoubleFloat,_ - DoubleFloat,DoubleFloat,Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(F))) -> Result + DoubleFloat,DoubleFloat,Integer,Integer,Integer,_ + Union(fn:FileName,fp:Asp1(F))) -> Result ++ d01alf(a,b,npts,points,epsabs,epsrel,lw,liw,ifail,f) ++ is a general purpose integrator which calculates an ++ approximation to the integral of a function f(x) over a finite ++ interval [a,b]: ++ See \downlink{Manual Page}{manpageXXd01alf}. d01amf : (DoubleFloat,Integer,DoubleFloat,DoubleFloat,_ - Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(F))) -> Result + Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(F))) -> Result ++ d01amf(bound,inf,epsabs,epsrel,lw,liw,ifail,f) ++ calculates an approximation to the integral of a function ++ f(x) over an infinite or semi-infinite interval [a,b]: ++ See \downlink{Manual Page}{manpageXXd01amf}. d01anf : (DoubleFloat,DoubleFloat,DoubleFloat,Integer,_ - DoubleFloat,DoubleFloat,Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(G))) -> Result + DoubleFloat,DoubleFloat,Integer,Integer,Integer,_ + Union(fn:FileName,fp:Asp1(G))) -> Result ++ d01anf(a,b,omega,key,epsabs,epsrel,lw,liw,ifail,g) ++ calculates an approximation to the sine or the cosine ++ transform of a function g over [a,b]: ++ See \downlink{Manual Page}{manpageXXd01anf}. d01apf : (DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat,_ - Integer,DoubleFloat,DoubleFloat,Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(G))) -> Result + Integer,DoubleFloat,DoubleFloat,Integer,Integer,Integer,_ + Union(fn:FileName,fp:Asp1(G))) -> Result ++ d01apf(a,b,alfa,beta,key,epsabs,epsrel,lw,liw,ifail,g) ++ is an adaptive integrator which calculates an ++ approximation to the integral of a function g(x)w(x) over a ++ finite interval [a,b]: ++ See \downlink{Manual Page}{manpageXXd01apf}. d01aqf : (DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat,_ - DoubleFloat,Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(G))) -> Result + DoubleFloat,Integer,Integer,Integer,_ + Union(fn:FileName,fp:Asp1(G))) -> Result ++ d01aqf(a,b,c,epsabs,epsrel,lw,liw,ifail,g) ++ calculates an approximation to the Hilbert transform of a ++ function g(x) over [a,b]: ++ See \downlink{Manual Page}{manpageXXd01aqf}. d01asf : (DoubleFloat,DoubleFloat,Integer,DoubleFloat,_ - Integer,Integer,Integer,Integer,Union(fn:FileName,fp:Asp1(G))) -> Result + Integer,Integer,Integer,Integer,_ + Union(fn:FileName,fp:Asp1(G))) -> Result ++ d01asf(a,omega,key,epsabs,limlst,lw,liw,ifail,g) ++ calculates an approximation to the sine or the cosine ++ transform of a function g over [a,infty): ++ See \downlink{Manual Page}{manpageXXd01asf}. d01bbf : (DoubleFloat,DoubleFloat,Integer,Integer,_ - Integer,Integer) -> Result + Integer,Integer) -> Result ++ d01bbf(a,b,itype,n,gtype,ifail) ++ returns the weight appropriate to a ++ Gaussian quadrature. @@ -79147,7 +79535,8 @@ NagIntegrationPackage(): Exports == Implementation where ++ Laguerre and Gauss-Hermite. ++ See \downlink{Manual Page}{manpageXXd01bbf}. d01fcf : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer,_ - DoubleFloat,Integer,Integer,Integer,Union(fn:FileName,fp:Asp4(FUNCTN))) -> Result + DoubleFloat,Integer,Integer,Integer,_ + Union(fn:FileName,fp:Asp4(FUNCTN))) -> Result ++ d01fcf(ndim,a,b,maxpts,eps,lenwrk,minpts,ifail,functn) ++ attempts to evaluate a multi-dimensional integral (up to ++ 15 dimensions), with constant and finite limits, to a specified @@ -79161,7 +79550,8 @@ NagIntegrationPackage(): Exports == Implementation where ++ according to a method due to Gill and Miller. ++ See \downlink{Manual Page}{manpageXXd01gaf}. d01gbf : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer,_ - DoubleFloat,Integer,Integer,Matrix DoubleFloat,Integer,Union(fn:FileName,fp:Asp4(FUNCTN))) -> Result + DoubleFloat,Integer,Integer,Matrix DoubleFloat,Integer,_ + Union(fn:FileName,fp:Asp4(FUNCTN))) -> Result ++ d01gbf(ndim,a,b,maxcls,eps,lenwrk,mincls,wrkstr,ifail,functn) ++ returns an approximation to the integral of a function ++ over a hyper-rectangular region, using a Monte Carlo method. An @@ -79186,279 +79576,306 @@ NagIntegrationPackage(): Exports == Implementation where d01ajf(aArg:DoubleFloat,bArg:DoubleFloat,epsabsArg:DoubleFloat,_ - epsrelArg:DoubleFloat,lwArg:Integer,liwArg:Integer,_ - ifailArg:Integer,fArg:Union(fn:FileName,fp:Asp1(F))): Result == - pushFortranOutputStack(fFilename := aspFilename "f")$FOP - if fArg case fn - then outputAsFortran(fArg.fn) - else outputAsFortran(fArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([fFilename]$Lisp,_ - "d01ajf",_ - ["a"::S,"b"::S,"epsabs"::S,"epsrel"::S,"lw"::S_ - ,"liw"::S,"result"::S,"abserr"::S,"ifail"::S,"f"::S_ - ,"w"::S,"iw"::S]$Lisp,_ - ["result"::S,"abserr"::S,"w"::S,"iw"::S,"f"::S]$Lisp,_ - [["double"::S,"a"::S,"b"::S,"epsabs"::S,"epsrel"::S_ - ,"result"::S,"abserr"::S,["w"::S,"lw"::S]$Lisp,"f"::S]$Lisp_ - ,["integer"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_ - ,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_ - [([aArg::Any,bArg::Any,epsabsArg::Any,epsrelArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + epsrelArg:DoubleFloat,lwArg:Integer,liwArg:Integer,_ + ifailArg:Integer,fArg:Union(fn:FileName,fp:Asp1(F))): Result == + pushFortranOutputStack(fFilename := aspFilename "f")$FOP + if fArg case fn + then outputAsFortran(fArg.fn) + else outputAsFortran(fArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([fFilename]$Lisp,_ + "d01ajf",_ + ["a"::S,"b"::S,"epsabs"::S,"epsrel"::S,"lw"::S_ + ,"liw"::S,"result"::S,"abserr"::S,"ifail"::S,"f"::S_ + ,"w"::S,"iw"::S]$Lisp,_ + ["result"::S,"abserr"::S,"w"::S,"iw"::S,"f"::S]$Lisp,_ + [["double"::S,"a"::S,"b"::S,"epsabs"::S,"epsrel"::S_ + ,"result"::S,"abserr"::S,["w"::S,"lw"::S]$Lisp,"f"::S]$Lisp_ + ,["integer"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_ + [([aArg::Any,bArg::Any,epsabsArg::Any,epsrelArg::Any,lwArg::Any,_ + liwArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d01akf(aArg:DoubleFloat,bArg:DoubleFloat,epsabsArg:DoubleFloat,_ - epsrelArg:DoubleFloat,lwArg:Integer,liwArg:Integer,_ - ifailArg:Integer,fArg:Union(fn:FileName,fp:Asp1(F))): Result == - pushFortranOutputStack(fFilename := aspFilename "f")$FOP - if fArg case fn - then outputAsFortran(fArg.fn) - else outputAsFortran(fArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([fFilename]$Lisp,_ - "d01akf",_ - ["a"::S,"b"::S,"epsabs"::S,"epsrel"::S,"lw"::S_ - ,"liw"::S,"result"::S,"abserr"::S,"ifail"::S,"f"::S_ - ,"w"::S,"iw"::S]$Lisp,_ - ["result"::S,"abserr"::S,"w"::S,"iw"::S,"f"::S]$Lisp,_ - [["double"::S,"a"::S,"b"::S,"epsabs"::S,"epsrel"::S_ - ,"result"::S,"abserr"::S,["w"::S,"lw"::S]$Lisp,"f"::S]$Lisp_ - ,["integer"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_ - ,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_ - [([aArg::Any,bArg::Any,epsabsArg::Any,epsrelArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + epsrelArg:DoubleFloat,lwArg:Integer,liwArg:Integer,_ + ifailArg:Integer,fArg:Union(fn:FileName,fp:Asp1(F))): Result == + pushFortranOutputStack(fFilename := aspFilename "f")$FOP + if fArg case fn + then outputAsFortran(fArg.fn) + else outputAsFortran(fArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([fFilename]$Lisp,_ + "d01akf",_ + ["a"::S,"b"::S,"epsabs"::S,"epsrel"::S,"lw"::S_ + ,"liw"::S,"result"::S,"abserr"::S,"ifail"::S,"f"::S_ + ,"w"::S,"iw"::S]$Lisp,_ + ["result"::S,"abserr"::S,"w"::S,"iw"::S,"f"::S]$Lisp,_ + [["double"::S,"a"::S,"b"::S,"epsabs"::S,"epsrel"::S_ + ,"result"::S,"abserr"::S,["w"::S,"lw"::S]$Lisp,"f"::S]$Lisp_ + ,["integer"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_ + [([aArg::Any,bArg::Any,epsabsArg::Any,epsrelArg::Any,lwArg::Any,_ + liwArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d01alf(aArg:DoubleFloat,bArg:DoubleFloat,nptsArg:Integer,_ - pointsArg:Matrix DoubleFloat,epsabsArg:DoubleFloat,epsrelArg:DoubleFloat,_ - lwArg:Integer,liwArg:Integer,ifailArg:Integer,_ - fArg:Union(fn:FileName,fp:Asp1(F))): Result == - pushFortranOutputStack(fFilename := aspFilename "f")$FOP - if fArg case fn - then outputAsFortran(fArg.fn) - else outputAsFortran(fArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([fFilename]$Lisp,_ - "d01alf",_ - ["a"::S,"b"::S,"npts"::S,"epsabs"::S,"epsrel"::S_ - ,"lw"::S,"liw"::S,"result"::S,"abserr"::S,"ifail"::S_ - ,"f"::S,"points"::S,"w"::S,"iw"::S]$Lisp,_ - ["result"::S,"abserr"::S,"w"::S,"iw"::S,"f"::S]$Lisp,_ - [["double"::S,"a"::S,"b"::S,["points"::S,"*"::S]$Lisp_ - ,"epsabs"::S,"epsrel"::S,"result"::S,"abserr"::S,["w"::S,"lw"::S]$Lisp,"f"::S]$Lisp_ - ,["integer"::S,"npts"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_ - ,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_ - [([aArg::Any,bArg::Any,nptsArg::Any,epsabsArg::Any,epsrelArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any,pointsArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + pointsArg:Matrix DoubleFloat,epsabsArg:DoubleFloat,_ + epsrelArg:DoubleFloat,_ + lwArg:Integer,liwArg:Integer,ifailArg:Integer,_ + fArg:Union(fn:FileName,fp:Asp1(F))): Result == + pushFortranOutputStack(fFilename := aspFilename "f")$FOP + if fArg case fn + then outputAsFortran(fArg.fn) + else outputAsFortran(fArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([fFilename]$Lisp,_ + "d01alf",_ + ["a"::S,"b"::S,"npts"::S,"epsabs"::S,"epsrel"::S_ + ,"lw"::S,"liw"::S,"result"::S,"abserr"::S,"ifail"::S_ + ,"f"::S,"points"::S,"w"::S,"iw"::S]$Lisp,_ + ["result"::S,"abserr"::S,"w"::S,"iw"::S,"f"::S]$Lisp,_ + [["double"::S,"a"::S,"b"::S,["points"::S,"*"::S]$Lisp_ + ,"epsabs"::S,"epsrel"::S,"result"::S,"abserr"::S,_ + ["w"::S,"lw"::S]$Lisp,"f"::S]$Lisp_ + ,["integer"::S,"npts"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_ + [([aArg::Any,bArg::Any,nptsArg::Any,epsabsArg::Any,epsrelArg::Any,_ + lwArg::Any,liwArg::Any,ifailArg::Any,pointsArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d01amf(boundArg:DoubleFloat,infArg:Integer,epsabsArg:DoubleFloat,_ - epsrelArg:DoubleFloat,lwArg:Integer,liwArg:Integer,_ - ifailArg:Integer,fArg:Union(fn:FileName,fp:Asp1(F))): Result == - pushFortranOutputStack(fFilename := aspFilename "f")$FOP - if fArg case fn - then outputAsFortran(fArg.fn) - else outputAsFortran(fArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([fFilename]$Lisp,_ - "d01amf",_ - ["bound"::S,"inf"::S,"epsabs"::S,"epsrel"::S,"lw"::S_ - ,"liw"::S,"result"::S,"abserr"::S,"ifail"::S,"f"::S_ - ,"w"::S,"iw"::S]$Lisp,_ - ["result"::S,"abserr"::S,"w"::S,"iw"::S,"f"::S]$Lisp,_ - [["double"::S,"bound"::S,"epsabs"::S,"epsrel"::S_ - ,"result"::S,"abserr"::S,["w"::S,"lw"::S]$Lisp,"f"::S]$Lisp_ - ,["integer"::S,"inf"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_ - ,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_ - [([boundArg::Any,infArg::Any,epsabsArg::Any,epsrelArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + epsrelArg:DoubleFloat,lwArg:Integer,liwArg:Integer,_ + ifailArg:Integer,fArg:Union(fn:FileName,fp:Asp1(F))): Result == + pushFortranOutputStack(fFilename := aspFilename "f")$FOP + if fArg case fn + then outputAsFortran(fArg.fn) + else outputAsFortran(fArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([fFilename]$Lisp,_ + "d01amf",_ + ["bound"::S,"inf"::S,"epsabs"::S,"epsrel"::S,"lw"::S_ + ,"liw"::S,"result"::S,"abserr"::S,"ifail"::S,"f"::S_ + ,"w"::S,"iw"::S]$Lisp,_ + ["result"::S,"abserr"::S,"w"::S,"iw"::S,"f"::S]$Lisp,_ + [["double"::S,"bound"::S,"epsabs"::S,"epsrel"::S_ + ,"result"::S,"abserr"::S,["w"::S,"lw"::S]$Lisp,"f"::S]$Lisp_ + ,["integer"::S,"inf"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_ + [([boundArg::Any,infArg::Any,epsabsArg::Any,epsrelArg::Any,_ + lwArg::Any,liwArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d01anf(aArg:DoubleFloat,bArg:DoubleFloat,omegaArg:DoubleFloat,_ - keyArg:Integer,epsabsArg:DoubleFloat,epsrelArg:DoubleFloat,_ - lwArg:Integer,liwArg:Integer,ifailArg:Integer,_ - gArg:Union(fn:FileName,fp:Asp1(G))): Result == - pushFortranOutputStack(gFilename := aspFilename "g")$FOP - if gArg case fn - then outputAsFortran(gArg.fn) - else outputAsFortran(gArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([gFilename]$Lisp,_ - "d01anf",_ - ["a"::S,"b"::S,"omega"::S,"key"::S,"epsabs"::S_ - ,"epsrel"::S,"lw"::S,"liw"::S,"result"::S,"abserr"::S_ - ,"ifail"::S,"g"::S,"w"::S,"iw"::S]$Lisp,_ - ["result"::S,"abserr"::S,"w"::S,"iw"::S,"g"::S]$Lisp,_ - [["double"::S,"a"::S,"b"::S,"omega"::S,"epsabs"::S_ - ,"epsrel"::S,"result"::S,"abserr"::S,["w"::S,"lw"::S]$Lisp,"g"::S]$Lisp_ - ,["integer"::S,"key"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_ - ,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_ - [([aArg::Any,bArg::Any,omegaArg::Any,keyArg::Any,epsabsArg::Any,epsrelArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + keyArg:Integer,epsabsArg:DoubleFloat,epsrelArg:DoubleFloat,_ + lwArg:Integer,liwArg:Integer,ifailArg:Integer,_ + gArg:Union(fn:FileName,fp:Asp1(G))): Result == + pushFortranOutputStack(gFilename := aspFilename "g")$FOP + if gArg case fn + then outputAsFortran(gArg.fn) + else outputAsFortran(gArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([gFilename]$Lisp,_ + "d01anf",_ + ["a"::S,"b"::S,"omega"::S,"key"::S,"epsabs"::S_ + ,"epsrel"::S,"lw"::S,"liw"::S,"result"::S,"abserr"::S_ + ,"ifail"::S,"g"::S,"w"::S,"iw"::S]$Lisp,_ + ["result"::S,"abserr"::S,"w"::S,"iw"::S,"g"::S]$Lisp,_ + [["double"::S,"a"::S,"b"::S,"omega"::S,"epsabs"::S_ + ,"epsrel"::S,"result"::S,"abserr"::S,["w"::S,"lw"::S]$Lisp,_ + "g"::S]$Lisp_ + ,["integer"::S,"key"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_ + [([aArg::Any,bArg::Any,omegaArg::Any,keyArg::Any,epsabsArg::Any,_ + epsrelArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d01apf(aArg:DoubleFloat,bArg:DoubleFloat,alfaArg:DoubleFloat,_ - betaArg:DoubleFloat,keyArg:Integer,epsabsArg:DoubleFloat,_ - epsrelArg:DoubleFloat,lwArg:Integer,liwArg:Integer,_ - ifailArg:Integer,gArg:Union(fn:FileName,fp:Asp1(G))): Result == - pushFortranOutputStack(gFilename := aspFilename "g")$FOP - if gArg case fn - then outputAsFortran(gArg.fn) - else outputAsFortran(gArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([gFilename]$Lisp,_ - "d01apf",_ - ["a"::S,"b"::S,"alfa"::S,"beta"::S,"key"::S_ - ,"epsabs"::S,"epsrel"::S,"lw"::S,"liw"::S,"result"::S_ - ,"abserr"::S,"ifail"::S,"g"::S,"w"::S,"iw"::S]$Lisp,_ - ["result"::S,"abserr"::S,"w"::S,"iw"::S,"g"::S]$Lisp,_ - [["double"::S,"a"::S,"b"::S,"alfa"::S,"beta"::S_ - ,"epsabs"::S,"epsrel"::S,"result"::S,"abserr"::S,["w"::S,"lw"::S]$Lisp,"g"::S]$Lisp_ - ,["integer"::S,"key"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_ - ,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_ - [([aArg::Any,bArg::Any,alfaArg::Any,betaArg::Any,keyArg::Any,epsabsArg::Any,epsrelArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + betaArg:DoubleFloat,keyArg:Integer,epsabsArg:DoubleFloat,_ + epsrelArg:DoubleFloat,lwArg:Integer,liwArg:Integer,_ + ifailArg:Integer,gArg:Union(fn:FileName,fp:Asp1(G))): Result == + pushFortranOutputStack(gFilename := aspFilename "g")$FOP + if gArg case fn + then outputAsFortran(gArg.fn) + else outputAsFortran(gArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([gFilename]$Lisp,_ + "d01apf",_ + ["a"::S,"b"::S,"alfa"::S,"beta"::S,"key"::S_ + ,"epsabs"::S,"epsrel"::S,"lw"::S,"liw"::S,"result"::S_ + ,"abserr"::S,"ifail"::S,"g"::S,"w"::S,"iw"::S]$Lisp,_ + ["result"::S,"abserr"::S,"w"::S,"iw"::S,"g"::S]$Lisp,_ + [["double"::S,"a"::S,"b"::S,"alfa"::S,"beta"::S_ + ,"epsabs"::S,"epsrel"::S,"result"::S,"abserr"::S,_ + ["w"::S,"lw"::S]$Lisp,"g"::S]$Lisp_ + ,["integer"::S,"key"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_ + [([aArg::Any,bArg::Any,alfaArg::Any,betaArg::Any,keyArg::Any,_ + epsabsArg::Any,epsrelArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d01aqf(aArg:DoubleFloat,bArg:DoubleFloat,cArg:DoubleFloat,_ - epsabsArg:DoubleFloat,epsrelArg:DoubleFloat,lwArg:Integer,_ - liwArg:Integer,ifailArg:Integer,gArg:Union(fn:FileName,fp:Asp1(G))): Result == - pushFortranOutputStack(gFilename := aspFilename "g")$FOP - if gArg case fn - then outputAsFortran(gArg.fn) - else outputAsFortran(gArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([gFilename]$Lisp,_ - "d01aqf",_ - ["a"::S,"b"::S,"c"::S,"epsabs"::S,"epsrel"::S_ - ,"lw"::S,"liw"::S,"result"::S,"abserr"::S,"ifail"::S_ - ,"g"::S,"w"::S,"iw"::S]$Lisp,_ - ["result"::S,"abserr"::S,"w"::S,"iw"::S,"g"::S]$Lisp,_ - [["double"::S,"a"::S,"b"::S,"c"::S,"epsabs"::S_ - ,"epsrel"::S,"result"::S,"abserr"::S,["w"::S,"lw"::S]$Lisp,"g"::S]$Lisp_ - ,["integer"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_ - ,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_ - [([aArg::Any,bArg::Any,cArg::Any,epsabsArg::Any,epsrelArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + epsabsArg:DoubleFloat,epsrelArg:DoubleFloat,lwArg:Integer,_ + liwArg:Integer,ifailArg:Integer,_ + gArg:Union(fn:FileName,fp:Asp1(G))): Result == + pushFortranOutputStack(gFilename := aspFilename "g")$FOP + if gArg case fn + then outputAsFortran(gArg.fn) + else outputAsFortran(gArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([gFilename]$Lisp,_ + "d01aqf",_ + ["a"::S,"b"::S,"c"::S,"epsabs"::S,"epsrel"::S_ + ,"lw"::S,"liw"::S,"result"::S,"abserr"::S,"ifail"::S_ + ,"g"::S,"w"::S,"iw"::S]$Lisp,_ + ["result"::S,"abserr"::S,"w"::S,"iw"::S,"g"::S]$Lisp,_ + [["double"::S,"a"::S,"b"::S,"c"::S,"epsabs"::S_ + ,"epsrel"::S,"result"::S,"abserr"::S,_ + ["w"::S,"lw"::S]$Lisp,"g"::S]$Lisp_ + ,["integer"::S,"lw"::S,"liw"::S,["iw"::S,"liw"::S]$Lisp_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["result"::S,"abserr"::S,"w"::S,"iw"::S,"ifail"::S]$Lisp,_ + [([aArg::Any,bArg::Any,cArg::Any,epsabsArg::Any,epsrelArg::Any,_ + lwArg::Any,liwArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d01asf(aArg:DoubleFloat,omegaArg:DoubleFloat,keyArg:Integer,_ - epsabsArg:DoubleFloat,limlstArg:Integer,lwArg:Integer,_ - liwArg:Integer,ifailArg:Integer,gArg:Union(fn:FileName,fp:Asp1(G))): Result == - pushFortranOutputStack(gFilename := aspFilename "g")$FOP - if gArg case fn - then outputAsFortran(gArg.fn) - else outputAsFortran(gArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([gFilename]$Lisp,_ - "d01asf",_ - ["a"::S,"omega"::S,"key"::S,"epsabs"::S,"limlst"::S_ - ,"lw"::S,"liw"::S,"result"::S,"abserr"::S,"lst"::S_ - ,"ifail"::S,"g"::S,"erlst"::S,"rslst"::S,"ierlst"::S,"iw"::S,"w"::S_ - ]$Lisp,_ - ["result"::S,"abserr"::S,"lst"::S,"erlst"::S,"rslst"::S,"ierlst"::S,"iw"::S,"w"::S,"g"::S]$Lisp,_ - [["double"::S,"a"::S,"omega"::S,"epsabs"::S_ - ,"result"::S,"abserr"::S,["erlst"::S,"limlst"::S]$Lisp,["rslst"::S,"limlst"::S]$Lisp,["w"::S,"lw"::S]$Lisp,"g"::S]$Lisp_ - ,["integer"::S,"key"::S,"limlst"::S,"lw"::S_ - ,"liw"::S,"lst"::S,["ierlst"::S,"limlst"::S]$Lisp,["iw"::S,"liw"::S]$Lisp,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["result"::S,"abserr"::S,"lst"::S,"erlst"::S,"rslst"::S,"ierlst"::S,"iw"::S,"ifail"::S]$Lisp,_ - [([aArg::Any,omegaArg::Any,keyArg::Any,epsabsArg::Any,limlstArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + epsabsArg:DoubleFloat,limlstArg:Integer,lwArg:Integer,_ + liwArg:Integer,ifailArg:Integer,_ + gArg:Union(fn:FileName,fp:Asp1(G))): Result == + pushFortranOutputStack(gFilename := aspFilename "g")$FOP + if gArg case fn + then outputAsFortran(gArg.fn) + else outputAsFortran(gArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([gFilename]$Lisp,_ + "d01asf",_ + ["a"::S,"omega"::S,"key"::S,"epsabs"::S,"limlst"::S_ + ,"lw"::S,"liw"::S,"result"::S,"abserr"::S,"lst"::S_ + ,"ifail"::S,"g"::S,"erlst"::S,"rslst"::S,"ierlst"::S,"iw"::S,"w"::S_ + ]$Lisp,_ + ["result"::S,"abserr"::S,"lst"::S,"erlst"::S,"rslst"::S,_ + "ierlst"::S,"iw"::S,"w"::S,"g"::S]$Lisp,_ + [["double"::S,"a"::S,"omega"::S,"epsabs"::S_ + ,"result"::S,"abserr"::S,["erlst"::S,"limlst"::S]$Lisp,_ + ["rslst"::S,"limlst"::S]$Lisp,["w"::S,"lw"::S]$Lisp,"g"::S]$Lisp_ + ,["integer"::S,"key"::S,"limlst"::S,"lw"::S_ + ,"liw"::S,"lst"::S,["ierlst"::S,"limlst"::S]$Lisp,_ + ["iw"::S,"liw"::S]$Lisp,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["result"::S,"abserr"::S,"lst"::S,"erlst"::S,"rslst"::S,_ + "ierlst"::S,"iw"::S,"ifail"::S]$Lisp,_ + [([aArg::Any,omegaArg::Any,keyArg::Any,epsabsArg::Any,_ + limlstArg::Any,lwArg::Any,liwArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d01bbf(aArg:DoubleFloat,bArg:DoubleFloat,itypeArg:Integer,_ - nArg:Integer,gtypeArg:Integer,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "d01bbf",_ - ["a"::S,"b"::S,"itype"::S,"n"::S,"gtype"::S_ - ,"ifail"::S,"weight"::S,"abscis"::S]$Lisp,_ - ["weight"::S,"abscis"::S]$Lisp,_ - [["double"::S,"a"::S,"b"::S,["weight"::S,"n"::S]$Lisp_ - ,["abscis"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"itype"::S,"n"::S,"gtype"::S_ - ,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["weight"::S,"abscis"::S,"ifail"::S]$Lisp,_ - [([aArg::Any,bArg::Any,itypeArg::Any,nArg::Any,gtypeArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + nArg:Integer,gtypeArg:Integer,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "d01bbf",_ + ["a"::S,"b"::S,"itype"::S,"n"::S,"gtype"::S_ + ,"ifail"::S,"weight"::S,"abscis"::S]$Lisp,_ + ["weight"::S,"abscis"::S]$Lisp,_ + [["double"::S,"a"::S,"b"::S,["weight"::S,"n"::S]$Lisp_ + ,["abscis"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"itype"::S,"n"::S,"gtype"::S_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["weight"::S,"abscis"::S,"ifail"::S]$Lisp,_ + [([aArg::Any,bArg::Any,itypeArg::Any,nArg::Any,_ + gtypeArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d01fcf(ndimArg:Integer,aArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,_ - maxptsArg:Integer,epsArg:DoubleFloat,lenwrkArg:Integer,_ - minptsArg:Integer,ifailArg:Integer,functnArg:Union(fn:FileName,fp:Asp4(FUNCTN))): Result == - pushFortranOutputStack(functnFilename := aspFilename "functn")$FOP - if functnArg case fn - then outputAsFortran(functnArg.fn) - else outputAsFortran(functnArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([functnFilename]$Lisp,_ - "d01fcf",_ - ["ndim"::S,"maxpts"::S,"eps"::S,"lenwrk"::S,"acc"::S_ - ,"finval"::S,"minpts"::S,"ifail"::S,"functn"::S,"a"::S,"b"::S,"wrkstr"::S]$Lisp,_ - ["acc"::S,"finval"::S,"wrkstr"::S,"functn"::S]$Lisp,_ - [["double"::S,["a"::S,"ndim"::S]$Lisp,["b"::S,"ndim"::S]$Lisp_ - ,"eps"::S,"acc"::S,"finval"::S,["wrkstr"::S,"lenwrk"::S]$Lisp,"functn"::S]$Lisp_ - ,["integer"::S,"ndim"::S,"maxpts"::S,"lenwrk"::S_ - ,"minpts"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["acc"::S,"finval"::S,"minpts"::S,"ifail"::S]$Lisp,_ - [([ndimArg::Any,maxptsArg::Any,epsArg::Any,lenwrkArg::Any,minptsArg::Any,ifailArg::Any,aArg::Any,bArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + maxptsArg:Integer,epsArg:DoubleFloat,lenwrkArg:Integer,_ + minptsArg:Integer,ifailArg:Integer,_ + functnArg:Union(fn:FileName,fp:Asp4(FUNCTN))): Result == + pushFortranOutputStack(functnFilename := aspFilename "functn")$FOP + if functnArg case fn + then outputAsFortran(functnArg.fn) + else outputAsFortran(functnArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([functnFilename]$Lisp,_ + "d01fcf",_ + ["ndim"::S,"maxpts"::S,"eps"::S,"lenwrk"::S,"acc"::S_ + ,"finval"::S,"minpts"::S,"ifail"::S,"functn"::S,"a"::S,_ + "b"::S,"wrkstr"::S]$Lisp,_ + ["acc"::S,"finval"::S,"wrkstr"::S,"functn"::S]$Lisp,_ + [["double"::S,["a"::S,"ndim"::S]$Lisp,["b"::S,"ndim"::S]$Lisp_ + ,"eps"::S,"acc"::S,"finval"::S,["wrkstr"::S,"lenwrk"::S]$Lisp,_ + "functn"::S]$Lisp_ + ,["integer"::S,"ndim"::S,"maxpts"::S,"lenwrk"::S_ + ,"minpts"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["acc"::S,"finval"::S,"minpts"::S,"ifail"::S]$Lisp,_ + [([ndimArg::Any,maxptsArg::Any,epsArg::Any,lenwrkArg::Any,_ + minptsArg::Any,ifailArg::Any,aArg::Any,bArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d01gaf(xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,nArg:Integer,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "d01gaf",_ - ["n"::S,"ans"::S,"er"::S,"ifail"::S,"x"::S,"y"::S]$Lisp,_ - ["ans"::S,"er"::S]$Lisp,_ - [["double"::S,["x"::S,"n"::S]$Lisp,["y"::S,"n"::S]$Lisp_ - ,"ans"::S,"er"::S]$Lisp_ - ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["ans"::S,"er"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,ifailArg::Any,xArg::Any,yArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "d01gaf",_ + ["n"::S,"ans"::S,"er"::S,"ifail"::S,"x"::S,"y"::S]$Lisp,_ + ["ans"::S,"er"::S]$Lisp,_ + [["double"::S,["x"::S,"n"::S]$Lisp,["y"::S,"n"::S]$Lisp_ + ,"ans"::S,"er"::S]$Lisp_ + ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["ans"::S,"er"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,ifailArg::Any,xArg::Any,yArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d01gbf(ndimArg:Integer,aArg:Matrix DoubleFloat,bArg:Matrix DoubleFloat,_ - maxclsArg:Integer,epsArg:DoubleFloat,lenwrkArg:Integer,_ - minclsArg:Integer,wrkstrArg:Matrix DoubleFloat,ifailArg:Integer,_ - functnArg:Union(fn:FileName,fp:Asp4(FUNCTN))): Result == - pushFortranOutputStack(functnFilename := aspFilename "functn")$FOP - if functnArg case fn - then outputAsFortran(functnArg.fn) - else outputAsFortran(functnArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([functnFilename]$Lisp,_ - "d01gbf",_ - ["ndim"::S,"maxcls"::S,"eps"::S,"lenwrk"::S,"acc"::S_ - ,"finest"::S,"mincls"::S,"ifail"::S,"functn"::S,"a"::S,"b"::S,"wrkstr"::S]$Lisp,_ - ["acc"::S,"finest"::S,"functn"::S]$Lisp,_ - [["double"::S,["a"::S,"ndim"::S]$Lisp,["b"::S,"ndim"::S]$Lisp_ - ,"eps"::S,"acc"::S,"finest"::S,["wrkstr"::S,"lenwrk"::S]$Lisp,"functn"::S]$Lisp_ - ,["integer"::S,"ndim"::S,"maxcls"::S,"lenwrk"::S_ - ,"mincls"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["acc"::S,"finest"::S,"mincls"::S,"wrkstr"::S,"ifail"::S]$Lisp,_ - [([ndimArg::Any,maxclsArg::Any,epsArg::Any,lenwrkArg::Any,minclsArg::Any,ifailArg::Any,aArg::Any,bArg::Any,wrkstrArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + maxclsArg:Integer,epsArg:DoubleFloat,lenwrkArg:Integer,_ + minclsArg:Integer,wrkstrArg:Matrix DoubleFloat,ifailArg:Integer,_ + functnArg:Union(fn:FileName,fp:Asp4(FUNCTN))): Result == + pushFortranOutputStack(functnFilename := aspFilename "functn")$FOP + if functnArg case fn + then outputAsFortran(functnArg.fn) + else outputAsFortran(functnArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([functnFilename]$Lisp,_ + "d01gbf",_ + ["ndim"::S,"maxcls"::S,"eps"::S,"lenwrk"::S,"acc"::S_ + ,"finest"::S,"mincls"::S,"ifail"::S,"functn"::S,"a"::S,_ + "b"::S,"wrkstr"::S]$Lisp,_ + ["acc"::S,"finest"::S,"functn"::S]$Lisp,_ + [["double"::S,["a"::S,"ndim"::S]$Lisp,["b"::S,"ndim"::S]$Lisp_ + ,"eps"::S,"acc"::S,"finest"::S,["wrkstr"::S,"lenwrk"::S]$Lisp,_ + "functn"::S]$Lisp_ + ,["integer"::S,"ndim"::S,"maxcls"::S,"lenwrk"::S_ + ,"mincls"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["acc"::S,"finest"::S,"mincls"::S,"wrkstr"::S,"ifail"::S]$Lisp,_ + [([ndimArg::Any,maxclsArg::Any,epsArg::Any,lenwrkArg::Any,_ + minclsArg::Any,ifailArg::Any,aArg::Any,bArg::Any,wrkstrArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result @ <>= @@ -81423,8 +81840,6 @@ NagIntegrationPackage(): Exports == Implementation where ++ interpolated value. For some of the interpolating functions, ++ there are supporting routines to evaluate, differentiate or ++ integrate them. -++ See \downlink{Manual Page}{manpageXXe01}. - NagInterpolationPackage(): Exports == Implementation where S ==> Symbol @@ -81432,7 +81847,7 @@ NagInterpolationPackage(): Exports == Implementation where Exports ==> with e01baf : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer,_ - Integer,Integer) -> Result + Integer,Integer) -> Result ++ e01baf(m,x,y,lck,lwrk,ifail) ++ determines a cubic spline to a given set of ++ data. @@ -81442,50 +81857,52 @@ NagInterpolationPackage(): Exports == Implementation where ++ computes a monotonicity-preserving piecewise cubic Hermite ++ interpolant to a set of data points. ++ See \downlink{Manual Page}{manpageXXe01bef}. - e01bff : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ - Integer,Matrix DoubleFloat,Integer) -> Result + e01bff: (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ + Integer,Matrix DoubleFloat,Integer) -> Result ++ e01bff(n,x,f,d,m,px,ifail) ++ evaluates a piecewise cubic Hermite interpolant at a set ++ of points. ++ See \downlink{Manual Page}{manpageXXe01bff}. - e01bgf : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ - Integer,Matrix DoubleFloat,Integer) -> Result + e01bgf: (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ + Integer,Matrix DoubleFloat,Integer) -> Result ++ e01bgf(n,x,f,d,m,px,ifail) ++ evaluates a piecewise cubic Hermite interpolant and its ++ first derivative at a set of points. ++ See \downlink{Manual Page}{manpageXXe01bgf}. - e01bhf : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ - DoubleFloat,DoubleFloat,Integer) -> Result + e01bhf: (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ + DoubleFloat,DoubleFloat,Integer) -> Result ++ e01bhf(n,x,f,d,a,b,ifail) ++ evaluates the definite integral of a piecewise cubic ++ Hermite interpolant over the interval [a,b]. ++ See \downlink{Manual Page}{manpageXXe01bhf}. e01daf : (Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,_ - Matrix DoubleFloat,Integer) -> Result + Matrix DoubleFloat,Integer) -> Result ++ e01daf(mx,my,x,y,f,ifail) ++ computes a bicubic spline interpolating surface through a ++ set of data values, given on a rectangular grid in the x-y plane. ++ See \downlink{Manual Page}{manpageXXe01daf}. - e01saf : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ - Integer) -> Result + e01saf: (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ + Integer) -> Result ++ e01saf(m,x,y,f,ifail) ++ generates a two-dimensional surface interpolating a set of ++ scattered data points, using the method of Renka and Cline. ++ See \downlink{Manual Page}{manpageXXe01saf}. - e01sbf : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ - Matrix Integer,Matrix DoubleFloat,DoubleFloat,DoubleFloat,Integer) -> Result + e01sbf: (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ + Matrix Integer,Matrix DoubleFloat,DoubleFloat,DoubleFloat,_ + Integer) -> Result ++ e01sbf(m,x,y,f,triang,grads,px,py,ifail) ++ evaluates at a given point the two-dimensional interpolant ++ function computed by E01SAF. ++ See \downlink{Manual Page}{manpageXXe01sbf}. - e01sef : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ - Integer,Integer,DoubleFloat,DoubleFloat,Integer) -> Result + e01sef: (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ + Integer,Integer,DoubleFloat,DoubleFloat,Integer) -> Result ++ e01sef(m,x,y,f,nw,nq,rnw,rnq,ifail) ++ generates a two-dimensional surface interpolating a set of ++ scattered data points, using a modified Shepard method. ++ See \downlink{Manual Page}{manpageXXe01sef}. - e01sff : (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ - DoubleFloat,Matrix DoubleFloat,DoubleFloat,DoubleFloat,Integer) -> Result + e01sff: (Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ + DoubleFloat,Matrix DoubleFloat,DoubleFloat,DoubleFloat,_ + Integer) -> Result ++ e01sff(m,x,y,f,rnw,fnodes,px,py,ifail) ++ evaluates at a given point the two-dimensional ++ interpolating function computed by E01SEF. @@ -81507,180 +81924,202 @@ NagInterpolationPackage(): Exports == Implementation where e01baf(mArg:Integer,xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,_ - lckArg:Integer,lwrkArg:Integer,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e01baf",_ - ["m"::S,"lck"::S,"lwrk"::S,"ifail"::S,"x"::S,"y"::S,"lamda"::S,"c"::S,"wrk"::S_ - ]$Lisp,_ - ["lamda"::S,"c"::S,"wrk"::S]$Lisp,_ - [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ - ,["lamda"::S,"lck"::S]$Lisp,["c"::S,"lck"::S]$Lisp,["wrk"::S,"lwrk"::S]$Lisp]$Lisp_ - ,["integer"::S,"m"::S,"lck"::S,"lwrk"::S,"ifail"::S_ - ]$Lisp_ - ]$Lisp,_ - ["lamda"::S,"c"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,lckArg::Any,lwrkArg::Any,ifailArg::Any,xArg::Any,yArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + lckArg:Integer,lwrkArg:Integer,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e01baf",_ + ["m"::S,"lck"::S,"lwrk"::S,"ifail"::S,"x"::S,"y"::S,_ + "lamda"::S,"c"::S,"wrk"::S_ + ]$Lisp,_ + ["lamda"::S,"c"::S,"wrk"::S]$Lisp,_ + [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ + ,["lamda"::S,"lck"::S]$Lisp,["c"::S,"lck"::S]$Lisp,_ + ["wrk"::S,"lwrk"::S]$Lisp]$Lisp_ + ,["integer"::S,"m"::S,"lck"::S,"lwrk"::S,"ifail"::S_ + ]$Lisp_ + ]$Lisp,_ + ["lamda"::S,"c"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,lckArg::Any,lwrkArg::Any,ifailArg::Any,_ + xArg::Any,yArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e01bef(nArg:Integer,xArg:Matrix DoubleFloat,fArg:Matrix DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e01bef",_ - ["n"::S,"ifail"::S,"x"::S,"f"::S,"d"::S]$Lisp,_ - ["d"::S]$Lisp,_ - [["double"::S,["x"::S,"n"::S]$Lisp,["f"::S,"n"::S]$Lisp_ - ,["d"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["d"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,ifailArg::Any,xArg::Any,fArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e01bef",_ + ["n"::S,"ifail"::S,"x"::S,"f"::S,"d"::S]$Lisp,_ + ["d"::S]$Lisp,_ + [["double"::S,["x"::S,"n"::S]$Lisp,["f"::S,"n"::S]$Lisp_ + ,["d"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["d"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,ifailArg::Any,xArg::Any,fArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e01bff(nArg:Integer,xArg:Matrix DoubleFloat,fArg:Matrix DoubleFloat,_ - dArg:Matrix DoubleFloat,mArg:Integer,pxArg:Matrix DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e01bff",_ - ["n"::S,"m"::S,"ifail"::S,"x"::S,"f"::S,"d"::S,"px"::S,"pf"::S_ - ]$Lisp,_ - ["pf"::S]$Lisp,_ - [["double"::S,["x"::S,"n"::S]$Lisp,["f"::S,"n"::S]$Lisp_ - ,["d"::S,"n"::S]$Lisp,["px"::S,"m"::S]$Lisp,["pf"::S,"m"::S]$Lisp]$Lisp_ - ,["integer"::S,"n"::S,"m"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["pf"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,mArg::Any,ifailArg::Any,xArg::Any,fArg::Any,dArg::Any,pxArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + dArg:Matrix DoubleFloat,mArg:Integer,pxArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e01bff",_ + ["n"::S,"m"::S,"ifail"::S,"x"::S,"f"::S,"d"::S,"px"::S,"pf"::S_ + ]$Lisp,_ + ["pf"::S]$Lisp,_ + [["double"::S,["x"::S,"n"::S]$Lisp,["f"::S,"n"::S]$Lisp_ + ,["d"::S,"n"::S]$Lisp,["px"::S,"m"::S]$Lisp,_ + ["pf"::S,"m"::S]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"m"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["pf"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,mArg::Any,ifailArg::Any,xArg::Any,fArg::Any,_ + dArg::Any,pxArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e01bgf(nArg:Integer,xArg:Matrix DoubleFloat,fArg:Matrix DoubleFloat,_ - dArg:Matrix DoubleFloat,mArg:Integer,pxArg:Matrix DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e01bgf",_ - ["n"::S,"m"::S,"ifail"::S,"x"::S,"f"::S,"d"::S,"px"::S,"pf"::S_ - ,"pd"::S]$Lisp,_ - ["pf"::S,"pd"::S]$Lisp,_ - [["double"::S,["x"::S,"n"::S]$Lisp,["f"::S,"n"::S]$Lisp_ - ,["d"::S,"n"::S]$Lisp,["px"::S,"m"::S]$Lisp,["pf"::S,"m"::S]$Lisp,["pd"::S,"m"::S]$Lisp]$Lisp_ - ,["integer"::S,"n"::S,"m"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["pf"::S,"pd"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,mArg::Any,ifailArg::Any,xArg::Any,fArg::Any,dArg::Any,pxArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + dArg:Matrix DoubleFloat,mArg:Integer,pxArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e01bgf",_ + ["n"::S,"m"::S,"ifail"::S,"x"::S,"f"::S,"d"::S,"px"::S,"pf"::S_ + ,"pd"::S]$Lisp,_ + ["pf"::S,"pd"::S]$Lisp,_ + [["double"::S,["x"::S,"n"::S]$Lisp,["f"::S,"n"::S]$Lisp_ + ,["d"::S,"n"::S]$Lisp,["px"::S,"m"::S]$Lisp,_ + ["pf"::S,"m"::S]$Lisp,["pd"::S,"m"::S]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"m"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["pf"::S,"pd"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,mArg::Any,ifailArg::Any,xArg::Any,_ + fArg::Any,dArg::Any,pxArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e01bhf(nArg:Integer,xArg:Matrix DoubleFloat,fArg:Matrix DoubleFloat,_ - dArg:Matrix DoubleFloat,aArg:DoubleFloat,bArg:DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e01bhf",_ - ["n"::S,"a"::S,"b"::S,"pint"::S,"ifail"::S_ - ,"x"::S,"f"::S,"d"::S]$Lisp,_ - ["pint"::S]$Lisp,_ - [["double"::S,["x"::S,"n"::S]$Lisp,["f"::S,"n"::S]$Lisp_ - ,["d"::S,"n"::S]$Lisp,"a"::S,"b"::S,"pint"::S]$Lisp_ - ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["pint"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,aArg::Any,bArg::Any,ifailArg::Any,xArg::Any,fArg::Any,dArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + dArg:Matrix DoubleFloat,aArg:DoubleFloat,bArg:DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e01bhf",_ + ["n"::S,"a"::S,"b"::S,"pint"::S,"ifail"::S_ + ,"x"::S,"f"::S,"d"::S]$Lisp,_ + ["pint"::S]$Lisp,_ + [["double"::S,["x"::S,"n"::S]$Lisp,["f"::S,"n"::S]$Lisp_ + ,["d"::S,"n"::S]$Lisp,"a"::S,"b"::S,"pint"::S]$Lisp_ + ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["pint"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,aArg::Any,bArg::Any,ifailArg::Any,xArg::Any,_ + fArg::Any,dArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e01daf(mxArg:Integer,myArg:Integer,xArg:Matrix DoubleFloat,_ - yArg:Matrix DoubleFloat,fArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e01daf",_ - ["mx"::S,"my"::S,"px"::S,"py"::S,"ifail"::S_ - ,"x"::S,"y"::S,"f"::S,"lamda"::S,"mu"::S_ - ,"c"::S,"wrk"::S]$Lisp,_ - ["px"::S,"py"::S,"lamda"::S,"mu"::S,"c"::S,"wrk"::S]$Lisp,_ - [["double"::S,["x"::S,"mx"::S]$Lisp,["y"::S,"my"::S]$Lisp_ - ,["f"::S,["*"::S,"mx"::S,"my"::S]$Lisp]$Lisp,["lamda"::S,["+"::S,"mx"::S,4$Lisp]$Lisp]$Lisp,["mu"::S,["+"::S,"mx"::S,4$Lisp]$Lisp]$Lisp_ - ,["c"::S,["*"::S,"mx"::S,"my"::S]$Lisp]$Lisp,["wrk"::S,["*"::S,["+"::S,"mx"::S,6$Lisp]$Lisp,["+"::S,"my"::S,6$Lisp]$Lisp]$Lisp]$Lisp_ - ]$Lisp_ - ,["integer"::S,"mx"::S,"my"::S,"px"::S,"py"::S_ - ,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["px"::S,"py"::S,"lamda"::S,"mu"::S,"c"::S,"ifail"::S]$Lisp,_ - [([mxArg::Any,myArg::Any,ifailArg::Any,xArg::Any,yArg::Any,fArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + yArg:Matrix DoubleFloat,fArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e01daf",_ + ["mx"::S,"my"::S,"px"::S,"py"::S,"ifail"::S_ + ,"x"::S,"y"::S,"f"::S,"lamda"::S,"mu"::S_ + ,"c"::S,"wrk"::S]$Lisp,_ + ["px"::S,"py"::S,"lamda"::S,"mu"::S,"c"::S,"wrk"::S]$Lisp,_ + [["double"::S,["x"::S,"mx"::S]$Lisp,["y"::S,"my"::S]$Lisp_ + ,["f"::S,["*"::S,"mx"::S,"my"::S]$Lisp]$Lisp,_ + ["lamda"::S,["+"::S,"mx"::S,4$Lisp]$Lisp]$Lisp,_ + ["mu"::S,["+"::S,"mx"::S,4$Lisp]$Lisp]$Lisp_ + ,["c"::S,["*"::S,"mx"::S,"my"::S]$Lisp]$Lisp,_ + ["wrk"::S,["*"::S,["+"::S,"mx"::S,6$Lisp]$Lisp,_ + ["+"::S,"my"::S,6$Lisp]$Lisp]$Lisp]$Lisp_ + ]$Lisp_ + ,["integer"::S,"mx"::S,"my"::S,"px"::S,"py"::S_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["px"::S,"py"::S,"lamda"::S,"mu"::S,"c"::S,"ifail"::S]$Lisp,_ + [([mxArg::Any,myArg::Any,ifailArg::Any,xArg::Any,_ + yArg::Any,fArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e01saf(mArg:Integer,xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,_ - fArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e01saf",_ - ["m"::S,"ifail"::S,"x"::S,"y"::S,"f"::S,"triang"::S,"grads"::S_ - ]$Lisp,_ - ["triang"::S,"grads"::S]$Lisp,_ - [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ - ,["f"::S,"m"::S]$Lisp,["grads"::S,2$Lisp,"m"::S]$Lisp]$Lisp_ - ,["integer"::S,"m"::S,["triang"::S,["*"::S,7$Lisp,"m"::S]$Lisp]$Lisp_ - ,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["triang"::S,"grads"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,ifailArg::Any,xArg::Any,yArg::Any,fArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + fArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e01saf",_ + ["m"::S,"ifail"::S,"x"::S,"y"::S,"f"::S,"triang"::S,"grads"::S_ + ]$Lisp,_ + ["triang"::S,"grads"::S]$Lisp,_ + [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ + ,["f"::S,"m"::S]$Lisp,["grads"::S,2$Lisp,"m"::S]$Lisp]$Lisp_ + ,["integer"::S,"m"::S,["triang"::S,["*"::S,7$Lisp,"m"::S]$Lisp]$Lisp_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["triang"::S,"grads"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,ifailArg::Any,xArg::Any,yArg::Any,fArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e01sbf(mArg:Integer,xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,_ - fArg:Matrix DoubleFloat,triangArg:Matrix Integer,gradsArg:Matrix DoubleFloat,_ - pxArg:DoubleFloat,pyArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e01sbf",_ - ["m"::S,"px"::S,"py"::S,"pf"::S,"ifail"::S_ - ,"x"::S,"y"::S,"f"::S,"triang"::S,"grads"::S_ - ]$Lisp,_ - ["pf"::S]$Lisp,_ - [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ - ,["f"::S,"m"::S]$Lisp,["grads"::S,2$Lisp,"m"::S]$Lisp,"px"::S,"py"::S,"pf"::S]$Lisp_ - ,["integer"::S,"m"::S,["triang"::S,["*"::S,7$Lisp,"m"::S]$Lisp]$Lisp_ - ,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["pf"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,pxArg::Any,pyArg::Any,ifailArg::Any,xArg::Any,yArg::Any,fArg::Any,triangArg::Any,gradsArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + fArg:Matrix DoubleFloat,triangArg:Matrix Integer,_ + gradsArg:Matrix DoubleFloat,_ + pxArg:DoubleFloat,pyArg:DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e01sbf",_ + ["m"::S,"px"::S,"py"::S,"pf"::S,"ifail"::S_ + ,"x"::S,"y"::S,"f"::S,"triang"::S,"grads"::S_ + ]$Lisp,_ + ["pf"::S]$Lisp,_ + [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ + ,["f"::S,"m"::S]$Lisp,["grads"::S,2$Lisp,"m"::S]$Lisp,_ + "px"::S,"py"::S,"pf"::S]$Lisp_ + ,["integer"::S,"m"::S,["triang"::S,["*"::S,7$Lisp,"m"::S]$Lisp]$Lisp_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["pf"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,pxArg::Any,pyArg::Any,ifailArg::Any,xArg::Any,_ + yArg::Any,fArg::Any,triangArg::Any,gradsArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e01sef(mArg:Integer,xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,_ - fArg:Matrix DoubleFloat,nwArg:Integer,nqArg:Integer,_ - rnwArg:DoubleFloat,rnqArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e01sef",_ - ["m"::S,"nw"::S,"nq"::S,"minnq"::S,"rnw"::S_ - ,"rnq"::S,"ifail"::S,"x"::S,"y"::S,"f"::S,"fnodes"::S,"wrk"::S_ - ]$Lisp,_ - ["fnodes"::S,"minnq"::S,"wrk"::S]$Lisp,_ - [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ - ,["f"::S,"m"::S]$Lisp,["fnodes"::S,["*"::S,5$Lisp,"m"::S]$Lisp]$Lisp,"rnw"::S,"rnq"::S,["wrk"::S,["*"::S,6$Lisp,"m"::S]$Lisp]$Lisp_ - ]$Lisp_ - ,["integer"::S,"m"::S,"nw"::S,"nq"::S,"minnq"::S_ - ,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["fnodes"::S,"minnq"::S,"rnw"::S,"rnq"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,nwArg::Any,nqArg::Any,rnwArg::Any,rnqArg::Any,ifailArg::Any,xArg::Any,yArg::Any,fArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + fArg:Matrix DoubleFloat,nwArg:Integer,nqArg:Integer,_ + rnwArg:DoubleFloat,rnqArg:DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e01sef",_ + ["m"::S,"nw"::S,"nq"::S,"minnq"::S,"rnw"::S_ + ,"rnq"::S,"ifail"::S,"x"::S,"y"::S,"f"::S,"fnodes"::S,"wrk"::S_ + ]$Lisp,_ + ["fnodes"::S,"minnq"::S,"wrk"::S]$Lisp,_ + [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ + ,["f"::S,"m"::S]$Lisp,["fnodes"::S,["*"::S,5$Lisp,"m"::S]$Lisp]$Lisp,_ + "rnw"::S,"rnq"::S,["wrk"::S,["*"::S,6$Lisp,"m"::S]$Lisp]$Lisp_ + ]$Lisp_ + ,["integer"::S,"m"::S,"nw"::S,"nq"::S,"minnq"::S_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["fnodes"::S,"minnq"::S,"rnw"::S,"rnq"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,nwArg::Any,nqArg::Any,rnwArg::Any,rnqArg::Any,_ + ifailArg::Any,xArg::Any,yArg::Any,fArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e01sff(mArg:Integer,xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,_ - fArg:Matrix DoubleFloat,rnwArg:DoubleFloat,fnodesArg:Matrix DoubleFloat,_ - pxArg:DoubleFloat,pyArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e01sff",_ - ["m"::S,"rnw"::S,"px"::S,"py"::S,"pf"::S_ - ,"ifail"::S,"x"::S,"y"::S,"f"::S,"fnodes"::S]$Lisp,_ - ["pf"::S]$Lisp,_ - [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ - ,["f"::S,"m"::S]$Lisp,"rnw"::S,["fnodes"::S,["*"::S,5$Lisp,"m"::S]$Lisp]$Lisp,"px"::S,"py"::S,"pf"::S]$Lisp_ - ,["integer"::S,"m"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["pf"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,rnwArg::Any,pxArg::Any,pyArg::Any,ifailArg::Any,xArg::Any,yArg::Any,fArg::Any,fnodesArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + fArg:Matrix DoubleFloat,rnwArg:DoubleFloat,_ + fnodesArg:Matrix DoubleFloat,_ + pxArg:DoubleFloat,pyArg:DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e01sff",_ + ["m"::S,"rnw"::S,"px"::S,"py"::S,"pf"::S_ + ,"ifail"::S,"x"::S,"y"::S,"f"::S,"fnodes"::S]$Lisp,_ + ["pf"::S]$Lisp,_ + [["double"::S,["x"::S,"m"::S]$Lisp,["y"::S,"m"::S]$Lisp_ + ,["f"::S,"m"::S]$Lisp,"rnw"::S,["fnodes"::S,_ + ["*"::S,5$Lisp,"m"::S]$Lisp]$Lisp,"px"::S,"py"::S,"pf"::S]$Lisp_ + ,["integer"::S,"m"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["pf"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,rnwArg::Any,pxArg::Any,pyArg::Any,_ + ifailArg::Any,xArg::Any,yArg::Any,fArg::Any,fnodesArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result @ <>= @@ -82398,7 +82837,7 @@ NagInterpolationPackage(): Exports == Implementation where ++ This package uses the NAG Library to compute matrix ++ factorizations, and to solve systems of linear equations ++ following the matrix factorizations. -++ See \downlink{Manual Page}{manpageXXf07}. + NagLapack(): Exports == Implementation where S ==> Symbol FOP ==> FortranOutputStackPackage @@ -82410,7 +82849,7 @@ NagLapack(): Exports == Implementation where ++ matrix. ++ See \downlink{Manual Page}{manpageXXf07adf}. f07aef : (String,Integer,Integer,Matrix DoubleFloat,_ - Integer,Matrix Integer,Integer,Matrix DoubleFloat) -> Result + Integer,Matrix Integer,Integer,Matrix DoubleFloat) -> Result ++ f07aef(trans,n,nrhs,a,lda,ipiv,ldb,b) ++ (DGETRS) solves a real system of linear equations with ++ T @@ -82423,7 +82862,7 @@ NagLapack(): Exports == Implementation where ++ symmetric positive-definite matrix. ++ See \downlink{Manual Page}{manpageXXf07fdf}. f07fef : (String,Integer,Integer,Matrix DoubleFloat,_ - Integer,Integer,Matrix DoubleFloat) -> Result + Integer,Integer,Matrix DoubleFloat) -> Result ++ f07fef(uplo,n,nrhs,a,lda,ldb,b) ++ (DPOTRS) solves a real symmetric positive-definite system ++ of linear equations with multiple right-hand sides, AX=B, where A @@ -82446,74 +82885,76 @@ NagLapack(): Exports == Implementation where f07adf(mArg:Integer,nArg:Integer,ldaArg:Integer,_ - aArg:Matrix DoubleFloat): Result == - [(invokeNagman(NIL$Lisp,_ - "f07adf",_ - ["m"::S,"n"::S,"lda"::S,"info"::S,"ipiv"::S,"a"::S]$Lisp,_ - ["ipiv"::S,"info"::S]$Lisp,_ - [["double"::S,["a"::S,"lda"::S,"n"::S]$Lisp_ - ]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"lda"::S,["ipiv"::S,"m"::S]$Lisp_ - ,"info"::S]$Lisp_ - ]$Lisp,_ - ["ipiv"::S,"info"::S,"a"::S]$Lisp,_ - [([mArg::Any,nArg::Any,ldaArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + aArg:Matrix DoubleFloat): Result == + [(invokeNagman(NIL$Lisp,_ + "f07adf",_ + ["m"::S,"n"::S,"lda"::S,"info"::S,"ipiv"::S,"a"::S]$Lisp,_ + ["ipiv"::S,"info"::S]$Lisp,_ + [["double"::S,["a"::S,"lda"::S,"n"::S]$Lisp_ + ]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"lda"::S,["ipiv"::S,"m"::S]$Lisp_ + ,"info"::S]$Lisp_ + ]$Lisp,_ + ["ipiv"::S,"info"::S,"a"::S]$Lisp,_ + [([mArg::Any,nArg::Any,ldaArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f07aef(transArg:String,nArg:Integer,nrhsArg:Integer,_ - aArg:Matrix DoubleFloat,ldaArg:Integer,ipivArg:Matrix Integer,_ - ldbArg:Integer,bArg:Matrix DoubleFloat): Result == - [(invokeNagman(NIL$Lisp,_ - "f07aef",_ - ["trans"::S,"n"::S,"nrhs"::S,"lda"::S,"ldb"::S_ - ,"info"::S,"a"::S,"ipiv"::S,"b"::S]$Lisp,_ - ["info"::S]$Lisp,_ - [["double"::S,["a"::S,"lda"::S,"n"::S]$Lisp_ - ,["b"::S,"ldb"::S,"nrhs"::S]$Lisp]$Lisp_ - ,["integer"::S,"n"::S,"nrhs"::S,"lda"::S,["ipiv"::S,"n"::S]$Lisp_ - ,"ldb"::S,"info"::S]$Lisp_ - ,["character"::S,"trans"::S]$Lisp_ - ]$Lisp,_ - ["info"::S,"b"::S]$Lisp,_ - [([transArg::Any,nArg::Any,nrhsArg::Any,ldaArg::Any,ldbArg::Any,aArg::Any,ipivArg::Any,bArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + aArg:Matrix DoubleFloat,ldaArg:Integer,ipivArg:Matrix Integer,_ + ldbArg:Integer,bArg:Matrix DoubleFloat): Result == + [(invokeNagman(NIL$Lisp,_ + "f07aef",_ + ["trans"::S,"n"::S,"nrhs"::S,"lda"::S,"ldb"::S_ + ,"info"::S,"a"::S,"ipiv"::S,"b"::S]$Lisp,_ + ["info"::S]$Lisp,_ + [["double"::S,["a"::S,"lda"::S,"n"::S]$Lisp_ + ,["b"::S,"ldb"::S,"nrhs"::S]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"nrhs"::S,"lda"::S,["ipiv"::S,"n"::S]$Lisp_ + ,"ldb"::S,"info"::S]$Lisp_ + ,["character"::S,"trans"::S]$Lisp_ + ]$Lisp,_ + ["info"::S,"b"::S]$Lisp,_ + [([transArg::Any,nArg::Any,nrhsArg::Any,ldaArg::Any,_ + ldbArg::Any,aArg::Any,ipivArg::Any,bArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f07fdf(uploArg:String,nArg:Integer,ldaArg:Integer,_ - aArg:Matrix DoubleFloat): Result == - [(invokeNagman(NIL$Lisp,_ - "f07fdf",_ - ["uplo"::S,"n"::S,"lda"::S,"info"::S,"a"::S]$Lisp,_ - ["info"::S]$Lisp,_ - [["double"::S,["a"::S,"lda"::S,"n"::S]$Lisp_ - ]$Lisp_ - ,["integer"::S,"n"::S,"lda"::S,"info"::S]$Lisp_ - ,["character"::S,"uplo"::S]$Lisp_ - ]$Lisp,_ - ["info"::S,"a"::S]$Lisp,_ - [([uploArg::Any,nArg::Any,ldaArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + aArg:Matrix DoubleFloat): Result == + [(invokeNagman(NIL$Lisp,_ + "f07fdf",_ + ["uplo"::S,"n"::S,"lda"::S,"info"::S,"a"::S]$Lisp,_ + ["info"::S]$Lisp,_ + [["double"::S,["a"::S,"lda"::S,"n"::S]$Lisp_ + ]$Lisp_ + ,["integer"::S,"n"::S,"lda"::S,"info"::S]$Lisp_ + ,["character"::S,"uplo"::S]$Lisp_ + ]$Lisp,_ + ["info"::S,"a"::S]$Lisp,_ + [([uploArg::Any,nArg::Any,ldaArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f07fef(uploArg:String,nArg:Integer,nrhsArg:Integer,_ - aArg:Matrix DoubleFloat,ldaArg:Integer,ldbArg:Integer,_ - bArg:Matrix DoubleFloat): Result == - [(invokeNagman(NIL$Lisp,_ - "f07fef",_ - ["uplo"::S,"n"::S,"nrhs"::S,"lda"::S,"ldb"::S_ - ,"info"::S,"a"::S,"b"::S]$Lisp,_ - ["info"::S]$Lisp,_ - [["double"::S,["a"::S,"lda"::S,"n"::S]$Lisp_ - ,["b"::S,"ldb"::S,"nrhs"::S]$Lisp]$Lisp_ - ,["integer"::S,"n"::S,"nrhs"::S,"lda"::S,"ldb"::S_ - ,"info"::S]$Lisp_ - ,["character"::S,"uplo"::S]$Lisp_ - ]$Lisp,_ - ["info"::S,"b"::S]$Lisp,_ - [([uploArg::Any,nArg::Any,nrhsArg::Any,ldaArg::Any,ldbArg::Any,aArg::Any,bArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + aArg:Matrix DoubleFloat,ldaArg:Integer,ldbArg:Integer,_ + bArg:Matrix DoubleFloat): Result == + [(invokeNagman(NIL$Lisp,_ + "f07fef",_ + ["uplo"::S,"n"::S,"nrhs"::S,"lda"::S,"ldb"::S_ + ,"info"::S,"a"::S,"b"::S]$Lisp,_ + ["info"::S]$Lisp,_ + [["double"::S,["a"::S,"lda"::S,"n"::S]$Lisp_ + ,["b"::S,"ldb"::S,"nrhs"::S]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"nrhs"::S,"lda"::S,"ldb"::S_ + ,"info"::S]$Lisp_ + ,["character"::S,"uplo"::S]$Lisp_ + ]$Lisp,_ + ["info"::S,"b"::S]$Lisp,_ + [([uploArg::Any,nArg::Any,nrhsArg::Any,ldaArg::Any,_ + ldbArg::Any,aArg::Any,bArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result @ <>= @@ -85329,14 +85770,15 @@ NagLapack(): Exports == Implementation where ++ Description: ++ This package uses the NAG Library to provide facilities for matrix ++ factorizations and associated transformations. -++ See \downlink{Manual Page}{manpageXXf01}. + NagMatrixOperationsPackage(): Exports == Implementation where S ==> Symbol FOP ==> FortranOutputStackPackage Exports ==> with f01brf : (Integer,Integer,Integer,Integer,_ - DoubleFloat,Boolean,Boolean,List Boolean,Matrix DoubleFloat,Matrix Integer,Matrix Integer,Integer) -> Result + DoubleFloat,Boolean,Boolean,List Boolean,Matrix DoubleFloat,_ + Matrix Integer,Matrix Integer,Integer) -> Result ++ f01brf(n,nz,licn,lirn,pivot,lblock,grow,abort,a,irn,icn,ifail) ++ factorizes a real sparse matrix. The routine either forms ++ the LU factorization of a permutation of the entire matrix, or, @@ -85344,55 +85786,61 @@ NagMatrixOperationsPackage(): Exports == Implementation where ++ form and then only factorizes the diagonal blocks. ++ See \downlink{Manual Page}{manpageXXf01brf}. f01bsf : (Integer,Integer,Integer,Matrix Integer,_ - Matrix Integer,Matrix Integer,Matrix Integer,Boolean,DoubleFloat,Boolean,Matrix Integer,Matrix DoubleFloat,Integer) -> Result - ++ f01bsf(n,nz,licn,ivect,jvect,icn,ikeep,grow,eta,abort,idisp,avals,ifail) + Matrix Integer,Matrix Integer,Matrix Integer,Boolean,DoubleFloat,_ + Boolean,Matrix Integer,Matrix DoubleFloat,Integer) -> Result + ++ f01bsf(n,nz,licn,ivect,jvect,icn,ikeep,grow, + ++ eta,abort,idisp,avals,ifail) ++ factorizes a real sparse matrix using the pivotal sequence ++ previously obtained by F01BRF when a matrix of the same sparsity ++ pattern was factorized. ++ See \downlink{Manual Page}{manpageXXf01bsf}. f01maf : (Integer,Integer,Integer,Integer,_ - List Boolean,Matrix DoubleFloat,Matrix Integer,Matrix Integer,DoubleFloat,DoubleFloat,Integer) -> Result + List Boolean,Matrix DoubleFloat,Matrix Integer,Matrix Integer,_ + DoubleFloat,DoubleFloat,Integer) -> Result ++ f01maf(n,nz,licn,lirn,abort,avals,irn,icn,droptl,densw,ifail) ++ computes an incomplete Cholesky factorization of a real ++ sparse symmetric positive-definite matrix A. ++ See \downlink{Manual Page}{manpageXXf01maf}. f01mcf : (Integer,Matrix DoubleFloat,Integer,Matrix Integer,_ - Integer) -> Result + Integer) -> Result ++ f01mcf(n,avals,lal,nrow,ifail) ++ computes the Cholesky factorization of a real symmetric ++ positive-definite variable-bandwidth matrix. ++ See \downlink{Manual Page}{manpageXXf01mcf}. f01qcf : (Integer,Integer,Integer,Matrix DoubleFloat,_ - Integer) -> Result + Integer) -> Result ++ f01qcf(m,n,lda,a,ifail) ++ finds the QR factorization of the real m by n matrix A, ++ where m>=n. ++ See \downlink{Manual Page}{manpageXXf01qcf}. f01qdf : (String,String,Integer,Integer,_ - Matrix DoubleFloat,Integer,Matrix DoubleFloat,Integer,Integer,Matrix DoubleFloat,Integer) -> Result + Matrix DoubleFloat,Integer,Matrix DoubleFloat,Integer,Integer,_ + Matrix DoubleFloat,Integer) -> Result ++ f01qdf(trans,wheret,m,n,a,lda,zeta,ncolb,ldb,b,ifail) ++ performs one of the transformations ++ See \downlink{Manual Page}{manpageXXf01qdf}. f01qef : (String,Integer,Integer,Integer,_ - Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result + Integer,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result ++ f01qef(wheret,m,n,ncolq,lda,zeta,a,ifail) ++ returns the first ncolq columns of the real m by m ++ orthogonal matrix Q, where Q is given as the product of ++ Householder transformation matrices. ++ See \downlink{Manual Page}{manpageXXf01qef}. f01rcf : (Integer,Integer,Integer,Matrix Complex DoubleFloat,_ - Integer) -> Result + Integer) -> Result ++ f01rcf(m,n,lda,a,ifail) ++ finds the QR factorization of the complex m by n matrix A, ++ where m>=n. ++ See \downlink{Manual Page}{manpageXXf01rcf}. f01rdf : (String,String,Integer,Integer,_ - Matrix Complex DoubleFloat,Integer,Matrix Complex DoubleFloat,Integer,Integer,Matrix Complex DoubleFloat,Integer) -> Result + Matrix Complex DoubleFloat,Integer,Matrix Complex DoubleFloat,_ + Integer,Integer,Matrix Complex DoubleFloat,Integer) -> Result ++ f01rdf(trans,wheret,m,n,a,lda,theta,ncolb,ldb,b,ifail) ++ performs one of the transformations ++ See \downlink{Manual Page}{manpageXXf01rdf}. f01ref : (String,Integer,Integer,Integer,_ - Integer,Matrix Complex DoubleFloat,Matrix Complex DoubleFloat,Integer) -> Result + Integer,Matrix Complex DoubleFloat,Matrix Complex DoubleFloat,_ + Integer) -> Result ++ f01ref(wheret,m,n,ncolq,lda,theta,a,ifail) ++ returns the first ncolq columns of the complex m by m ++ unitary matrix Q, where Q is given as the product of Householder @@ -85419,194 +85867,219 @@ NagMatrixOperationsPackage(): Exports == Implementation where f01brf(nArg:Integer,nzArg:Integer,licnArg:Integer,_ - lirnArg:Integer,pivotArg:DoubleFloat,lblockArg:Boolean,_ - growArg:Boolean,abortArg:List Boolean,aArg:Matrix DoubleFloat,_ - irnArg:Matrix Integer,icnArg:Matrix Integer,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f01brf",_ - ["n"::S,"nz"::S,"licn"::S,"lirn"::S,"pivot"::S_ - ,"lblock"::S,"grow"::S,"ifail"::S,"abort"::S,"ikeep"::S,"w"::S,"idisp"::S,"a"::S_ - ,"irn"::S,"icn"::S,"iw"::S]$Lisp,_ - ["ikeep"::S,"w"::S,"idisp"::S,"iw"::S]$Lisp,_ - [["double"::S,"pivot"::S,["w"::S,"n"::S]$Lisp_ - ,["a"::S,"licn"::S]$Lisp]$Lisp_ - ,["integer"::S,"n"::S,"nz"::S,"licn"::S,"lirn"::S_ - ,["ikeep"::S,["*"::S,5$Lisp,"n"::S]$Lisp]$Lisp,["idisp"::S,10$Lisp]$Lisp,["irn"::S,"lirn"::S]$Lisp,["icn"::S,"licn"::S]$Lisp_ - ,"ifail"::S,["iw"::S,["*"::S,8$Lisp,"n"::S]$Lisp]$Lisp]$Lisp_ - ,["logical"::S,"lblock"::S,"grow"::S,["abort"::S,4$Lisp]$Lisp]$Lisp_ - ]$Lisp,_ - ["ikeep"::S,"w"::S,"idisp"::S,"a"::S,"irn"::S,"icn"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,nzArg::Any,licnArg::Any,lirnArg::Any,pivotArg::Any,lblockArg::Any,growArg::Any,ifailArg::Any,abortArg::Any,aArg::Any,irnArg::Any,icnArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + lirnArg:Integer,pivotArg:DoubleFloat,lblockArg:Boolean,_ + growArg:Boolean,abortArg:List Boolean,aArg:Matrix DoubleFloat,_ + irnArg:Matrix Integer,icnArg:Matrix Integer,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01brf",_ + ["n"::S,"nz"::S,"licn"::S,"lirn"::S,"pivot"::S_ + ,"lblock"::S,"grow"::S,"ifail"::S,"abort"::S,"ikeep"::S,_ + "w"::S,"idisp"::S,"a"::S_ + ,"irn"::S,"icn"::S,"iw"::S]$Lisp,_ + ["ikeep"::S,"w"::S,"idisp"::S,"iw"::S]$Lisp,_ + [["double"::S,"pivot"::S,["w"::S,"n"::S]$Lisp_ + ,["a"::S,"licn"::S]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"nz"::S,"licn"::S,"lirn"::S_ + ,["ikeep"::S,["*"::S,5$Lisp,"n"::S]$Lisp]$Lisp,_ + ["idisp"::S,10$Lisp]$Lisp,["irn"::S,"lirn"::S]$Lisp,_ + ["icn"::S,"licn"::S]$Lisp_ + ,"ifail"::S,["iw"::S,["*"::S,8$Lisp,"n"::S]$Lisp]$Lisp]$Lisp_ + ,["logical"::S,"lblock"::S,"grow"::S,["abort"::S,4$Lisp]$Lisp]$Lisp_ + ]$Lisp,_ + ["ikeep"::S,"w"::S,"idisp"::S,"a"::S,"irn"::S,_ + "icn"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,nzArg::Any,licnArg::Any,lirnArg::Any,pivotArg::Any,_ + lblockArg::Any,growArg::Any,ifailArg::Any,abortArg::Any,_ + aArg::Any,irnArg::Any,icnArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f01bsf(nArg:Integer,nzArg:Integer,licnArg:Integer,_ - ivectArg:Matrix Integer,jvectArg:Matrix Integer,icnArg:Matrix Integer,_ - ikeepArg:Matrix Integer,growArg:Boolean,etaArg:DoubleFloat,_ - abortArg:Boolean,idispArg:Matrix Integer,avalsArg:Matrix DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f01bsf",_ - ["n"::S,"nz"::S,"licn"::S,"grow"::S,"eta"::S_ - ,"abort"::S,"rpmin"::S,"ifail"::S,"ivect"::S,"jvect"::S,"icn"::S,"ikeep"::S,"idisp"::S_ - ,"w"::S,"avals"::S,"iw"::S]$Lisp,_ - ["w"::S,"rpmin"::S,"iw"::S]$Lisp,_ - [["double"::S,"eta"::S,["w"::S,"n"::S]$Lisp_ - ,"rpmin"::S,["avals"::S,"licn"::S]$Lisp]$Lisp_ - ,["integer"::S,"n"::S,"nz"::S,"licn"::S,["ivect"::S,"nz"::S]$Lisp_ - ,["jvect"::S,"nz"::S]$Lisp,["icn"::S,"licn"::S]$Lisp,["ikeep"::S,["*"::S,5$Lisp,"n"::S]$Lisp]$Lisp_ - ,["idisp"::S,2$Lisp]$Lisp,"ifail"::S,["iw"::S,["*"::S,8$Lisp,"n"::S]$Lisp]$Lisp]$Lisp_ - ,["logical"::S,"grow"::S,"abort"::S]$Lisp_ - ]$Lisp,_ - ["w"::S,"rpmin"::S,"avals"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,nzArg::Any,licnArg::Any,growArg::Any,etaArg::Any,abortArg::Any,ifailArg::Any,ivectArg::Any,jvectArg::Any,icnArg::Any,ikeepArg::Any,idispArg::Any,avalsArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ivectArg:Matrix Integer,jvectArg:Matrix Integer,icnArg:Matrix Integer,_ + ikeepArg:Matrix Integer,growArg:Boolean,etaArg:DoubleFloat,_ + abortArg:Boolean,idispArg:Matrix Integer,avalsArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01bsf",_ + ["n"::S,"nz"::S,"licn"::S,"grow"::S,"eta"::S_ + ,"abort"::S,"rpmin"::S,"ifail"::S,"ivect"::S,"jvect"::S,_ + "icn"::S,"ikeep"::S,"idisp"::S_ + ,"w"::S,"avals"::S,"iw"::S]$Lisp,_ + ["w"::S,"rpmin"::S,"iw"::S]$Lisp,_ + [["double"::S,"eta"::S,["w"::S,"n"::S]$Lisp_ + ,"rpmin"::S,["avals"::S,"licn"::S]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"nz"::S,"licn"::S,["ivect"::S,"nz"::S]$Lisp_ + ,["jvect"::S,"nz"::S]$Lisp,["icn"::S,"licn"::S]$Lisp,_ + ["ikeep"::S,["*"::S,5$Lisp,"n"::S]$Lisp]$Lisp_ + ,["idisp"::S,2$Lisp]$Lisp,"ifail"::S,_ + ["iw"::S,["*"::S,8$Lisp,"n"::S]$Lisp]$Lisp]$Lisp_ + ,["logical"::S,"grow"::S,"abort"::S]$Lisp_ + ]$Lisp,_ + ["w"::S,"rpmin"::S,"avals"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,nzArg::Any,licnArg::Any,growArg::Any,etaArg::Any,_ + abortArg::Any,ifailArg::Any,ivectArg::Any,jvectArg::Any,icnArg::Any,_ + ikeepArg::Any,idispArg::Any,avalsArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f01maf(nArg:Integer,nzArg:Integer,licnArg:Integer,_ - lirnArg:Integer,abortArg:List Boolean,avalsArg:Matrix DoubleFloat,_ - irnArg:Matrix Integer,icnArg:Matrix Integer,droptlArg:DoubleFloat,_ - denswArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f01maf",_ - ["n"::S,"nz"::S,"licn"::S,"lirn"::S,"droptl"::S_ - ,"densw"::S,"ifail"::S,"abort"::S,"wkeep"::S,"ikeep"::S,"inform"::S,"avals"::S_ - ,"irn"::S,"icn"::S,"iwork"::S]$Lisp,_ - ["wkeep"::S,"ikeep"::S,"inform"::S,"iwork"::S]$Lisp,_ - [["double"::S,["wkeep"::S,["*"::S,3$Lisp,"n"::S]$Lisp]$Lisp_ - ,["avals"::S,"licn"::S]$Lisp,"droptl"::S,"densw"::S]$Lisp_ - ,["integer"::S,"n"::S,"nz"::S,"licn"::S,"lirn"::S_ - ,["ikeep"::S,["*"::S,2$Lisp,"n"::S]$Lisp]$Lisp,["inform"::S,4$Lisp]$Lisp,["irn"::S,"lirn"::S]$Lisp,["icn"::S,"licn"::S]$Lisp_ - ,"ifail"::S,["iwork"::S,["*"::S,6$Lisp,"n"::S]$Lisp]$Lisp]$Lisp_ - ,["logical"::S,["abort"::S,3$Lisp]$Lisp]$Lisp_ - ]$Lisp,_ - ["wkeep"::S,"ikeep"::S,"inform"::S,"avals"::S,"irn"::S,"icn"::S,"droptl"::S,"densw"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,nzArg::Any,licnArg::Any,lirnArg::Any,droptlArg::Any,denswArg::Any,ifailArg::Any,abortArg::Any,avalsArg::Any,irnArg::Any,icnArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + lirnArg:Integer,abortArg:List Boolean,avalsArg:Matrix DoubleFloat,_ + irnArg:Matrix Integer,icnArg:Matrix Integer,droptlArg:DoubleFloat,_ + denswArg:DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01maf",_ + ["n"::S,"nz"::S,"licn"::S,"lirn"::S,"droptl"::S_ + ,"densw"::S,"ifail"::S,"abort"::S,"wkeep"::S,"ikeep"::S,_ + "inform"::S,"avals"::S_ + ,"irn"::S,"icn"::S,"iwork"::S]$Lisp,_ + ["wkeep"::S,"ikeep"::S,"inform"::S,"iwork"::S]$Lisp,_ + [["double"::S,["wkeep"::S,["*"::S,3$Lisp,"n"::S]$Lisp]$Lisp_ + ,["avals"::S,"licn"::S]$Lisp,"droptl"::S,"densw"::S]$Lisp_ + ,["integer"::S,"n"::S,"nz"::S,"licn"::S,"lirn"::S_ + ,["ikeep"::S,["*"::S,2$Lisp,"n"::S]$Lisp]$Lisp,_ + ["inform"::S,4$Lisp]$Lisp,["irn"::S,"lirn"::S]$Lisp,_ + ["icn"::S,"licn"::S]$Lisp_ + ,"ifail"::S,["iwork"::S,["*"::S,6$Lisp,"n"::S]$Lisp]$Lisp]$Lisp_ + ,["logical"::S,["abort"::S,3$Lisp]$Lisp]$Lisp_ + ]$Lisp,_ + ["wkeep"::S,"ikeep"::S,"inform"::S,"avals"::S,"irn"::S,_ + "icn"::S,"droptl"::S,"densw"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,nzArg::Any,licnArg::Any,lirnArg::Any,droptlArg::Any,_ + denswArg::Any,ifailArg::Any,abortArg::Any,avalsArg::Any,_ + irnArg::Any,icnArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f01mcf(nArg:Integer,avalsArg:Matrix DoubleFloat,lalArg:Integer,_ - nrowArg:Matrix Integer,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f01mcf",_ - ["n"::S,"lal"::S,"ifail"::S,"avals"::S,"nrow"::S,"al"::S,"d"::S]$Lisp,_ - ["al"::S,"d"::S]$Lisp,_ - [["double"::S,["avals"::S,"lal"::S]$Lisp,["al"::S,"lal"::S]$Lisp_ - ,["d"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"n"::S,"lal"::S,["nrow"::S,"n"::S]$Lisp_ - ,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["al"::S,"d"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,lalArg::Any,ifailArg::Any,avalsArg::Any,nrowArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + nrowArg:Matrix Integer,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01mcf",_ + ["n"::S,"lal"::S,"ifail"::S,"avals"::S,"nrow"::S,"al"::S,"d"::S]$Lisp,_ + ["al"::S,"d"::S]$Lisp,_ + [["double"::S,["avals"::S,"lal"::S]$Lisp,["al"::S,"lal"::S]$Lisp_ + ,["d"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"lal"::S,["nrow"::S,"n"::S]$Lisp_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["al"::S,"d"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,lalArg::Any,ifailArg::Any,avalsArg::Any,nrowArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f01qcf(mArg:Integer,nArg:Integer,ldaArg:Integer,_ - aArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f01qcf",_ - ["m"::S,"n"::S,"lda"::S,"ifail"::S,"zeta"::S,"a"::S]$Lisp,_ - ["zeta"::S]$Lisp,_ - [["double"::S,["zeta"::S,"n"::S]$Lisp,["a"::S,"lda"::S,"n"::S]$Lisp_ - ]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"lda"::S,"ifail"::S_ - ]$Lisp_ - ]$Lisp,_ - ["zeta"::S,"a"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,nArg::Any,ldaArg::Any,ifailArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + aArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01qcf",_ + ["m"::S,"n"::S,"lda"::S,"ifail"::S,"zeta"::S,"a"::S]$Lisp,_ + ["zeta"::S]$Lisp,_ + [["double"::S,["zeta"::S,"n"::S]$Lisp,["a"::S,"lda"::S,"n"::S]$Lisp_ + ]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"lda"::S,"ifail"::S_ + ]$Lisp_ + ]$Lisp,_ + ["zeta"::S,"a"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,nArg::Any,ldaArg::Any,ifailArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f01qdf(transArg:String,wheretArg:String,mArg:Integer,_ - nArg:Integer,aArg:Matrix DoubleFloat,ldaArg:Integer,_ - zetaArg:Matrix DoubleFloat,ncolbArg:Integer,ldbArg:Integer,_ - bArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f01qdf",_ - ["trans"::S,"wheret"::S,"m"::S,"n"::S,"lda"::S_ - ,"ncolb"::S,"ldb"::S,"ifail"::S,"a"::S,"zeta"::S,"b"::S,"work"::S]$Lisp,_ - ["work"::S]$Lisp,_ - [["double"::S,["a"::S,"lda"::S,"n"::S]$Lisp_ - ,["zeta"::S,"n"::S]$Lisp,["b"::S,"ldb"::S,"ncolb"::S]$Lisp,["work"::S,"ncolb"::S]$Lisp]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"lda"::S,"ncolb"::S_ - ,"ldb"::S,"ifail"::S]$Lisp_ - ,["character"::S,"trans"::S,"wheret"::S]$Lisp_ - ]$Lisp,_ - ["b"::S,"ifail"::S]$Lisp,_ - [([transArg::Any,wheretArg::Any,mArg::Any,nArg::Any,ldaArg::Any,ncolbArg::Any,ldbArg::Any,ifailArg::Any,aArg::Any,zetaArg::Any,bArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + nArg:Integer,aArg:Matrix DoubleFloat,ldaArg:Integer,_ + zetaArg:Matrix DoubleFloat,ncolbArg:Integer,ldbArg:Integer,_ + bArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01qdf",_ + ["trans"::S,"wheret"::S,"m"::S,"n"::S,"lda"::S,"ncolb"::S,"ldb"::S,_ + "ifail"::S,"a"::S,"zeta"::S,"b"::S,"work"::S]$Lisp,_ + ["work"::S]$Lisp,_ + [["double"::S,["a"::S,"lda"::S,"n"::S]$Lisp,["zeta"::S,"n"::S]$Lisp,_ + ["b"::S,"ldb"::S,"ncolb"::S]$Lisp,["work"::S,"ncolb"::S]$Lisp]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"lda"::S,"ncolb"::S_ + ,"ldb"::S,"ifail"::S]$Lisp_ + ,["character"::S,"trans"::S,"wheret"::S]$Lisp_ + ]$Lisp,_ + ["b"::S,"ifail"::S]$Lisp,_ + [([transArg::Any,wheretArg::Any,mArg::Any,nArg::Any,ldaArg::Any,_ + ncolbArg::Any,ldbArg::Any,ifailArg::Any,aArg::Any,_ + zetaArg::Any,bArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f01qef(wheretArg:String,mArg:Integer,nArg:Integer,_ - ncolqArg:Integer,ldaArg:Integer,zetaArg:Matrix DoubleFloat,_ - aArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f01qef",_ - ["wheret"::S,"m"::S,"n"::S,"ncolq"::S,"lda"::S_ - ,"ifail"::S,"zeta"::S,"a"::S,"work"::S]$Lisp,_ - ["work"::S]$Lisp,_ - [["double"::S,["zeta"::S,"n"::S]$Lisp,["a"::S,"lda"::S,"ncolq"::S]$Lisp_ - ,["work"::S,"ncolq"::S]$Lisp]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"ncolq"::S,"lda"::S_ - ,"ifail"::S]$Lisp_ - ,["character"::S,"wheret"::S]$Lisp_ - ]$Lisp,_ - ["a"::S,"ifail"::S]$Lisp,_ - [([wheretArg::Any,mArg::Any,nArg::Any,ncolqArg::Any,ldaArg::Any,ifailArg::Any,zetaArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ncolqArg:Integer,ldaArg:Integer,zetaArg:Matrix DoubleFloat,_ + aArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01qef",_ + ["wheret"::S,"m"::S,"n"::S,"ncolq"::S,"lda"::S_ + ,"ifail"::S,"zeta"::S,"a"::S,"work"::S]$Lisp,_ + ["work"::S]$Lisp,_ + [["double"::S,["zeta"::S,"n"::S]$Lisp,_ + ["a"::S,"lda"::S,"ncolq"::S]$Lisp_ + ,["work"::S,"ncolq"::S]$Lisp]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"ncolq"::S,"lda"::S_ + ,"ifail"::S]$Lisp_ + ,["character"::S,"wheret"::S]$Lisp_ + ]$Lisp,_ + ["a"::S,"ifail"::S]$Lisp,_ + [([wheretArg::Any,mArg::Any,nArg::Any,ncolqArg::Any,ldaArg::Any,_ + ifailArg::Any,zetaArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f01rcf(mArg:Integer,nArg:Integer,ldaArg:Integer,_ - aArg:Matrix Complex DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f01rcf",_ - ["m"::S,"n"::S,"lda"::S,"ifail"::S,"theta"::S,"a"::S]$Lisp,_ - ["theta"::S]$Lisp,_ - [["integer"::S,"m"::S,"n"::S,"lda"::S,"ifail"::S_ - ]$Lisp_ - ,["double complex"::S,["theta"::S,"n"::S]$Lisp,["a"::S,"lda"::S,"n"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["theta"::S,"a"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,nArg::Any,ldaArg::Any,ifailArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + aArg:Matrix Complex DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01rcf",_ + ["m"::S,"n"::S,"lda"::S,"ifail"::S,"theta"::S,"a"::S]$Lisp,_ + ["theta"::S]$Lisp,_ + [["integer"::S,"m"::S,"n"::S,"lda"::S,"ifail"::S]$Lisp_ + ,["double complex"::S,["theta"::S,"n"::S]$Lisp,_ + ["a"::S,"lda"::S,"n"::S]$Lisp]$Lisp]$Lisp,_ + ["theta"::S,"a"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,nArg::Any,ldaArg::Any,ifailArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f01rdf(transArg:String,wheretArg:String,mArg:Integer,_ - nArg:Integer,aArg:Matrix Complex DoubleFloat,ldaArg:Integer,_ - thetaArg:Matrix Complex DoubleFloat,ncolbArg:Integer,ldbArg:Integer,_ - bArg:Matrix Complex DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f01rdf",_ - ["trans"::S,"wheret"::S,"m"::S,"n"::S,"lda"::S_ - ,"ncolb"::S,"ldb"::S,"ifail"::S,"a"::S,"theta"::S,"b"::S,"work"::S]$Lisp,_ - ["work"::S]$Lisp,_ - [["integer"::S,"m"::S,"n"::S,"lda"::S,"ncolb"::S_ - ,"ldb"::S,"ifail"::S]$Lisp_ - ,["character"::S,"trans"::S,"wheret"::S]$Lisp_ - ,["double complex"::S,["a"::S,"lda"::S,"n"::S]$Lisp,["theta"::S,"n"::S]$Lisp,["b"::S,"ldb"::S,"ncolb"::S]$Lisp,["work"::S,"ncolb"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["b"::S,"ifail"::S]$Lisp,_ - [([transArg::Any,wheretArg::Any,mArg::Any,nArg::Any,ldaArg::Any,ncolbArg::Any,ldbArg::Any,ifailArg::Any,aArg::Any,thetaArg::Any,bArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + nArg:Integer,aArg:Matrix Complex DoubleFloat,ldaArg:Integer,_ + thetaArg:Matrix Complex DoubleFloat,ncolbArg:Integer,ldbArg:Integer,_ + bArg:Matrix Complex DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01rdf",_ + ["trans"::S,"wheret"::S,"m"::S,"n"::S,"lda"::S_ + ,"ncolb"::S,"ldb"::S,"ifail"::S,"a"::S,"theta"::S,_ + "b"::S,"work"::S]$Lisp,["work"::S]$Lisp,_ + [["integer"::S,"m"::S,"n"::S,"lda"::S,"ncolb"::S_ + ,"ldb"::S,"ifail"::S]$Lisp_ + ,["character"::S,"trans"::S,"wheret"::S]$Lisp_ + ,["double complex"::S,["a"::S,"lda"::S,"n"::S]$Lisp,_ + ["theta"::S,"n"::S]$Lisp,["b"::S,"ldb"::S,"ncolb"::S]$Lisp,_ + ["work"::S,"ncolb"::S]$Lisp]$Lisp]$Lisp,_ + ["b"::S,"ifail"::S]$Lisp,_ + [([transArg::Any,wheretArg::Any,mArg::Any,nArg::Any,_ + ldaArg::Any,ncolbArg::Any,ldbArg::Any,ifailArg::Any,aArg::Any,_ + thetaArg::Any,bArg::Any ])@List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result f01ref(wheretArg:String,mArg:Integer,nArg:Integer,_ - ncolqArg:Integer,ldaArg:Integer,thetaArg:Matrix Complex DoubleFloat,_ - aArg:Matrix Complex DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "f01ref",_ - ["wheret"::S,"m"::S,"n"::S,"ncolq"::S,"lda"::S_ - ,"ifail"::S,"theta"::S,"a"::S,"work"::S]$Lisp,_ - ["work"::S]$Lisp,_ - [["integer"::S,"m"::S,"n"::S,"ncolq"::S,"lda"::S_ - ,"ifail"::S]$Lisp_ - ,["character"::S,"wheret"::S]$Lisp_ - ,["double complex"::S,["theta"::S,"n"::S]$Lisp,["a"::S,"lda"::S,"n"::S]$Lisp,["work"::S,"ncolq"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["a"::S,"ifail"::S]$Lisp,_ - [([wheretArg::Any,mArg::Any,nArg::Any,ncolqArg::Any,ldaArg::Any,ifailArg::Any,thetaArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ncolqArg:Integer,ldaArg:Integer,thetaArg:Matrix Complex DoubleFloat,_ + aArg:Matrix Complex DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "f01ref",_ + ["wheret"::S,"m"::S,"n"::S,"ncolq"::S,"lda"::S_ + ,"ifail"::S,"theta"::S,"a"::S,"work"::S]$Lisp,_ + ["work"::S]$Lisp,_ + [["integer"::S,"m"::S,"n"::S,"ncolq"::S,"lda"::S_ + ,"ifail"::S]$Lisp_ + ,["character"::S,"wheret"::S]$Lisp_ + ,["double complex"::S,["theta"::S,"n"::S]$Lisp,_ + ["a"::S,"lda"::S,"n"::S]$Lisp,["work"::S,"ncolq"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["a"::S,"ifail"::S]$Lisp,_ + [([wheretArg::Any,mArg::Any,nArg::Any,ncolqArg::Any,ldaArg::Any,_ + ifailArg::Any,thetaArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result @ <>= @@ -93197,14 +93670,16 @@ NagMatrixOperationsPackage(): Exports == Implementation where ++ are concerned with function minimization only, since the problem ++ of maximizing a given function can be transformed into a ++ minimization problem simply by multiplying the function by -1. -++ See \downlink{Manual Page}{manpageXXe04}. + NagOptimisationPackage(): Exports == Implementation where S ==> Symbol FOP ==> FortranOutputStackPackage Exports ==> with e04dgf : (Integer,DoubleFloat,DoubleFloat,Integer,_ - DoubleFloat,Boolean,DoubleFloat,DoubleFloat,Integer,Integer,Integer,Integer,Matrix DoubleFloat,Integer,Union(fn:FileName,fp:Asp49(OBJFUN))) -> Result + DoubleFloat,Boolean,DoubleFloat,DoubleFloat,Integer,Integer,Integer,_ + Integer,Matrix DoubleFloat,Integer,_ + Union(fn:FileName,fp:Asp49(OBJFUN))) -> Result ++ e04dgf(n,es,fu,it,lin,list,ma,op,pr,sta,sto,ve,x,ifail,objfun) ++ minimizes an unconstrained nonlinear function of several ++ variables using a pre-conditioned, limited memory quasi-Newton @@ -93212,21 +93687,24 @@ NagOptimisationPackage(): Exports == Implementation where ++ routine is intended for use on large scale problems. ++ See \downlink{Manual Page}{manpageXXe04dgf}. e04fdf : (Integer,Integer,Integer,Integer,_ - Matrix DoubleFloat,Integer,Union(fn:FileName,fp:Asp50(LSFUN1))) -> Result + Matrix DoubleFloat,Integer,_ + Union(fn:FileName,fp:Asp50(LSFUN1))) -> Result ++ e04fdf(m,n,liw,lw,x,ifail,lsfun1) ++ is an easy-to-use algorithm for finding an unconstrained ++ minimum of a sum of squares of m nonlinear functions in n ++ variables (m>=n). No derivatives are required. ++ See \downlink{Manual Page}{manpageXXe04fdf}. e04gcf : (Integer,Integer,Integer,Integer,_ - Matrix DoubleFloat,Integer,Union(fn:FileName,fp:Asp19(LSFUN2))) -> Result + Matrix DoubleFloat,Integer,_ + Union(fn:FileName,fp:Asp19(LSFUN2))) -> Result ++ e04gcf(m,n,liw,lw,x,ifail,lsfun2) ++ is an easy-to-use quasi-Newton algorithm for finding an ++ unconstrained minimum of m nonlinear ++ functions in n variables (m>=n). First derivatives are required. ++ See \downlink{Manual Page}{manpageXXe04gcf}. e04jaf : (Integer,Integer,Integer,Integer,_ - Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Integer,Union(fn:FileName,fp:Asp24(FUNCT1))) -> Result + Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Integer,_ + Union(fn:FileName,fp:Asp24(FUNCT1))) -> Result ++ e04jaf(n,ibound,liw,lw,bl,bu,x,ifail,funct1) ++ is an easy-to-use quasi-Newton algorithm for finding a ++ minimum of a function F(x ,x ,...,x ), subject to fixed upper and @@ -93236,22 +93714,40 @@ NagOptimisationPackage(): Exports == Implementation where ++ function values only. ++ See \downlink{Manual Page}{manpageXXe04jaf}. e04mbf : (Integer,Integer,Integer,Integer,_ - Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Boolean,Integer,Integer,Matrix DoubleFloat,Integer) -> Result - ++ e04mbf(itmax,msglvl,n,nclin,nctotl,nrowa,a,bl,bu,cvec,linobj,liwork,lwork,x,ifail) + Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,_ + Matrix DoubleFloat,Matrix DoubleFloat,Boolean,Integer,Integer,_ + Matrix DoubleFloat,Integer) -> Result + ++ e04mbf(itmax,msglvl,n,nclin,nctotl,nrowa,a,bl,bu, + ++ cvec,linobj,liwork,lwork,x,ifail) ++ is an easy-to-use routine for solving linear programming ++ problems, or for finding a feasible point for such problems. It ++ is not intended for large sparse problems. ++ See \downlink{Manual Page}{manpageXXe04mbf}. - e04naf : (Integer,Integer,Integer,Integer,_ - Integer,Integer,Integer,Integer,DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Boolean,Boolean,Boolean,Integer,Integer,Matrix DoubleFloat,Matrix Integer,Integer,Union(fn:FileName,fp:Asp20(QPHESS))) -> Result - ++ e04naf(itmax,msglvl,n,nclin,nctotl,nrowa,nrowh,ncolh,bigbnd,a,bl,bu,cvec,featol,hess,cold,lpp,orthog,liwork,lwork,x,istate,ifail,qphess) + e04naf : (Integer,Integer,Integer,Integer,Integer,Integer,Integer,_ + Integer,DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ + Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ + Matrix DoubleFloat,Boolean,Boolean,Boolean,Integer,Integer,_ + Matrix DoubleFloat,Matrix Integer,Integer,_ + Union(fn:FileName,fp:Asp20(QPHESS))) -> Result + ++ e04naf(itmax,msglvl,n,nclin,nctotl,nrowa,nrowh,ncolh,bigbnd,a,bl, + ++ bu,cvec,featol,hess,cold,lpp,orthog,liwork,lwork,x,istate,ifail,qphess) ++ is a comprehensive ++ programming (QP) or linear programming (LP) problems. It is not ++ intended for large sparse problems. ++ See \downlink{Manual Page}{manpageXXe04naf}. - e04ucf : (Integer,Integer,Integer,Integer,_ - Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Integer,Integer,Boolean,DoubleFloat,Integer,DoubleFloat,DoubleFloat,Boolean,DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat,Boolean,Integer,Integer,Integer,Integer,Integer,DoubleFloat,DoubleFloat,DoubleFloat,Integer,Integer,Integer,Integer,Integer,Matrix Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Integer,Union(fn:FileName,fp:Asp55(CONFUN)),Union(fn:FileName,fp:Asp49(OBJFUN))) -> Result - ++ e04ucf(n,nclin,ncnln,nrowa,nrowj,nrowr,a,bl,bu,liwork,lwork,sta,cra,der,fea,fun,hes,infb,infs,linf,lint,list,maji,majp,mini,minp,mon,nonf,opt,ste,stao,stac,stoo,stoc,ve,istate,cjac,clamda,r,x,ifail,confun,objfun) + e04ucf : (Integer,Integer,Integer,Integer,Integer,Integer,_ + Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Integer,_ + Integer,Boolean,DoubleFloat,Integer,DoubleFloat,DoubleFloat,Boolean,_ + DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat,Boolean,Integer,_ + Integer,Integer,Integer,Integer,DoubleFloat,DoubleFloat,DoubleFloat,_ + Integer,Integer,Integer,Integer,Integer,Matrix Integer,_ + Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ + Matrix DoubleFloat,Integer,Union(fn:FileName,fp:Asp55(CONFUN)),_ + Union(fn:FileName,fp:Asp49(OBJFUN))) -> Result + ++ e04ucf(n,nclin,ncnln,nrowa,nrowj,nrowr,a,bl,bu,liwork,lwork,sta, + ++ cra,der,fea,fun,hes,infb,infs,linf,lint,list,maji,majp,mini, + ++ minp,mon,nonf,opt,ste,stao,stac,stoo,stoc,ve,istate,cjac, + ++ clamda,r,x,ifail,confun,objfun) ++ is designed to minimize an arbitrary smooth function ++ subject to constraints on the ++ variables, linear constraints. @@ -93264,7 +93760,7 @@ NagOptimisationPackage(): Exports == Implementation where ++ intended for large sparse problems. ++ See \downlink{Manual Page}{manpageXXe04ucf}. e04ycf : (Integer,Integer,Integer,DoubleFloat,_ - Matrix DoubleFloat,Integer,Matrix DoubleFloat,Integer) -> Result + Matrix DoubleFloat,Integer,Matrix DoubleFloat,Integer) -> Result ++ e04ycf(job,m,n,fsumsq,s,lv,v,ifail) ++ returns estimates of elements of the variance ++ matrix of the estimated regression coefficients for a nonlinear @@ -93291,238 +93787,290 @@ NagOptimisationPackage(): Exports == Implementation where e04dgf(nArg:Integer,esArg:DoubleFloat,fuArg:DoubleFloat,_ - itArg:Integer,linArg:DoubleFloat,listArg:Boolean,_ - maArg:DoubleFloat,opArg:DoubleFloat,prArg:Integer,_ - staArg:Integer,stoArg:Integer,veArg:Integer,_ - xArg:Matrix DoubleFloat,ifailArg:Integer,objfunArg:Union(fn:FileName,fp:Asp49(OBJFUN))): Result == - pushFortranOutputStack(objfunFilename := aspFilename "objfun")$FOP - if objfunArg case fn - then outputAsFortran(objfunArg.fn) - else outputAsFortran(objfunArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([objfunFilename]$Lisp,_ - "e04dgf",_ - ["n"::S,"es"::S,"fu"::S,"it"::S,"lin"::S_ - ,"list"::S,"ma"::S,"op"::S,"pr"::S,"sta"::S_ - ,"sto"::S,"ve"::S,"iter"::S,"objf"::S,"ifail"::S_ - ,"objfun"::S,"objgrd"::S,"x"::S,"iwork"::S,"work"::S,"iuser"::S_ - ,"user"::S]$Lisp,_ - ["iter"::S,"objf"::S,"objgrd"::S,"iwork"::S,"work"::S,"iuser"::S,"user"::S,"objfun"::S]$Lisp,_ - [["double"::S,"es"::S,"fu"::S,"lin"::S,"ma"::S_ - ,"op"::S,"objf"::S,["objgrd"::S,"n"::S]$Lisp,["x"::S,"n"::S]$Lisp,["work"::S,["*"::S,13$Lisp,"n"::S]$Lisp]$Lisp,["user"::S,"*"::S]$Lisp_ - ,"objfun"::S]$Lisp_ - ,["integer"::S,"n"::S,"it"::S,"pr"::S,"sta"::S_ - ,"sto"::S,"ve"::S,"iter"::S,"ifail"::S,["iwork"::S,["+"::S,"n"::S,1$Lisp]$Lisp]$Lisp,["iuser"::S,"*"::S]$Lisp]$Lisp_ - ,["logical"::S,"list"::S]$Lisp_ - ]$Lisp,_ - ["iter"::S,"objf"::S,"objgrd"::S,"x"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,esArg::Any,fuArg::Any,itArg::Any,linArg::Any,listArg::Any,maArg::Any,opArg::Any,prArg::Any,staArg::Any,stoArg::Any,veArg::Any,ifailArg::Any,xArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + itArg:Integer,linArg:DoubleFloat,listArg:Boolean,_ + maArg:DoubleFloat,opArg:DoubleFloat,prArg:Integer,_ + staArg:Integer,stoArg:Integer,veArg:Integer,_ + xArg:Matrix DoubleFloat,ifailArg:Integer,_ + objfunArg:Union(fn:FileName,fp:Asp49(OBJFUN))): Result == + pushFortranOutputStack(objfunFilename := aspFilename "objfun")$FOP + if objfunArg case fn + then outputAsFortran(objfunArg.fn) + else outputAsFortran(objfunArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([objfunFilename]$Lisp,_ + "e04dgf",_ + ["n"::S,"es"::S,"fu"::S,"it"::S,"lin"::S_ + ,"list"::S,"ma"::S,"op"::S,"pr"::S,"sta"::S_ + ,"sto"::S,"ve"::S,"iter"::S,"objf"::S,"ifail"::S_ + ,"objfun"::S,"objgrd"::S,"x"::S,"iwork"::S,"work"::S,"iuser"::S_ + ,"user"::S]$Lisp,_ + ["iter"::S,"objf"::S,"objgrd"::S,"iwork"::S,"work"::S,"iuser"::S,_ + "user"::S,"objfun"::S]$Lisp,_ + [["double"::S,"es"::S,"fu"::S,"lin"::S,"ma"::S_ + ,"op"::S,"objf"::S,["objgrd"::S,"n"::S]$Lisp,["x"::S,"n"::S]$Lisp,_ + ["work"::S,["*"::S,13$Lisp,"n"::S]$Lisp]$Lisp,["user"::S,"*"::S]$Lisp_ + ,"objfun"::S]$Lisp_ + ,["integer"::S,"n"::S,"it"::S,"pr"::S,"sta"::S_ + ,"sto"::S,"ve"::S,"iter"::S,"ifail"::S,["iwork"::S,_ + ["+"::S,"n"::S,1$Lisp]$Lisp]$Lisp,["iuser"::S,"*"::S]$Lisp]$Lisp_ + ,["logical"::S,"list"::S]$Lisp_ + ]$Lisp,_ + ["iter"::S,"objf"::S,"objgrd"::S,"x"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,esArg::Any,fuArg::Any,itArg::Any,linArg::Any,_ + listArg::Any,maArg::Any,opArg::Any,prArg::Any,staArg::Any,_ + stoArg::Any,veArg::Any,ifailArg::Any,xArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e04fdf(mArg:Integer,nArg:Integer,liwArg:Integer,_ - lwArg:Integer,xArg:Matrix DoubleFloat,ifailArg:Integer,_ - lsfun1Arg:Union(fn:FileName,fp:Asp50(LSFUN1))): Result == - pushFortranOutputStack(lsfun1Filename := aspFilename "lsfun1")$FOP - if lsfun1Arg case fn - then outputAsFortran(lsfun1Arg.fn) - else outputAsFortran(lsfun1Arg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([lsfun1Filename]$Lisp,_ - "e04fdf",_ - ["m"::S,"n"::S,"liw"::S,"lw"::S,"fsumsq"::S_ - ,"ifail"::S,"lsfun1"::S,"w"::S,"x"::S,"iw"::S]$Lisp,_ - ["fsumsq"::S,"w"::S,"iw"::S,"lsfun1"::S]$Lisp,_ - [["double"::S,"fsumsq"::S,["w"::S,"lw"::S]$Lisp_ - ,["x"::S,"n"::S]$Lisp,"lsfun1"::S]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"liw"::S,"lw"::S_ - ,"ifail"::S,["iw"::S,"liw"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["fsumsq"::S,"w"::S,"x"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,nArg::Any,liwArg::Any,lwArg::Any,ifailArg::Any,xArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + lwArg:Integer,xArg:Matrix DoubleFloat,ifailArg:Integer,_ + lsfun1Arg:Union(fn:FileName,fp:Asp50(LSFUN1))): Result == + pushFortranOutputStack(lsfun1Filename := aspFilename "lsfun1")$FOP + if lsfun1Arg case fn + then outputAsFortran(lsfun1Arg.fn) + else outputAsFortran(lsfun1Arg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([lsfun1Filename]$Lisp,_ + "e04fdf",_ + ["m"::S,"n"::S,"liw"::S,"lw"::S,"fsumsq"::S_ + ,"ifail"::S,"lsfun1"::S,"w"::S,"x"::S,"iw"::S]$Lisp,_ + ["fsumsq"::S,"w"::S,"iw"::S,"lsfun1"::S]$Lisp,_ + [["double"::S,"fsumsq"::S,["w"::S,"lw"::S]$Lisp_ + ,["x"::S,"n"::S]$Lisp,"lsfun1"::S]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"liw"::S,"lw"::S_ + ,"ifail"::S,["iw"::S,"liw"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["fsumsq"::S,"w"::S,"x"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,nArg::Any,liwArg::Any,lwArg::Any,_ + ifailArg::Any,xArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e04gcf(mArg:Integer,nArg:Integer,liwArg:Integer,_ - lwArg:Integer,xArg:Matrix DoubleFloat,ifailArg:Integer,_ - lsfun2Arg:Union(fn:FileName,fp:Asp19(LSFUN2))): Result == - pushFortranOutputStack(lsfun2Filename := aspFilename "lsfun2")$FOP - if lsfun2Arg case fn - then outputAsFortran(lsfun2Arg.fn) - else outputAsFortran(lsfun2Arg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([lsfun2Filename]$Lisp,_ - "e04gcf",_ - ["m"::S,"n"::S,"liw"::S,"lw"::S,"fsumsq"::S_ - ,"ifail"::S,"lsfun2"::S,"w"::S,"x"::S,"iw"::S]$Lisp,_ - ["fsumsq"::S,"w"::S,"iw"::S,"lsfun2"::S]$Lisp,_ - [["double"::S,"fsumsq"::S,["w"::S,"lw"::S]$Lisp_ - ,["x"::S,"n"::S]$Lisp,"lsfun2"::S]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"liw"::S,"lw"::S_ - ,"ifail"::S,["iw"::S,"liw"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["fsumsq"::S,"w"::S,"x"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,nArg::Any,liwArg::Any,lwArg::Any,ifailArg::Any,xArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + lwArg:Integer,xArg:Matrix DoubleFloat,ifailArg:Integer,_ + lsfun2Arg:Union(fn:FileName,fp:Asp19(LSFUN2))): Result == + pushFortranOutputStack(lsfun2Filename := aspFilename "lsfun2")$FOP + if lsfun2Arg case fn + then outputAsFortran(lsfun2Arg.fn) + else outputAsFortran(lsfun2Arg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([lsfun2Filename]$Lisp,_ + "e04gcf",_ + ["m"::S,"n"::S,"liw"::S,"lw"::S,"fsumsq"::S_ + ,"ifail"::S,"lsfun2"::S,"w"::S,"x"::S,"iw"::S]$Lisp,_ + ["fsumsq"::S,"w"::S,"iw"::S,"lsfun2"::S]$Lisp,_ + [["double"::S,"fsumsq"::S,["w"::S,"lw"::S]$Lisp_ + ,["x"::S,"n"::S]$Lisp,"lsfun2"::S]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"liw"::S,"lw"::S_ + ,"ifail"::S,["iw"::S,"liw"::S]$Lisp]$Lisp]$Lisp,_ + ["fsumsq"::S,"w"::S,"x"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,nArg::Any,liwArg::Any,lwArg::Any,ifailArg::Any,_ + xArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e04jaf(nArg:Integer,iboundArg:Integer,liwArg:Integer,_ - lwArg:Integer,blArg:Matrix DoubleFloat,buArg:Matrix DoubleFloat,_ - xArg:Matrix DoubleFloat,ifailArg:Integer,funct1Arg:Union(fn:FileName,fp:Asp24(FUNCT1))): Result == - pushFortranOutputStack(funct1Filename := aspFilename "funct1")$FOP - if funct1Arg case fn - then outputAsFortran(funct1Arg.fn) - else outputAsFortran(funct1Arg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([funct1Filename]$Lisp,_ - "e04jaf",_ - ["n"::S,"ibound"::S,"liw"::S,"lw"::S,"f"::S_ - ,"ifail"::S,"funct1"::S,"bl"::S,"bu"::S,"x"::S,"iw"::S,"w"::S_ - ]$Lisp,_ - ["f"::S,"iw"::S,"w"::S,"funct1"::S]$Lisp,_ - [["double"::S,"f"::S,["bl"::S,"n"::S]$Lisp_ - ,["bu"::S,"n"::S]$Lisp,["x"::S,"n"::S]$Lisp,["w"::S,"lw"::S]$Lisp,"funct1"::S]$Lisp_ - ,["integer"::S,"n"::S,"ibound"::S,"liw"::S_ - ,"lw"::S,"ifail"::S,["iw"::S,"liw"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["f"::S,"bl"::S,"bu"::S,"x"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,iboundArg::Any,liwArg::Any,lwArg::Any,ifailArg::Any,blArg::Any,buArg::Any,xArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + lwArg:Integer,blArg:Matrix DoubleFloat,buArg:Matrix DoubleFloat,_ + xArg:Matrix DoubleFloat,ifailArg:Integer,_ + funct1Arg:Union(fn:FileName,fp:Asp24(FUNCT1))): Result == + pushFortranOutputStack(funct1Filename := aspFilename "funct1")$FOP + if funct1Arg case fn + then outputAsFortran(funct1Arg.fn) + else outputAsFortran(funct1Arg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([funct1Filename]$Lisp,_ + "e04jaf",_ + ["n"::S,"ibound"::S,"liw"::S,"lw"::S,"f"::S_ + ,"ifail"::S,"funct1"::S,"bl"::S,"bu"::S,"x"::S,"iw"::S,"w"::S_ + ]$Lisp,_ + ["f"::S,"iw"::S,"w"::S,"funct1"::S]$Lisp,_ + [["double"::S,"f"::S,["bl"::S,"n"::S]$Lisp_ + ,["bu"::S,"n"::S]$Lisp,["x"::S,"n"::S]$Lisp,_ + ["w"::S,"lw"::S]$Lisp,"funct1"::S]$Lisp_ + ,["integer"::S,"n"::S,"ibound"::S,"liw"::S_ + ,"lw"::S,"ifail"::S,["iw"::S,"liw"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["f"::S,"bl"::S,"bu"::S,"x"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,iboundArg::Any,liwArg::Any,lwArg::Any,_ + ifailArg::Any,blArg::Any,buArg::Any,xArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e04mbf(itmaxArg:Integer,msglvlArg:Integer,nArg:Integer,_ - nclinArg:Integer,nctotlArg:Integer,nrowaArg:Integer,_ - aArg:Matrix DoubleFloat,blArg:Matrix DoubleFloat,buArg:Matrix DoubleFloat,_ - cvecArg:Matrix DoubleFloat,linobjArg:Boolean,liworkArg:Integer,_ - lworkArg:Integer,xArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e04mbf",_ - ["itmax"::S,"msglvl"::S,"n"::S,"nclin"::S,"nctotl"::S_ - ,"nrowa"::S,"linobj"::S,"liwork"::S,"lwork"::S,"objlp"::S_ - ,"ifail"::S,"a"::S,"bl"::S,"bu"::S,"cvec"::S,"istate"::S_ - ,"clamda"::S,"x"::S,"iwork"::S,"work"::S]$Lisp,_ - ["istate"::S,"objlp"::S,"clamda"::S,"iwork"::S,"work"::S]$Lisp,_ - [["double"::S,["a"::S,"nrowa"::S,"n"::S]$Lisp_ - ,["bl"::S,"nctotl"::S]$Lisp,["bu"::S,"nctotl"::S]$Lisp,["cvec"::S,"n"::S]$Lisp,"objlp"::S,["clamda"::S,"nctotl"::S]$Lisp_ - ,["x"::S,"n"::S]$Lisp,["work"::S,"lwork"::S]$Lisp]$Lisp_ - ,["integer"::S,"itmax"::S,"msglvl"::S,"n"::S_ - ,"nclin"::S,"nctotl"::S,"nrowa"::S,"liwork"::S,"lwork"::S,["istate"::S,"nctotl"::S]$Lisp,"ifail"::S,["iwork"::S,"liwork"::S]$Lisp_ - ]$Lisp_ - ,["logical"::S,"linobj"::S]$Lisp_ - ]$Lisp,_ - ["istate"::S,"objlp"::S,"clamda"::S,"x"::S,"ifail"::S]$Lisp,_ - [([itmaxArg::Any,msglvlArg::Any,nArg::Any,nclinArg::Any,nctotlArg::Any,nrowaArg::Any,linobjArg::Any,liworkArg::Any,lworkArg::Any,ifailArg::Any,aArg::Any,blArg::Any,buArg::Any,cvecArg::Any,xArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + nclinArg:Integer,nctotlArg:Integer,nrowaArg:Integer,_ + aArg:Matrix DoubleFloat,blArg:Matrix DoubleFloat,_ + buArg:Matrix DoubleFloat,_ + cvecArg:Matrix DoubleFloat,linobjArg:Boolean,liworkArg:Integer,_ + lworkArg:Integer,xArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e04mbf",_ + ["itmax"::S,"msglvl"::S,"n"::S,"nclin"::S,"nctotl"::S_ + ,"nrowa"::S,"linobj"::S,"liwork"::S,"lwork"::S,"objlp"::S_ + ,"ifail"::S,"a"::S,"bl"::S,"bu"::S,"cvec"::S,"istate"::S_ + ,"clamda"::S,"x"::S,"iwork"::S,"work"::S]$Lisp,_ + ["istate"::S,"objlp"::S,"clamda"::S,"iwork"::S,"work"::S]$Lisp,_ + [["double"::S,["a"::S,"nrowa"::S,"n"::S]$Lisp_ + ,["bl"::S,"nctotl"::S]$Lisp,["bu"::S,"nctotl"::S]$Lisp,_ + ["cvec"::S,"n"::S]$Lisp,"objlp"::S,["clamda"::S,"nctotl"::S]$Lisp_ + ,["x"::S,"n"::S]$Lisp,["work"::S,"lwork"::S]$Lisp]$Lisp_ + ,["integer"::S,"itmax"::S,"msglvl"::S,"n"::S_ + ,"nclin"::S,"nctotl"::S,"nrowa"::S,"liwork"::S,"lwork"::S,_ + ["istate"::S,"nctotl"::S]$Lisp,"ifail"::S,_ + ["iwork"::S,"liwork"::S]$Lisp]$Lisp_ + ,["logical"::S,"linobj"::S]$Lisp]$Lisp,_ + ["istate"::S,"objlp"::S,"clamda"::S,"x"::S,"ifail"::S]$Lisp,_ + [([itmaxArg::Any,msglvlArg::Any,nArg::Any,nclinArg::Any,_ + nctotlArg::Any,nrowaArg::Any,linobjArg::Any,liworkArg::Any,_ + lworkArg::Any,ifailArg::Any,aArg::Any,blArg::Any,buArg::Any,_ + cvecArg::Any,xArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e04naf(itmaxArg:Integer,msglvlArg:Integer,nArg:Integer,_ - nclinArg:Integer,nctotlArg:Integer,nrowaArg:Integer,_ - nrowhArg:Integer,ncolhArg:Integer,bigbndArg:DoubleFloat,_ - aArg:Matrix DoubleFloat,blArg:Matrix DoubleFloat,buArg:Matrix DoubleFloat,_ - cvecArg:Matrix DoubleFloat,featolArg:Matrix DoubleFloat,hessArg:Matrix DoubleFloat,_ - coldArg:Boolean,lppArg:Boolean,orthogArg:Boolean,_ - liworkArg:Integer,lworkArg:Integer,xArg:Matrix DoubleFloat,_ - istateArg:Matrix Integer,ifailArg:Integer,qphessArg:Union(fn:FileName,fp:Asp20(QPHESS))): Result == - pushFortranOutputStack(qphessFilename := aspFilename "qphess")$FOP - if qphessArg case fn - then outputAsFortran(qphessArg.fn) - else outputAsFortran(qphessArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([qphessFilename]$Lisp,_ - "e04naf",_ - ["itmax"::S,"msglvl"::S,"n"::S,"nclin"::S,"nctotl"::S_ - ,"nrowa"::S,"nrowh"::S,"ncolh"::S,"bigbnd"::S,"cold"::S_ - ,"lpp"::S,"orthog"::S,"liwork"::S,"lwork"::S,"iter"::S_ - ,"obj"::S,"ifail"::S,"qphess"::S,"a"::S,"bl"::S,"bu"::S,"cvec"::S,"featol"::S_ - ,"hess"::S,"clamda"::S,"x"::S,"istate"::S,"iwork"::S_ - ,"work"::S]$Lisp,_ - ["iter"::S,"obj"::S,"clamda"::S,"iwork"::S,"work"::S,"qphess"::S]$Lisp,_ - [["double"::S,"bigbnd"::S,["a"::S,"nrowa"::S,"n"::S]$Lisp_ - ,["bl"::S,"nctotl"::S]$Lisp,["bu"::S,"nctotl"::S]$Lisp,["cvec"::S,"n"::S]$Lisp,["featol"::S,"nctotl"::S]$Lisp_ - ,["hess"::S,"nrowh"::S,"ncolh"::S]$Lisp,"obj"::S,["clamda"::S,"nctotl"::S]$Lisp,["x"::S,"n"::S]$Lisp,["work"::S,"lwork"::S]$Lisp_ - ,"qphess"::S]$Lisp_ - ,["integer"::S,"itmax"::S,"msglvl"::S,"n"::S_ - ,"nclin"::S,"nctotl"::S,"nrowa"::S,"nrowh"::S,"ncolh"::S,"liwork"::S,"lwork"::S,"iter"::S,["istate"::S,"nctotl"::S]$Lisp_ - ,"ifail"::S,["iwork"::S,"liwork"::S]$Lisp]$Lisp_ - ,["logical"::S,"cold"::S,"lpp"::S,"orthog"::S]$Lisp_ - ]$Lisp,_ - ["iter"::S,"obj"::S,"clamda"::S,"x"::S,"istate"::S,"ifail"::S]$Lisp,_ - [([itmaxArg::Any,msglvlArg::Any,nArg::Any,nclinArg::Any,nctotlArg::Any,nrowaArg::Any,nrowhArg::Any,ncolhArg::Any,bigbndArg::Any,coldArg::Any,lppArg::Any,orthogArg::Any,liworkArg::Any,lworkArg::Any,ifailArg::Any,aArg::Any,blArg::Any,buArg::Any,cvecArg::Any,featolArg::Any,hessArg::Any,xArg::Any,istateArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + nclinArg:Integer,nctotlArg:Integer,nrowaArg:Integer,_ + nrowhArg:Integer,ncolhArg:Integer,bigbndArg:DoubleFloat,_ + aArg:Matrix DoubleFloat,blArg:Matrix DoubleFloat,_ + buArg:Matrix DoubleFloat,_ + cvecArg:Matrix DoubleFloat,featolArg:Matrix DoubleFloat,_ + hessArg:Matrix DoubleFloat,_ + coldArg:Boolean,lppArg:Boolean,orthogArg:Boolean,_ + liworkArg:Integer,lworkArg:Integer,xArg:Matrix DoubleFloat,_ + istateArg:Matrix Integer,ifailArg:Integer,_ + qphessArg:Union(fn:FileName,fp:Asp20(QPHESS))): Result == + pushFortranOutputStack(qphessFilename := aspFilename "qphess")$FOP + if qphessArg case fn + then outputAsFortran(qphessArg.fn) + else outputAsFortran(qphessArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([qphessFilename]$Lisp,_ + "e04naf",_ + ["itmax"::S,"msglvl"::S,"n"::S,"nclin"::S,"nctotl"::S_ + ,"nrowa"::S,"nrowh"::S,"ncolh"::S,"bigbnd"::S,"cold"::S_ + ,"lpp"::S,"orthog"::S,"liwork"::S,"lwork"::S,"iter"::S_ + ,"obj"::S,"ifail"::S,"qphess"::S,"a"::S,"bl"::S,"bu"::S,_ + "cvec"::S,"featol"::S_ + ,"hess"::S,"clamda"::S,"x"::S,"istate"::S,"iwork"::S_ + ,"work"::S]$Lisp,_ + ["iter"::S,"obj"::S,"clamda"::S,"iwork"::S,"work"::S,_ + "qphess"::S]$Lisp,_ + [["double"::S,"bigbnd"::S,["a"::S,"nrowa"::S,"n"::S]$Lisp_ + ,["bl"::S,"nctotl"::S]$Lisp,["bu"::S,"nctotl"::S]$Lisp,_ + ["cvec"::S,"n"::S]$Lisp,["featol"::S,"nctotl"::S]$Lisp_ + ,["hess"::S,"nrowh"::S,"ncolh"::S]$Lisp,"obj"::S,_ + ["clamda"::S,"nctotl"::S]$Lisp,["x"::S,"n"::S]$Lisp,_ + ["work"::S,"lwork"::S]$Lisp_ + ,"qphess"::S]$Lisp_ + ,["integer"::S,"itmax"::S,"msglvl"::S,"n"::S_ + ,"nclin"::S,"nctotl"::S,"nrowa"::S,"nrowh"::S,"ncolh"::S,_ + "liwork"::S,"lwork"::S,"iter"::S,["istate"::S,"nctotl"::S]$Lisp_ + ,"ifail"::S,["iwork"::S,"liwork"::S]$Lisp]$Lisp_ + ,["logical"::S,"cold"::S,"lpp"::S,"orthog"::S]$Lisp_ + ]$Lisp,_ + ["iter"::S,"obj"::S,"clamda"::S,"x"::S,"istate"::S,"ifail"::S]$Lisp,_ + [([itmaxArg::Any,msglvlArg::Any,nArg::Any,nclinArg::Any,_ + nctotlArg::Any,nrowaArg::Any,nrowhArg::Any,ncolhArg::Any,_ + bigbndArg::Any,coldArg::Any,lppArg::Any,orthogArg::Any,_ + liworkArg::Any,lworkArg::Any,ifailArg::Any,aArg::Any,blArg::Any,_ + buArg::Any,cvecArg::Any,featolArg::Any,hessArg::Any,xArg::Any,_ + istateArg::Any ])@List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e04ucf(nArg:Integer,nclinArg:Integer,ncnlnArg:Integer,_ - nrowaArg:Integer,nrowjArg:Integer,nrowrArg:Integer,_ - aArg:Matrix DoubleFloat,blArg:Matrix DoubleFloat,buArg:Matrix DoubleFloat,_ - liworkArg:Integer,lworkArg:Integer,staArg:Boolean,_ - craArg:DoubleFloat,derArg:Integer,feaArg:DoubleFloat,_ - funArg:DoubleFloat,hesArg:Boolean,infbArg:DoubleFloat,_ - infsArg:DoubleFloat,linfArg:DoubleFloat,lintArg:DoubleFloat,_ - listArg:Boolean,majiArg:Integer,majpArg:Integer,_ - miniArg:Integer,minpArg:Integer,monArg:Integer,_ - nonfArg:DoubleFloat,optArg:DoubleFloat,steArg:DoubleFloat,_ - staoArg:Integer,stacArg:Integer,stooArg:Integer,_ - stocArg:Integer,veArg:Integer,istateArg:Matrix Integer,_ - cjacArg:Matrix DoubleFloat,clamdaArg:Matrix DoubleFloat,rArg:Matrix DoubleFloat,_ - xArg:Matrix DoubleFloat,ifailArg:Integer,confunArg:Union(fn:FileName,fp:Asp55(CONFUN)),_ - objfunArg:Union(fn:FileName,fp:Asp49(OBJFUN))): Result == - pushFortranOutputStack(confunFilename := aspFilename "confun")$FOP - if confunArg case fn - then outputAsFortran(confunArg.fn) - else outputAsFortran(confunArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(objfunFilename := aspFilename "objfun")$FOP - if objfunArg case fn - then outputAsFortran(objfunArg.fn) - else outputAsFortran(objfunArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([confunFilename,objfunFilename]$Lisp,_ - "e04ucf",_ - ["n"::S,"nclin"::S,"ncnln"::S,"nrowa"::S,"nrowj"::S_ - ,"nrowr"::S,"liwork"::S,"lwork"::S,"sta"::S,"cra"::S_ - ,"der"::S,"fea"::S,"fun"::S,"hes"::S,"infb"::S_ - ,"infs"::S,"linf"::S,"lint"::S,"list"::S,"maji"::S_ - ,"majp"::S,"mini"::S,"minp"::S,"mon"::S,"nonf"::S_ - ,"opt"::S,"ste"::S,"stao"::S,"stac"::S,"stoo"::S_ - ,"stoc"::S,"ve"::S,"iter"::S,"objf"::S,"ifail"::S_ - ,"confun"::S,"objfun"::S,"a"::S,"bl"::S,"bu"::S,"c"::S,"objgrd"::S_ - ,"istate"::S,"cjac"::S,"clamda"::S,"r"::S,"x"::S_ - ,"iwork"::S,"work"::S,"iuser"::S,"user"::S]$Lisp,_ - ["iter"::S,"c"::S,"objf"::S,"objgrd"::S,"iwork"::S,"work"::S,"iuser"::S,"user"::S,"confun"::S,"objfun"::S]$Lisp,_ - [["double"::S,["a"::S,"nrowa"::S,"n"::S]$Lisp_ - ,["bl"::S,["+"::S,["+"::S,"nclin"::S,"ncnln"::S]$Lisp,"n"::S]$Lisp]$Lisp,["bu"::S,["+"::S,["+"::S,"nclin"::S,"ncnln"::S]$Lisp,"n"::S]$Lisp]$Lisp_ - ,"cra"::S,"fea"::S,"fun"::S,"infb"::S,"infs"::S,"linf"::S,"lint"::S,"nonf"::S,"opt"::S,"ste"::S_ - ,["c"::S,"ncnln"::S]$Lisp,"objf"::S,["objgrd"::S,"n"::S]$Lisp,["cjac"::S,"nrowj"::S,"n"::S]$Lisp,["clamda"::S,["+"::S,["+"::S,"nclin"::S,"ncnln"::S]$Lisp,"n"::S]$Lisp]$Lisp_ - ,["r"::S,"nrowr"::S,"n"::S]$Lisp,["x"::S,"n"::S]$Lisp,["work"::S,"lwork"::S]$Lisp_ - ,["user"::S,1$Lisp]$Lisp,"confun"::S,"objfun"::S]$Lisp_ - ,["integer"::S,"n"::S,"nclin"::S,"ncnln"::S_ - ,"nrowa"::S,"nrowj"::S,"nrowr"::S,"liwork"::S,"lwork"::S,"der"::S,"maji"::S,"majp"::S,"mini"::S,"minp"::S,"mon"::S,"stao"::S_ - ,"stac"::S,"stoo"::S,"stoc"::S,"ve"::S,"iter"::S,["istate"::S,["+"::S,["+"::S,"nclin"::S,"ncnln"::S]$Lisp,"n"::S]$Lisp]$Lisp_ - ,"ifail"::S,["iwork"::S,"liwork"::S]$Lisp,["iuser"::S,1$Lisp]$Lisp]$Lisp_ - ,["logical"::S,"sta"::S,"hes"::S,"list"::S]$Lisp_ - ]$Lisp,_ - ["iter"::S,"c"::S,"objf"::S,"objgrd"::S,"istate"::S,"cjac"::S,"clamda"::S,"r"::S,"x"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,nclinArg::Any,ncnlnArg::Any,nrowaArg::Any,nrowjArg::Any,nrowrArg::Any,liworkArg::Any,lworkArg::Any,staArg::Any,craArg::Any,derArg::Any,feaArg::Any,funArg::Any,hesArg::Any,infbArg::Any,infsArg::Any,linfArg::Any,lintArg::Any,listArg::Any,majiArg::Any,majpArg::Any,miniArg::Any,minpArg::Any,monArg::Any,nonfArg::Any,optArg::Any,steArg::Any,staoArg::Any,stacArg::Any,stooArg::Any,stocArg::Any,veArg::Any,ifailArg::Any,aArg::Any,blArg::Any,buArg::Any,istateArg::Any,cjacArg::Any,clamdaArg::Any,rArg::Any,xArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + nrowaArg:Integer,nrowjArg:Integer,nrowrArg:Integer,_ + aArg:Matrix DoubleFloat,blArg:Matrix DoubleFloat,_ + buArg:Matrix DoubleFloat,_ + liworkArg:Integer,lworkArg:Integer,staArg:Boolean,_ + craArg:DoubleFloat,derArg:Integer,feaArg:DoubleFloat,_ + funArg:DoubleFloat,hesArg:Boolean,infbArg:DoubleFloat,_ + infsArg:DoubleFloat,linfArg:DoubleFloat,lintArg:DoubleFloat,_ + listArg:Boolean,majiArg:Integer,majpArg:Integer,_ + miniArg:Integer,minpArg:Integer,monArg:Integer,_ + nonfArg:DoubleFloat,optArg:DoubleFloat,steArg:DoubleFloat,_ + staoArg:Integer,stacArg:Integer,stooArg:Integer,_ + stocArg:Integer,veArg:Integer,istateArg:Matrix Integer,_ + cjacArg:Matrix DoubleFloat,clamdaArg:Matrix DoubleFloat,_ + rArg:Matrix DoubleFloat,_ + xArg:Matrix DoubleFloat,ifailArg:Integer,_ + confunArg:Union(fn:FileName,fp:Asp55(CONFUN)),_ + objfunArg:Union(fn:FileName,fp:Asp49(OBJFUN))): Result == + pushFortranOutputStack(confunFilename := aspFilename "confun")$FOP + if confunArg case fn + then outputAsFortran(confunArg.fn) + else outputAsFortran(confunArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(objfunFilename := aspFilename "objfun")$FOP + if objfunArg case fn + then outputAsFortran(objfunArg.fn) + else outputAsFortran(objfunArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([confunFilename,objfunFilename]$Lisp,_ + "e04ucf",_ + ["n"::S,"nclin"::S,"ncnln"::S,"nrowa"::S,"nrowj"::S_ + ,"nrowr"::S,"liwork"::S,"lwork"::S,"sta"::S,"cra"::S_ + ,"der"::S,"fea"::S,"fun"::S,"hes"::S,"infb"::S_ + ,"infs"::S,"linf"::S,"lint"::S,"list"::S,"maji"::S_ + ,"majp"::S,"mini"::S,"minp"::S,"mon"::S,"nonf"::S_ + ,"opt"::S,"ste"::S,"stao"::S,"stac"::S,"stoo"::S_ + ,"stoc"::S,"ve"::S,"iter"::S,"objf"::S,"ifail"::S_ + ,"confun"::S,"objfun"::S,"a"::S,"bl"::S,"bu"::S,"c"::S,"objgrd"::S_ + ,"istate"::S,"cjac"::S,"clamda"::S,"r"::S,"x"::S_ + ,"iwork"::S,"work"::S,"iuser"::S,"user"::S]$Lisp,_ + ["iter"::S,"c"::S,"objf"::S,"objgrd"::S,"iwork"::S,"work"::S,_ + "iuser"::S,"user"::S,"confun"::S,"objfun"::S]$Lisp,_ + [["double"::S,["a"::S,"nrowa"::S,"n"::S]$Lisp_ + ,["bl"::S,["+"::S,["+"::S,"nclin"::S,"ncnln"::S]$Lisp,_ + "n"::S]$Lisp]$Lisp,["bu"::S,["+"::S,["+"::S,"nclin"::S,_ + "ncnln"::S]$Lisp,"n"::S]$Lisp]$Lisp_ + ,"cra"::S,"fea"::S,"fun"::S,"infb"::S,"infs"::S,"linf"::S,_ + "lint"::S,"nonf"::S,"opt"::S,"ste"::S_ + ,["c"::S,"ncnln"::S]$Lisp,"objf"::S,["objgrd"::S,"n"::S]$Lisp,_ + ["cjac"::S,"nrowj"::S,"n"::S]$Lisp,["clamda"::S,["+"::S,_ + ["+"::S,"nclin"::S,"ncnln"::S]$Lisp,"n"::S]$Lisp]$Lisp_ + ,["r"::S,"nrowr"::S,"n"::S]$Lisp,["x"::S,"n"::S]$Lisp,_ + ["work"::S,"lwork"::S]$Lisp_ + ,["user"::S,1$Lisp]$Lisp,"confun"::S,"objfun"::S]$Lisp_ + ,["integer"::S,"n"::S,"nclin"::S,"ncnln"::S_ + ,"nrowa"::S,"nrowj"::S,"nrowr"::S,"liwork"::S,"lwork"::S,"der"::S,_ + "maji"::S,"majp"::S,"mini"::S,"minp"::S,"mon"::S,"stao"::S_ + ,"stac"::S,"stoo"::S,"stoc"::S,"ve"::S,"iter"::S,["istate"::S,_ + ["+"::S,["+"::S,"nclin"::S,"ncnln"::S]$Lisp,"n"::S]$Lisp]$Lisp_ + ,"ifail"::S,["iwork"::S,"liwork"::S]$Lisp,_ + ["iuser"::S,1$Lisp]$Lisp]$Lisp_ + ,["logical"::S,"sta"::S,"hes"::S,"list"::S]$Lisp_ + ]$Lisp,_ + ["iter"::S,"c"::S,"objf"::S,"objgrd"::S,"istate"::S,"cjac"::S,_ + "clamda"::S,"r"::S,"x"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,nclinArg::Any,ncnlnArg::Any,nrowaArg::Any,_ + nrowjArg::Any,nrowrArg::Any,liworkArg::Any,lworkArg::Any,_ + staArg::Any,craArg::Any,derArg::Any,feaArg::Any,funArg::Any,_ + hesArg::Any,infbArg::Any,infsArg::Any,linfArg::Any,lintArg::Any,_ + listArg::Any,majiArg::Any,majpArg::Any,miniArg::Any,minpArg::Any,_ + monArg::Any,nonfArg::Any,optArg::Any,steArg::Any,staoArg::Any,_ + stacArg::Any,stooArg::Any,stocArg::Any,veArg::Any,ifailArg::Any,_ + aArg::Any,blArg::Any,buArg::Any,istateArg::Any,cjacArg::Any,_ + clamdaArg::Any,rArg::Any,xArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result e04ycf(jobArg:Integer,mArg:Integer,nArg:Integer,_ - fsumsqArg:DoubleFloat,sArg:Matrix DoubleFloat,lvArg:Integer,_ - vArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "e04ycf",_ - ["job"::S,"m"::S,"n"::S,"fsumsq"::S,"lv"::S_ - ,"ifail"::S,"s"::S,"cj"::S,"v"::S,"work"::S]$Lisp,_ - ["cj"::S,"work"::S]$Lisp,_ - [["double"::S,"fsumsq"::S,["s"::S,"n"::S]$Lisp_ - ,["cj"::S,"n"::S]$Lisp,["v"::S,"lv"::S,"n"::S]$Lisp,["work"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"job"::S,"m"::S,"n"::S,"lv"::S_ - ,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["cj"::S,"v"::S,"ifail"::S]$Lisp,_ - [([jobArg::Any,mArg::Any,nArg::Any,fsumsqArg::Any,lvArg::Any,ifailArg::Any,sArg::Any,vArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + fsumsqArg:DoubleFloat,sArg:Matrix DoubleFloat,lvArg:Integer,_ + vArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "e04ycf",_ + ["job"::S,"m"::S,"n"::S,"fsumsq"::S,"lv"::S_ + ,"ifail"::S,"s"::S,"cj"::S,"v"::S,"work"::S]$Lisp,_ + ["cj"::S,"work"::S]$Lisp,_ + [["double"::S,"fsumsq"::S,["s"::S,"n"::S]$Lisp_ + ,["cj"::S,"n"::S]$Lisp,["v"::S,"lv"::S,"n"::S]$Lisp,_ + ["work"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"job"::S,"m"::S,"n"::S,"lv"::S_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["cj"::S,"v"::S,"ifail"::S]$Lisp,_ + [([jobArg::Any,mArg::Any,nArg::Any,fsumsqArg::Any,lvArg::Any,_ + ifailArg::Any,sArg::Any,vArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result @ <>= @@ -98039,14 +98587,16 @@ NagOptimisationPackage(): Exports == Implementation where ++ value problems and eigenvalue problems). Routines are available ++ for initial-value problems, two-point boundary-value problems and ++ Sturm-Liouville eigenvalue problems. -++ See \downlink{Manual Page}{manpageXXd02}. + NagOrdinaryDifferentialEquationsPackage(): Exports == Implementation where S ==> Symbol FOP ==> FortranOutputStackPackage Exports ==> with d02bbf : (DoubleFloat,Integer,Integer,Integer,_ - DoubleFloat,Matrix DoubleFloat,DoubleFloat,Integer,Union(fn:FileName,fp:Asp7(FCN)),Union(fn:FileName,fp:Asp8(OUTPUT))) -> Result + DoubleFloat,Matrix DoubleFloat,DoubleFloat,Integer,_ + Union(fn:FileName,fp:Asp7(FCN)),_ + Union(fn:FileName,fp:Asp8(OUTPUT))) -> Result ++ d02bbf(xend,m,n,irelab,x,y,tol,ifail,fcn,output) ++ integrates a system of first-order ordinary differential ++ equations over an interval with suitable initial conditions, @@ -98054,7 +98604,9 @@ NagOrdinaryDifferentialEquationsPackage(): Exports == Implementation where ++ points specified by the user. ++ See \downlink{Manual Page}{manpageXXd02bbf}. d02bhf : (DoubleFloat,Integer,Integer,DoubleFloat,_ - DoubleFloat,Matrix DoubleFloat,DoubleFloat,Integer,Union(fn:FileName,fp:Asp9(G)),Union(fn:FileName,fp:Asp7(FCN))) -> Result + DoubleFloat,Matrix DoubleFloat,DoubleFloat,Integer,_ + Union(fn:FileName,fp:Asp9(G)),_ + Union(fn:FileName,fp:Asp7(FCN))) -> Result ++ d02bhf(xend,n,irelab,hmax,x,y,tol,ifail,g,fcn) ++ integrates a system of first-order ordinary differential ++ equations over an interval with suitable initial conditions, @@ -98062,7 +98614,9 @@ NagOrdinaryDifferentialEquationsPackage(): Exports == Implementation where ++ function of the solution is zero. ++ See \downlink{Manual Page}{manpageXXd02bhf}. d02cjf : (DoubleFloat,Integer,Integer,DoubleFloat,_ - String,DoubleFloat,Matrix DoubleFloat,Integer,Union(fn:FileName,fp:Asp9(G)),Union(fn:FileName,fp:Asp7(FCN)),Union(fn:FileName,fp:Asp8(OUTPUT))) -> Result + String,DoubleFloat,Matrix DoubleFloat,Integer,_ + Union(fn:FileName,fp:Asp9(G)),Union(fn:FileName,fp:Asp7(FCN)),_ + Union(fn:FileName,fp:Asp8(OUTPUT))) -> Result ++ d02cjf(xend,m,n,tol,relabs,x,y,ifail,g,fcn,output) ++ integrates a system of first-order ordinary differential ++ equations over a range with suitable initial conditions, using a @@ -98071,7 +98625,10 @@ NagOrdinaryDifferentialEquationsPackage(): Exports == Implementation where ++ solution at points specified by the user, if desired. ++ See \downlink{Manual Page}{manpageXXd02cjf}. d02ejf : (DoubleFloat,Integer,Integer,String,_ - Integer,DoubleFloat,Matrix DoubleFloat,DoubleFloat,Integer,Union(fn:FileName,fp:Asp9(G)),Union(fn:FileName,fp:Asp7(FCN)),Union(fn:FileName,fp:Asp31(PEDERV)),Union(fn:FileName,fp:Asp8(OUTPUT))) -> Result + Integer,DoubleFloat,Matrix DoubleFloat,DoubleFloat,Integer,_ + Union(fn:FileName,fp:Asp9(G)),Union(fn:FileName,fp:Asp7(FCN)),_ + Union(fn:FileName,fp:Asp31(PEDERV)),_ + Union(fn:FileName,fp:Asp8(OUTPUT))) -> Result ++ d02ejf(xend,m,n,relabs,iw,x,y,tol,ifail,g,fcn,pederv,output) ++ integrates a stiff system of first-order ordinary ++ differential equations over an interval with suitable initial @@ -98082,22 +98639,29 @@ NagOrdinaryDifferentialEquationsPackage(): Exports == Implementation where ++ desired. ++ See \downlink{Manual Page}{manpageXXd02ejf}. d02gaf : (Matrix DoubleFloat,Matrix DoubleFloat,Integer,DoubleFloat,_ - DoubleFloat,DoubleFloat,Integer,Integer,Integer,Matrix DoubleFloat,Integer,Integer,Union(fn:FileName,fp:Asp7(FCN))) -> Result + DoubleFloat,DoubleFloat,Integer,Integer,Integer,Matrix DoubleFloat,_ + Integer,Integer,Union(fn:FileName,fp:Asp7(FCN))) -> Result ++ d02gaf(u,v,n,a,b,tol,mnp,lw,liw,x,np,ifail,fcn) ++ solves the two-point boundary-value problem with assigned ++ boundary values for a system of ordinary differential equations, ++ using a deferred correction technique and a Newton iteration. ++ See \downlink{Manual Page}{manpageXXd02gaf}. d02gbf : (DoubleFloat,DoubleFloat,Integer,DoubleFloat,_ - Integer,Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Integer,Integer,Union(fn:FileName,fp:Asp77(FCNF)),Union(fn:FileName,fp:Asp78(FCNG))) -> Result + Integer,Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,_ + Matrix DoubleFloat,Matrix DoubleFloat,Integer,Integer,_ + Union(fn:FileName,fp:Asp77(FCNF)),_ + Union(fn:FileName,fp:Asp78(FCNG))) -> Result ++ d02gbf(a,b,n,tol,mnp,lw,liw,c,d,gam,x,np,ifail,fcnf,fcng) ++ solves a general linear two-point boundary value problem ++ for a system of ordinary differential equations using a deferred ++ correction technique. ++ See \downlink{Manual Page}{manpageXXd02gbf}. d02kef : (Matrix DoubleFloat,Integer,Integer,DoubleFloat,_ - Integer,Integer,DoubleFloat,DoubleFloat,Matrix DoubleFloat,Integer,Integer,Union(fn:FileName,fp:Asp10(COEFFN)),Union(fn:FileName,fp:Asp80(BDYVAL))) -> Result - ++ d02kef(xpoint,m,k,tol,maxfun,match,elam,delam,hmax,maxit,ifail,coeffn,bdyval) + Integer,Integer,DoubleFloat,DoubleFloat,Matrix DoubleFloat,Integer,_ + Integer,Union(fn:FileName,fp:Asp10(COEFFN)),_ + Union(fn:FileName,fp:Asp80(BDYVAL))) -> Result + ++ d02kef(xpoint,m,k,tol,maxfun,match,elam,delam, + ++ hmax,maxit,ifail,coeffn,bdyval) ++ finds a specified eigenvalue of a regular singular second- ++ order Sturm-Liouville system on a finite or infinite range, using ++ a Pruefer transformation and a shooting method. It also reports @@ -98106,10 +98670,14 @@ NagOrdinaryDifferentialEquationsPackage(): Exports == Implementation where ++ derivatives. ++ See \downlink{Manual Page}{manpageXXd02kef}. ++ ASP domains Asp12 and Asp33 are used to supply default - ++ subroutines for the MONIT and REPORT arguments via their \axiomOp{outputAsFortran} operation. + ++ subroutines for the MONIT and REPORT arguments via their + ++ \axiomOp{outputAsFortran} operation. d02kef : (Matrix DoubleFloat,Integer,Integer,DoubleFloat,_ - Integer,Integer,DoubleFloat,DoubleFloat,Matrix DoubleFloat,Integer,Integer,Union(fn:FileName,fp:Asp10(COEFFN)),Union(fn:FileName,fp:Asp80(BDYVAL)),FileName,FileName) -> Result - ++ d02kef(xpoint,m,k,tol,maxfun,match,elam,delam,hmax,maxit,ifail,coeffn,bdyval,monit,report) + Integer,Integer,DoubleFloat,DoubleFloat,Matrix DoubleFloat,Integer,_ + Integer,Union(fn:FileName,fp:Asp10(COEFFN)),_ + Union(fn:FileName,fp:Asp80(BDYVAL)),FileName,FileName) -> Result + ++ d02kef(xpoint,m,k,tol,maxfun,match,elam,delam, + ++ hmax,maxit,ifail,coeffn,bdyval,monit,report) ++ finds a specified eigenvalue of a regular singular second- ++ order Sturm-Liouville system on a finite or infinite range, using ++ a Pruefer transformation and a shooting method. It also reports @@ -98117,12 +98685,17 @@ NagOrdinaryDifferentialEquationsPackage(): Exports == Implementation where ++ made for discontinuities in the coefficient functions or their ++ derivatives. ++ See \downlink{Manual Page}{manpageXXd02kef}. - ++ Files \spad{monit} and \spad{report} will be used to define the subroutines for the + ++ Files \spad{monit} and \spad{report} will be used to define + ++ the subroutines for the ++ MONIT and REPORT arguments. ++ See \downlink{Manual Page}{manpageXXd02gbf}. d02raf : (Integer,Integer,Integer,Integer,_ - DoubleFloat,Integer,Integer,Integer,Integer,Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,DoubleFloat,Integer,Union(fn:FileName,fp:Asp41(FCN,JACOBF,JACEPS)),Union(fn:FileName,fp:Asp42(G,JACOBG,JACGEP))) -> Result - ++ d02raf(n,mnp,numbeg,nummix,tol,init,iy,ijac,lwork,liwork,np,x,y,deleps,ifail,fcn,g) + DoubleFloat,Integer,Integer,Integer,Integer,Integer,Integer,_ + Matrix DoubleFloat,Matrix DoubleFloat,DoubleFloat,Integer,_ + Union(fn:FileName,fp:Asp41(FCN,JACOBF,JACEPS)),_ + Union(fn:FileName,fp:Asp42(G,JACOBG,JACGEP))) -> Result + ++ d02raf(n,mnp,numbeg,nummix,tol,init,iy,ijac,lwork, + ++ liwork,np,x,y,deleps,ifail,fcn,g) ++ solves the two-point boundary-value problem with general ++ boundary conditions for a system of ordinary differential ++ equations, using a deferred correction technique and Newton @@ -98148,309 +98721,343 @@ NagOrdinaryDifferentialEquationsPackage(): Exports == Implementation where d02bbf(xendArg:DoubleFloat,mArg:Integer,nArg:Integer,_ - irelabArg:Integer,xArg:DoubleFloat,yArg:Matrix DoubleFloat,_ - tolArg:DoubleFloat,ifailArg:Integer,fcnArg:Union(fn:FileName,fp:Asp7(FCN)),_ - outputArg:Union(fn:FileName,fp:Asp8(OUTPUT))): Result == - pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP - if fcnArg case fn - then outputAsFortran(fcnArg.fn) - else outputAsFortran(fcnArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(outputFilename := aspFilename "output")$FOP - if outputArg case fn - then outputAsFortran(outputArg.fn) - else outputAsFortran(outputArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([fcnFilename, outputFilename]$Lisp,_ - "d02bbf",_ - ["xend"::S,"m"::S,"n"::S,"irelab"::S,"x"::S_ - ,"tol"::S,"ifail"::S,"fcn"::S,"output"::S,"result"::S,"y"::S,"w"::S]$Lisp,_ - ["result"::S,"w"::S,"fcn"::S,"output"::S]$Lisp,_ - [["double"::S,"xend"::S,["result"::S,"m"::S,"n"::S]$Lisp_ - ,"x"::S,["y"::S,"n"::S]$Lisp,"tol"::S,["w"::S,"n"::S,7$Lisp]$Lisp,"fcn"::S,"output"::S]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"irelab"::S,"ifail"::S_ - ]$Lisp_ - ]$Lisp,_ - ["result"::S,"x"::S,"y"::S,"tol"::S,"ifail"::S]$Lisp,_ - [([xendArg::Any,mArg::Any,nArg::Any,irelabArg::Any,xArg::Any,tolArg::Any,ifailArg::Any,yArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + irelabArg:Integer,xArg:DoubleFloat,yArg:Matrix DoubleFloat,_ + tolArg:DoubleFloat,ifailArg:Integer,_ + fcnArg:Union(fn:FileName,fp:Asp7(FCN)),_ + outputArg:Union(fn:FileName,fp:Asp8(OUTPUT))): Result == + pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP + if fcnArg case fn + then outputAsFortran(fcnArg.fn) + else outputAsFortran(fcnArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(outputFilename := aspFilename "output")$FOP + if outputArg case fn + then outputAsFortran(outputArg.fn) + else outputAsFortran(outputArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([fcnFilename, outputFilename]$Lisp,_ + "d02bbf",_ + ["xend"::S,"m"::S,"n"::S,"irelab"::S,"x"::S,"tol"::S,"ifail"::S,_ + "fcn"::S,"output"::S,"result"::S,"y"::S,"w"::S]$Lisp,_ + ["result"::S,"w"::S,"fcn"::S,"output"::S]$Lisp,_ + [["double"::S,"xend"::S,["result"::S,"m"::S,"n"::S]$Lisp_ + ,"x"::S,["y"::S,"n"::S]$Lisp,"tol"::S,["w"::S,"n"::S,7$Lisp]$Lisp,_ + "fcn"::S,"output"::S]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"irelab"::S,"ifail"::S]$Lisp]$Lisp,_ + ["result"::S,"x"::S,"y"::S,"tol"::S,"ifail"::S]$Lisp,_ + [([xendArg::Any,mArg::Any,nArg::Any,irelabArg::Any,xArg::Any,_ + tolArg::Any,ifailArg::Any,yArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d02bhf(xendArg:DoubleFloat,nArg:Integer,irelabArg:Integer,_ - hmaxArg:DoubleFloat,xArg:DoubleFloat,yArg:Matrix DoubleFloat,_ - tolArg:DoubleFloat,ifailArg:Integer,gArg:Union(fn:FileName,fp:Asp9(G)),_ - fcnArg:Union(fn:FileName,fp:Asp7(FCN))): Result == - pushFortranOutputStack(gFilename := aspFilename "g")$FOP - if gArg case fn - then outputAsFortran(gArg.fn) - else outputAsFortran(gArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP - if fcnArg case fn - then outputAsFortran(fcnArg.fn) - else outputAsFortran(fcnArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([gFilename,fcnFilename]$Lisp,_ - "d02bhf",_ - ["xend"::S,"n"::S,"irelab"::S,"hmax"::S,"x"::S_ - ,"tol"::S,"ifail"::S,"g"::S,"fcn"::S,"y"::S,"w"::S]$Lisp,_ - ["w"::S,"g"::S,"fcn"::S]$Lisp,_ - [["double"::S,"xend"::S,"hmax"::S,"x"::S,["y"::S,"n"::S]$Lisp_ - ,"tol"::S,["w"::S,"n"::S,7$Lisp]$Lisp,"g"::S,"fcn"::S]$Lisp_ - ,["integer"::S,"n"::S,"irelab"::S,"ifail"::S_ - ]$Lisp_ - ]$Lisp,_ - ["x"::S,"y"::S,"tol"::S,"ifail"::S]$Lisp,_ - [([xendArg::Any,nArg::Any,irelabArg::Any,hmaxArg::Any,xArg::Any,tolArg::Any,ifailArg::Any,yArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + hmaxArg:DoubleFloat,xArg:DoubleFloat,yArg:Matrix DoubleFloat,_ + tolArg:DoubleFloat,ifailArg:Integer,_ + gArg:Union(fn:FileName,fp:Asp9(G)),_ + fcnArg:Union(fn:FileName,fp:Asp7(FCN))): Result == + pushFortranOutputStack(gFilename := aspFilename "g")$FOP + if gArg case fn + then outputAsFortran(gArg.fn) + else outputAsFortran(gArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP + if fcnArg case fn + then outputAsFortran(fcnArg.fn) + else outputAsFortran(fcnArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([gFilename,fcnFilename]$Lisp,_ + "d02bhf",_ + ["xend"::S,"n"::S,"irelab"::S,"hmax"::S,"x"::S_ + ,"tol"::S,"ifail"::S,"g"::S,"fcn"::S,"y"::S,"w"::S]$Lisp,_ + ["w"::S,"g"::S,"fcn"::S]$Lisp,_ + [["double"::S,"xend"::S,"hmax"::S,"x"::S,["y"::S,"n"::S]$Lisp_ + ,"tol"::S,["w"::S,"n"::S,7$Lisp]$Lisp,"g"::S,"fcn"::S]$Lisp_ + ,["integer"::S,"n"::S,"irelab"::S,"ifail"::S]$Lisp]$Lisp,_ + ["x"::S,"y"::S,"tol"::S,"ifail"::S]$Lisp,_ + [([xendArg::Any,nArg::Any,irelabArg::Any,hmaxArg::Any,_ + xArg::Any,tolArg::Any,ifailArg::Any,yArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d02cjf(xendArg:DoubleFloat,mArg:Integer,nArg:Integer,_ - tolArg:DoubleFloat,relabsArg:String,xArg:DoubleFloat,_ - yArg:Matrix DoubleFloat,ifailArg:Integer,gArg:Union(fn:FileName,fp:Asp9(G)),_ - fcnArg:Union(fn:FileName,fp:Asp7(FCN)),outputArg:Union(fn:FileName,fp:Asp8(OUTPUT))): Result == - pushFortranOutputStack(gFilename := aspFilename "g")$FOP - if gArg case fn - then outputAsFortran(gArg.fn) - else outputAsFortran(gArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP - if fcnArg case fn - then outputAsFortran(fcnArg.fn) - else outputAsFortran(fcnArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(outputFilename := aspFilename "output")$FOP - if outputArg case fn - then outputAsFortran(outputArg.fn) - else outputAsFortran(outputArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([gFilename,fcnFilename,outputFilename]$Lisp,_ - "d02cjf",_ - ["xend"::S,"m"::S,"n"::S,"tol"::S,"relabs"::S_ - ,"x"::S,"ifail"::S,"g"::S,"fcn"::S,"output"::S_ - ,"result"::S,"y"::S,"w"::S]$Lisp,_ - ["result"::S,"w"::S,"g"::S,"fcn"::S,"output"::S]$Lisp,_ - [["double"::S,"xend"::S,"tol"::S,["result"::S,"m"::S,"n"::S]$Lisp_ - ,"x"::S,["y"::S,"n"::S]$Lisp,["w"::S,["+"::S,["*"::S,21$Lisp,"n"::S]$Lisp,28$Lisp]$Lisp]$Lisp,"g"::S_ - ,"fcn"::S,"output"::S]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"ifail"::S]$Lisp_ - ,["character"::S,"relabs"::S]$Lisp_ - ]$Lisp,_ - ["result"::S,"x"::S,"y"::S,"ifail"::S]$Lisp,_ - [([xendArg::Any,mArg::Any,nArg::Any,tolArg::Any,relabsArg::Any,xArg::Any,ifailArg::Any,yArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + tolArg:DoubleFloat,relabsArg:String,xArg:DoubleFloat,_ + yArg:Matrix DoubleFloat,ifailArg:Integer,_ + gArg:Union(fn:FileName,fp:Asp9(G)),_ + fcnArg:Union(fn:FileName,fp:Asp7(FCN)),_ + outputArg:Union(fn:FileName,fp:Asp8(OUTPUT))): Result == + pushFortranOutputStack(gFilename := aspFilename "g")$FOP + if gArg case fn + then outputAsFortran(gArg.fn) + else outputAsFortran(gArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP + if fcnArg case fn + then outputAsFortran(fcnArg.fn) + else outputAsFortran(fcnArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(outputFilename := aspFilename "output")$FOP + if outputArg case fn + then outputAsFortran(outputArg.fn) + else outputAsFortran(outputArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([gFilename,fcnFilename,outputFilename]$Lisp,_ + "d02cjf",_ + ["xend"::S,"m"::S,"n"::S,"tol"::S,"relabs"::S_ + ,"x"::S,"ifail"::S,"g"::S,"fcn"::S,"output"::S_ + ,"result"::S,"y"::S,"w"::S]$Lisp,_ + ["result"::S,"w"::S,"g"::S,"fcn"::S,"output"::S]$Lisp,_ + [["double"::S,"xend"::S,"tol"::S,["result"::S,"m"::S,"n"::S]$Lisp_ + ,"x"::S,["y"::S,"n"::S]$Lisp,["w"::S,["+"::S,_ + ["*"::S,21$Lisp,"n"::S]$Lisp,28$Lisp]$Lisp]$Lisp,"g"::S_ + ,"fcn"::S,"output"::S]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"ifail"::S]$Lisp_ + ,["character"::S,"relabs"::S]$Lisp]$Lisp,_ + ["result"::S,"x"::S,"y"::S,"ifail"::S]$Lisp,_ + [([xendArg::Any,mArg::Any,nArg::Any,tolArg::Any,relabsArg::Any,_ + xArg::Any,ifailArg::Any,yArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d02ejf(xendArg:DoubleFloat,mArg:Integer,nArg:Integer,_ - relabsArg:String,iwArg:Integer,xArg:DoubleFloat,_ - yArg:Matrix DoubleFloat,tolArg:DoubleFloat,ifailArg:Integer,_ - gArg:Union(fn:FileName,fp:Asp9(G)),fcnArg:Union(fn:FileName,fp:Asp7(FCN)),pedervArg:Union(fn:FileName,fp:Asp31(PEDERV)),_ - outputArg:Union(fn:FileName,fp:Asp8(OUTPUT))): Result == - pushFortranOutputStack(gFilename := aspFilename "g")$FOP - if gArg case fn - then outputAsFortran(gArg.fn) - else outputAsFortran(gArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP - if fcnArg case fn - then outputAsFortran(fcnArg.fn) - else outputAsFortran(fcnArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(pedervFilename := aspFilename "pederv")$FOP - if pedervArg case fn - then outputAsFortran(pedervArg.fn) - else outputAsFortran(pedervArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(outputFilename := aspFilename "output")$FOP - if outputArg case fn - then outputAsFortran(outputArg.fn) - else outputAsFortran(outputArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([gFilename,fcnFilename,pedervFilename,outputFilename]$Lisp,_ - "d02ejf",_ - ["xend"::S,"m"::S,"n"::S,"relabs"::S,"iw"::S_ - ,"x"::S,"tol"::S,"ifail"::S,"g"::S,"fcn"::S_ - ,"pederv"::S,"output"::S,"result"::S,"y"::S,"w"::S]$Lisp,_ - ["result"::S,"w"::S,"g"::S,"fcn"::S,"pederv"::S,"output"::S]$Lisp,_ - [["double"::S,"xend"::S,["result"::S,"m"::S,"n"::S]$Lisp_ - ,"x"::S,["y"::S,"n"::S]$Lisp,"tol"::S,["w"::S,"iw"::S]$Lisp,"g"::S,"fcn"::S,"pederv"::S,"output"::S]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"iw"::S,"ifail"::S_ - ]$Lisp_ - ,["character"::S,"relabs"::S]$Lisp_ - ]$Lisp,_ - ["result"::S,"x"::S,"y"::S,"tol"::S,"ifail"::S]$Lisp,_ - [([xendArg::Any,mArg::Any,nArg::Any,relabsArg::Any,iwArg::Any,xArg::Any,tolArg::Any,ifailArg::Any,yArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + relabsArg:String,iwArg:Integer,xArg:DoubleFloat,_ + yArg:Matrix DoubleFloat,tolArg:DoubleFloat,ifailArg:Integer,_ + gArg:Union(fn:FileName,fp:Asp9(G)),_ + fcnArg:Union(fn:FileName,fp:Asp7(FCN)),_ + pedervArg:Union(fn:FileName,fp:Asp31(PEDERV)),_ + outputArg:Union(fn:FileName,fp:Asp8(OUTPUT))): Result == + pushFortranOutputStack(gFilename := aspFilename "g")$FOP + if gArg case fn + then outputAsFortran(gArg.fn) + else outputAsFortran(gArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP + if fcnArg case fn + then outputAsFortran(fcnArg.fn) + else outputAsFortran(fcnArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(pedervFilename := aspFilename "pederv")$FOP + if pedervArg case fn + then outputAsFortran(pedervArg.fn) + else outputAsFortran(pedervArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(outputFilename := aspFilename "output")$FOP + if outputArg case fn + then outputAsFortran(outputArg.fn) + else outputAsFortran(outputArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([gFilename,fcnFilename,pedervFilename,_ + outputFilename]$Lisp,_ + "d02ejf",_ + ["xend"::S,"m"::S,"n"::S,"relabs"::S,"iw"::S_ + ,"x"::S,"tol"::S,"ifail"::S,"g"::S,"fcn"::S_ + ,"pederv"::S,"output"::S,"result"::S,"y"::S,"w"::S]$Lisp,_ + ["result"::S,"w"::S,"g"::S,"fcn"::S,"pederv"::S,"output"::S]$Lisp,_ + [["double"::S,"xend"::S,["result"::S,"m"::S,"n"::S]$Lisp_ + ,"x"::S,["y"::S,"n"::S]$Lisp,"tol"::S,["w"::S,"iw"::S]$Lisp,_ + "g"::S,"fcn"::S,"pederv"::S,"output"::S]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"iw"::S,"ifail"::S_ + ]$Lisp_ + ,["character"::S,"relabs"::S]$Lisp_ + ]$Lisp,_ + ["result"::S,"x"::S,"y"::S,"tol"::S,"ifail"::S]$Lisp,_ + [([xendArg::Any,mArg::Any,nArg::Any,relabsArg::Any,iwArg::Any,_ + xArg::Any,tolArg::Any,ifailArg::Any,yArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d02gaf(uArg:Matrix DoubleFloat,vArg:Matrix DoubleFloat,nArg:Integer,_ - aArg:DoubleFloat,bArg:DoubleFloat,tolArg:DoubleFloat,_ - mnpArg:Integer,lwArg:Integer,liwArg:Integer,_ - xArg:Matrix DoubleFloat,npArg:Integer,ifailArg:Integer,_ - fcnArg:Union(fn:FileName,fp:Asp7(FCN))): Result == - pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP - if fcnArg case fn - then outputAsFortran(fcnArg.fn) - else outputAsFortran(fcnArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([fcnFilename]$Lisp,_ - "d02gaf",_ - ["n"::S,"a"::S,"b"::S,"tol"::S,"mnp"::S_ - ,"lw"::S,"liw"::S,"np"::S,"ifail"::S,"fcn"::S_ - ,"u"::S,"v"::S,"y"::S,"x"::S,"w"::S_ - ,"iw"::S]$Lisp,_ - ["y"::S,"w"::S,"iw"::S,"fcn"::S]$Lisp,_ - [["double"::S,["u"::S,"n"::S,2$Lisp]$Lisp,["v"::S,"n"::S,2$Lisp]$Lisp_ - ,"a"::S,"b"::S,"tol"::S,["y"::S,"n"::S,"mnp"::S]$Lisp,["x"::S,"mnp"::S]$Lisp,["w"::S,"lw"::S]$Lisp_ - ,"fcn"::S]$Lisp_ - ,["integer"::S,"n"::S,"mnp"::S,"lw"::S,"liw"::S_ - ,"np"::S,"ifail"::S,["iw"::S,"liw"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["y"::S,"x"::S,"np"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,aArg::Any,bArg::Any,tolArg::Any,mnpArg::Any,lwArg::Any,liwArg::Any,npArg::Any,ifailArg::Any,uArg::Any,vArg::Any,xArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + aArg:DoubleFloat,bArg:DoubleFloat,tolArg:DoubleFloat,_ + mnpArg:Integer,lwArg:Integer,liwArg:Integer,_ + xArg:Matrix DoubleFloat,npArg:Integer,ifailArg:Integer,_ + fcnArg:Union(fn:FileName,fp:Asp7(FCN))): Result == + pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP + if fcnArg case fn + then outputAsFortran(fcnArg.fn) + else outputAsFortran(fcnArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([fcnFilename]$Lisp,_ + "d02gaf",_ + ["n"::S,"a"::S,"b"::S,"tol"::S,"mnp"::S_ + ,"lw"::S,"liw"::S,"np"::S,"ifail"::S,"fcn"::S_ + ,"u"::S,"v"::S,"y"::S,"x"::S,"w"::S_ + ,"iw"::S]$Lisp,_ + ["y"::S,"w"::S,"iw"::S,"fcn"::S]$Lisp,_ + [["double"::S,["u"::S,"n"::S,2$Lisp]$Lisp,["v"::S,"n"::S,2$Lisp]$Lisp_ + ,"a"::S,"b"::S,"tol"::S,["y"::S,"n"::S,"mnp"::S]$Lisp,_ + ["x"::S,"mnp"::S]$Lisp,["w"::S,"lw"::S]$Lisp_ + ,"fcn"::S]$Lisp_ + ,["integer"::S,"n"::S,"mnp"::S,"lw"::S,"liw"::S_ + ,"np"::S,"ifail"::S,["iw"::S,"liw"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["y"::S,"x"::S,"np"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,aArg::Any,bArg::Any,tolArg::Any,mnpArg::Any,_ + lwArg::Any,liwArg::Any,npArg::Any,ifailArg::Any,uArg::Any,_ + vArg::Any,xArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d02gbf(aArg:DoubleFloat,bArg:DoubleFloat,nArg:Integer,_ - tolArg:DoubleFloat,mnpArg:Integer,lwArg:Integer,_ - liwArg:Integer,cArg:Matrix DoubleFloat,dArg:Matrix DoubleFloat,_ - gamArg:Matrix DoubleFloat,xArg:Matrix DoubleFloat,npArg:Integer,_ - ifailArg:Integer,fcnfArg:Union(fn:FileName,fp:Asp77(FCNF)),fcngArg:Union(fn:FileName,fp:Asp78(FCNG))): Result == - pushFortranOutputStack(fcnfFilename := aspFilename "fcnf")$FOP - if fcnfArg case fn - then outputAsFortran(fcnfArg.fn) - else outputAsFortran(fcnfArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(fcngFilename := aspFilename "fcng")$FOP - if fcngArg case fn - then outputAsFortran(fcngArg.fn) - else outputAsFortran(fcngArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([fcnfFilename,fcngFilename]$Lisp,_ - "d02gbf",_ - ["a"::S,"b"::S,"n"::S,"tol"::S,"mnp"::S_ - ,"lw"::S,"liw"::S,"np"::S,"ifail"::S,"fcnf"::S_ - ,"fcng"::S,"y"::S,"c"::S,"d"::S,"gam"::S,"x"::S_ - ,"w"::S,"iw"::S]$Lisp,_ - ["y"::S,"w"::S,"iw"::S,"fcnf"::S,"fcng"::S]$Lisp,_ - [["double"::S,"a"::S,"b"::S,"tol"::S,["y"::S,"n"::S,"mnp"::S]$Lisp_ - ,["c"::S,"n"::S,"n"::S]$Lisp,["d"::S,"n"::S,"n"::S]$Lisp,["gam"::S,"n"::S]$Lisp,["x"::S,"mnp"::S]$Lisp_ - ,["w"::S,"lw"::S]$Lisp,"fcnf"::S,"fcng"::S]$Lisp_ - ,["integer"::S,"n"::S,"mnp"::S,"lw"::S,"liw"::S_ - ,"np"::S,"ifail"::S,["iw"::S,"liw"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["y"::S,"c"::S,"d"::S,"gam"::S,"x"::S,"np"::S,"ifail"::S]$Lisp,_ - [([aArg::Any,bArg::Any,nArg::Any,tolArg::Any,mnpArg::Any,lwArg::Any,liwArg::Any,npArg::Any,ifailArg::Any,cArg::Any,dArg::Any,gamArg::Any,xArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + tolArg:DoubleFloat,mnpArg:Integer,lwArg:Integer,_ + liwArg:Integer,cArg:Matrix DoubleFloat,dArg:Matrix DoubleFloat,_ + gamArg:Matrix DoubleFloat,xArg:Matrix DoubleFloat,npArg:Integer,_ + ifailArg:Integer,fcnfArg:Union(fn:FileName,fp:Asp77(FCNF)),_ + fcngArg:Union(fn:FileName,fp:Asp78(FCNG))): Result == + pushFortranOutputStack(fcnfFilename := aspFilename "fcnf")$FOP + if fcnfArg case fn + then outputAsFortran(fcnfArg.fn) + else outputAsFortran(fcnfArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(fcngFilename := aspFilename "fcng")$FOP + if fcngArg case fn + then outputAsFortran(fcngArg.fn) + else outputAsFortran(fcngArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([fcnfFilename,fcngFilename]$Lisp,_ + "d02gbf",_ + ["a"::S,"b"::S,"n"::S,"tol"::S,"mnp"::S_ + ,"lw"::S,"liw"::S,"np"::S,"ifail"::S,"fcnf"::S_ + ,"fcng"::S,"y"::S,"c"::S,"d"::S,"gam"::S,"x"::S_ + ,"w"::S,"iw"::S]$Lisp,_ + ["y"::S,"w"::S,"iw"::S,"fcnf"::S,"fcng"::S]$Lisp,_ + [["double"::S,"a"::S,"b"::S,"tol"::S,["y"::S,"n"::S,"mnp"::S]$Lisp_ + ,["c"::S,"n"::S,"n"::S]$Lisp,["d"::S,"n"::S,"n"::S]$Lisp,_ + ["gam"::S,"n"::S]$Lisp,["x"::S,"mnp"::S]$Lisp_ + ,["w"::S,"lw"::S]$Lisp,"fcnf"::S,"fcng"::S]$Lisp_ + ,["integer"::S,"n"::S,"mnp"::S,"lw"::S,"liw"::S_ + ,"np"::S,"ifail"::S,["iw"::S,"liw"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["y"::S,"c"::S,"d"::S,"gam"::S,"x"::S,"np"::S,"ifail"::S]$Lisp,_ + [([aArg::Any,bArg::Any,nArg::Any,tolArg::Any,mnpArg::Any,lwArg::Any,_ + liwArg::Any,npArg::Any,ifailArg::Any,cArg::Any,dArg::Any,_ + gamArg::Any,xArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d02kef(xpointArg:Matrix DoubleFloat,mArg:Integer,kArg:Integer,_ - tolArg:DoubleFloat,maxfunArg:Integer,matchArg:Integer,_ - elamArg:DoubleFloat,delamArg:DoubleFloat,hmaxArg:Matrix DoubleFloat,_ - maxitArg:Integer,ifailArg:Integer,coeffnArg:Union(fn:FileName,fp:Asp10(COEFFN)),_ - bdyvalArg:Union(fn:FileName,fp:Asp80(BDYVAL))): Result == - pushFortranOutputStack(coeffnFilename := aspFilename "coeffn")$FOP - if coeffnArg case fn - then outputAsFortran(coeffnArg.fn) - else outputAsFortran(coeffnArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(bdyvalFilename := aspFilename "bdyval")$FOP - if bdyvalArg case fn - then outputAsFortran(bdyvalArg.fn) - else outputAsFortran(bdyvalArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(monitFilename := aspFilename "monit")$FOP - outputAsFortran()$Asp12(MONIT) - popFortranOutputStack()$FOP - pushFortranOutputStack(reportFilename := aspFilename "report")$FOP - outputAsFortran()$Asp33(REPORT) - popFortranOutputStack()$FOP - [(invokeNagman([coeffnFilename,bdyvalFilename,monitFilename,reportFilename]$Lisp,_ - "d02kef",_ - ["m"::S,"k"::S,"tol"::S,"maxfun"::S,"match"::S_ - ,"elam"::S,"delam"::S,"maxit"::S,"ifail"::S,"coeffn"::S_ - ,"bdyval"::S,"monit"::S,"report"::S,"xpoint"::S,"hmax"::S]$Lisp,_ - ["coeffn"::S,"bdyval"::S,"monit"::S,"report"::S]$Lisp,_ - [["double"::S,["xpoint"::S,"m"::S]$Lisp,"tol"::S_ - ,"elam"::S,"delam"::S,["hmax"::S,2$Lisp,"m"::S]$Lisp,"coeffn"::S,"bdyval"::S,"monit"::S,"report"::S]$Lisp_ - ,["integer"::S,"m"::S,"k"::S,"maxfun"::S,"match"::S_ - ,"maxit"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["match"::S,"elam"::S,"delam"::S,"hmax"::S,"maxit"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,kArg::Any,tolArg::Any,maxfunArg::Any,matchArg::Any,elamArg::Any,delamArg::Any,maxitArg::Any,ifailArg::Any,xpointArg::Any,hmaxArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + tolArg:DoubleFloat,maxfunArg:Integer,matchArg:Integer,_ + elamArg:DoubleFloat,delamArg:DoubleFloat,hmaxArg:Matrix DoubleFloat,_ + maxitArg:Integer,ifailArg:Integer,_ + coeffnArg:Union(fn:FileName,fp:Asp10(COEFFN)),_ + bdyvalArg:Union(fn:FileName,fp:Asp80(BDYVAL))): Result == + pushFortranOutputStack(coeffnFilename := aspFilename "coeffn")$FOP + if coeffnArg case fn + then outputAsFortran(coeffnArg.fn) + else outputAsFortran(coeffnArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(bdyvalFilename := aspFilename "bdyval")$FOP + if bdyvalArg case fn + then outputAsFortran(bdyvalArg.fn) + else outputAsFortran(bdyvalArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(monitFilename := aspFilename "monit")$FOP + outputAsFortran()$Asp12(MONIT) + popFortranOutputStack()$FOP + pushFortranOutputStack(reportFilename := aspFilename "report")$FOP + outputAsFortran()$Asp33(REPORT) + popFortranOutputStack()$FOP + [(invokeNagman([coeffnFilename,bdyvalFilename,monitFilename,_ + reportFilename]$Lisp,_ + "d02kef",_ + ["m"::S,"k"::S,"tol"::S,"maxfun"::S,"match"::S_ + ,"elam"::S,"delam"::S,"maxit"::S,"ifail"::S,"coeffn"::S_ + ,"bdyval"::S,"monit"::S,"report"::S,"xpoint"::S,"hmax"::S]$Lisp,_ + ["coeffn"::S,"bdyval"::S,"monit"::S,"report"::S]$Lisp,_ + [["double"::S,["xpoint"::S,"m"::S]$Lisp,"tol"::S_ + ,"elam"::S,"delam"::S,["hmax"::S,2$Lisp,"m"::S]$Lisp,_ + "coeffn"::S,"bdyval"::S,"monit"::S,"report"::S]$Lisp_ + ,["integer"::S,"m"::S,"k"::S,"maxfun"::S,"match"::S_ + ,"maxit"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["match"::S,"elam"::S,"delam"::S,"hmax"::S,"maxit"::S,_ + "ifail"::S]$Lisp,_ + [([mArg::Any,kArg::Any,tolArg::Any,maxfunArg::Any,matchArg::Any,_ + elamArg::Any,delamArg::Any,maxitArg::Any,ifailArg::Any,_ + xpointArg::Any,hmaxArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d02kef(xpointArg:Matrix DoubleFloat,mArg:Integer,kArg:Integer,_ - tolArg:DoubleFloat,maxfunArg:Integer,matchArg:Integer,_ - elamArg:DoubleFloat,delamArg:DoubleFloat,hmaxArg:Matrix DoubleFloat,_ - maxitArg:Integer,ifailArg:Integer,coeffnArg:Union(fn:FileName,fp:Asp10(COEFFN)),_ - bdyvalArg:Union(fn:FileName,fp:Asp80(BDYVAL)),monitArg:FileName,reportArg:FileName): Result == - pushFortranOutputStack(coeffnFilename := aspFilename "coeffn")$FOP - if coeffnArg case fn - then outputAsFortran(coeffnArg.fn) - else outputAsFortran(coeffnArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(bdyvalFilename := aspFilename "bdyval")$FOP - if bdyvalArg case fn - then outputAsFortran(bdyvalArg.fn) - else outputAsFortran(bdyvalArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(monitFilename := aspFilename "monit")$FOP - outputAsFortran(monitArg) - popFortranOutputStack()$FOP - pushFortranOutputStack(reportFilename := aspFilename "report")$FOP - outputAsFortran(reportArg) - popFortranOutputStack()$FOP - [(invokeNagman([coeffnFilename,bdyvalFilename,monitFilename,reportFilename]$Lisp,_ - "d02kef",_ - ["m"::S,"k"::S,"tol"::S,"maxfun"::S,"match"::S_ - ,"elam"::S,"delam"::S,"maxit"::S,"ifail"::S,"coeffn"::S_ - ,"bdyval"::S,"monit"::S,"report"::S,"xpoint"::S,"hmax"::S]$Lisp,_ - ["coeffn"::S,"bdyval"::S,"monit"::S,"report"::S]$Lisp,_ - [["double"::S,["xpoint"::S,"m"::S]$Lisp,"tol"::S_ - ,"elam"::S,"delam"::S,["hmax"::S,2$Lisp,"m"::S]$Lisp,"coeffn"::S,"bdyval"::S,"monit"::S,"report"::S]$Lisp_ - ,["integer"::S,"m"::S,"k"::S,"maxfun"::S,"match"::S_ - ,"maxit"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["match"::S,"elam"::S,"delam"::S,"hmax"::S,"maxit"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,kArg::Any,tolArg::Any,maxfunArg::Any,matchArg::Any,elamArg::Any,delamArg::Any,maxitArg::Any,ifailArg::Any,xpointArg::Any,hmaxArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + tolArg:DoubleFloat,maxfunArg:Integer,matchArg:Integer,_ + elamArg:DoubleFloat,delamArg:DoubleFloat,hmaxArg:Matrix DoubleFloat,_ + maxitArg:Integer,ifailArg:Integer,_ + coeffnArg:Union(fn:FileName,fp:Asp10(COEFFN)),_ + bdyvalArg:Union(fn:FileName,fp:Asp80(BDYVAL)),_ + monitArg:FileName,reportArg:FileName): Result == + pushFortranOutputStack(coeffnFilename := aspFilename "coeffn")$FOP + if coeffnArg case fn + then outputAsFortran(coeffnArg.fn) + else outputAsFortran(coeffnArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(bdyvalFilename := aspFilename "bdyval")$FOP + if bdyvalArg case fn + then outputAsFortran(bdyvalArg.fn) + else outputAsFortran(bdyvalArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(monitFilename := aspFilename "monit")$FOP + outputAsFortran(monitArg) + popFortranOutputStack()$FOP + pushFortranOutputStack(reportFilename := aspFilename "report")$FOP + outputAsFortran(reportArg) + popFortranOutputStack()$FOP + [(invokeNagman([coeffnFilename,bdyvalFilename,monitFilename,_ + reportFilename]$Lisp,_ + "d02kef",_ + ["m"::S,"k"::S,"tol"::S,"maxfun"::S,"match"::S_ + ,"elam"::S,"delam"::S,"maxit"::S,"ifail"::S,"coeffn"::S_ + ,"bdyval"::S,"monit"::S,"report"::S,"xpoint"::S,"hmax"::S]$Lisp,_ + ["coeffn"::S,"bdyval"::S,"monit"::S,"report"::S]$Lisp,_ + [["double"::S,["xpoint"::S,"m"::S]$Lisp,"tol"::S_ + ,"elam"::S,"delam"::S,["hmax"::S,2$Lisp,"m"::S]$Lisp,_ + "coeffn"::S,"bdyval"::S,"monit"::S,"report"::S]$Lisp_ + ,["integer"::S,"m"::S,"k"::S,"maxfun"::S,"match"::S_ + ,"maxit"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["match"::S,"elam"::S,"delam"::S,"hmax"::S,"maxit"::S,_ + "ifail"::S]$Lisp,_ + [([mArg::Any,kArg::Any,tolArg::Any,maxfunArg::Any,_ + matchArg::Any,elamArg::Any,delamArg::Any,maxitArg::Any,_ + ifailArg::Any,xpointArg::Any,hmaxArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d02raf(nArg:Integer,mnpArg:Integer,numbegArg:Integer,_ - nummixArg:Integer,tolArg:DoubleFloat,initArg:Integer,_ - iyArg:Integer,ijacArg:Integer,lworkArg:Integer,_ - liworkArg:Integer,npArg:Integer,xArg:Matrix DoubleFloat,_ - yArg:Matrix DoubleFloat,delepsArg:DoubleFloat,ifailArg:Integer,_ - fcnArg:Union(fn:FileName,fp:Asp41(FCN,JACOBF,JACEPS)),gArg:Union(fn:FileName,fp:Asp42(G,JACOBG,JACGEP))): Result == - pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP - if fcnArg case fn - then outputAsFortran(fcnArg.fn) - else outputAsFortran(fcnArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(gFilename := aspFilename "g")$FOP - if gArg case fn - then outputAsFortran(gArg.fn) - else outputAsFortran(gArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([fcnFilename,gFilename]$Lisp,_ - "d02raf",_ - ["n"::S,"mnp"::S,"numbeg"::S,"nummix"::S,"tol"::S_ - ,"init"::S,"iy"::S,"ijac"::S,"lwork"::S,"liwork"::S_ - ,"np"::S,"deleps"::S,"ifail"::S,"fcn"::S,"g"::S_ - ,"abt"::S,"x"::S,"y"::S,"work"::S,"iwork"::S_ - ]$Lisp,_ - ["abt"::S,"work"::S,"iwork"::S,"fcn"::S,"g"::S]$Lisp,_ - [["double"::S,"tol"::S,["abt"::S,"n"::S]$Lisp_ - ,["x"::S,"mnp"::S]$Lisp,["y"::S,"iy"::S,"mnp"::S]$Lisp,"deleps"::S,["work"::S,"lwork"::S]$Lisp,"fcn"::S,"g"::S]$Lisp_ - ,["integer"::S,"n"::S,"mnp"::S,"numbeg"::S_ - ,"nummix"::S,"init"::S,"iy"::S,"ijac"::S,"lwork"::S,"liwork"::S,"np"::S,"ifail"::S,["iwork"::S,"liwork"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["abt"::S,"np"::S,"x"::S,"y"::S,"deleps"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,mnpArg::Any,numbegArg::Any,nummixArg::Any,tolArg::Any,initArg::Any,iyArg::Any,ijacArg::Any,lworkArg::Any,liworkArg::Any,npArg::Any,delepsArg::Any,ifailArg::Any,xArg::Any,yArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + nummixArg:Integer,tolArg:DoubleFloat,initArg:Integer,_ + iyArg:Integer,ijacArg:Integer,lworkArg:Integer,_ + liworkArg:Integer,npArg:Integer,xArg:Matrix DoubleFloat,_ + yArg:Matrix DoubleFloat,delepsArg:DoubleFloat,ifailArg:Integer,_ + fcnArg:Union(fn:FileName,fp:Asp41(FCN,JACOBF,JACEPS)),_ + gArg:Union(fn:FileName,fp:Asp42(G,JACOBG,JACGEP))): Result == + pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP + if fcnArg case fn + then outputAsFortran(fcnArg.fn) + else outputAsFortran(fcnArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(gFilename := aspFilename "g")$FOP + if gArg case fn + then outputAsFortran(gArg.fn) + else outputAsFortran(gArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([fcnFilename,gFilename]$Lisp,_ + "d02raf",_ + ["n"::S,"mnp"::S,"numbeg"::S,"nummix"::S,"tol"::S_ + ,"init"::S,"iy"::S,"ijac"::S,"lwork"::S,"liwork"::S_ + ,"np"::S,"deleps"::S,"ifail"::S,"fcn"::S,"g"::S_ + ,"abt"::S,"x"::S,"y"::S,"work"::S,"iwork"::S_ + ]$Lisp,_ + ["abt"::S,"work"::S,"iwork"::S,"fcn"::S,"g"::S]$Lisp,_ + [["double"::S,"tol"::S,["abt"::S,"n"::S]$Lisp_ + ,["x"::S,"mnp"::S]$Lisp,["y"::S,"iy"::S,"mnp"::S]$Lisp,_ + "deleps"::S,["work"::S,"lwork"::S]$Lisp,"fcn"::S,"g"::S]$Lisp_ + ,["integer"::S,"n"::S,"mnp"::S,"numbeg"::S_ + ,"nummix"::S,"init"::S,"iy"::S,"ijac"::S,"lwork"::S,"liwork"::S,_ + "np"::S,"ifail"::S,["iwork"::S,"liwork"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["abt"::S,"np"::S,"x"::S,"y"::S,"deleps"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,mnpArg::Any,numbegArg::Any,nummixArg::Any,tolArg::Any,_ + initArg::Any,iyArg::Any,ijacArg::Any,lworkArg::Any,liworkArg::Any,_ + npArg::Any,delepsArg::Any,ifailArg::Any,xArg::Any,yArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result @ <>= @@ -100261,14 +100868,15 @@ NagOrdinaryDifferentialEquationsPackage(): Exports == Implementation where ++ Description: ++ This package uses the NAG Library to solve partial ++ differential equations. -++ See \downlink{Manual Page}{manpageXXd03}. + NagPartialDifferentialEquationsPackage(): Exports == Implementation where S ==> Symbol FOP ==> FortranOutputStackPackage Exports ==> with d03edf : (Integer,Integer,Integer,Integer,_ - DoubleFloat,Integer,Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result + DoubleFloat,Integer,Matrix DoubleFloat,Matrix DoubleFloat,_ + Matrix DoubleFloat,Integer) -> Result ++ d03edf(ngx,ngy,lda,maxit,acc,iout,a,rhs,ub,ifail) ++ solves seven-diagonal systems of linear equations which ++ arise from the discretization of an elliptic partial differential @@ -100276,14 +100884,21 @@ NagPartialDifferentialEquationsPackage(): Exports == Implementation where ++ technique. ++ See \downlink{Manual Page}{manpageXXd03edf}. d03eef : (DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat,_ - Integer,Integer,Integer,String,Integer,Union(fn:FileName,fp:Asp73(PDEF)),Union(fn:FileName,fp:Asp74(BNDY))) -> Result + Integer,Integer,Integer,String,Integer,_ + Union(fn:FileName,fp:Asp73(PDEF)),_ + Union(fn:FileName,fp:Asp74(BNDY))) -> Result ++ d03eef(xmin,xmax,ymin,ymax,ngx,ngy,lda,scheme,ifail,pdef,bndy) ++ discretizes a second order elliptic partial differential ++ equation (PDE) on a rectangular region. ++ See \downlink{Manual Page}{manpageXXd03eef}. d03faf : (DoubleFloat,DoubleFloat,Integer,Integer,_ - Matrix DoubleFloat,Matrix DoubleFloat,DoubleFloat,DoubleFloat,Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,DoubleFloat,DoubleFloat,Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,DoubleFloat,Integer,Integer,Integer,ThreeDimensionalMatrix DoubleFloat,Integer) -> Result - ++ d03faf(xs,xf,l,lbdcnd,bdxs,bdxf,ys,yf,m,mbdcnd,bdys,bdyf,zs,zf,n,nbdcnd,bdzs,bdzf,lambda,ldimf,mdimf,lwrk,f,ifail) + Matrix DoubleFloat,Matrix DoubleFloat,DoubleFloat,DoubleFloat,_ + Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,DoubleFloat,_ + DoubleFloat,Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,_ + DoubleFloat,Integer,Integer,Integer,_ + ThreeDimensionalMatrix DoubleFloat,Integer) -> Result + ++ d03faf(xs,xf,l,lbdcnd,bdxs,bdxf,ys,yf,m,mbdcnd,bdys,bdyf,zs, + ++ zf,n,nbdcnd,bdzs,bdzf,lambda,ldimf,mdimf,lwrk,f,ifail) ++ solves the Helmholtz equation in Cartesian co-ordinates in ++ three dimensions using the standard seven-point finite difference ++ approximation. This routine is designed to be particularly @@ -100308,89 +100923,102 @@ NagPartialDifferentialEquationsPackage(): Exports == Implementation where import Union(fn:FileName,fp:Asp73(PDEF)) import Union(fn:FileName,fp:Asp74(BNDY)) - - - d03edf(ngxArg:Integer,ngyArg:Integer,ldaArg:Integer,_ - maxitArg:Integer,accArg:DoubleFloat,ioutArg:Integer,_ - aArg:Matrix DoubleFloat,rhsArg:Matrix DoubleFloat,ubArg:Matrix DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "d03edf",_ - ["ngx"::S,"ngy"::S,"lda"::S,"maxit"::S,"acc"::S_ - ,"iout"::S,"numit"::S,"ifail"::S,"us"::S,"u"::S,"a"::S,"rhs"::S,"ub"::S_ - ]$Lisp,_ - ["us"::S,"u"::S,"numit"::S]$Lisp,_ - [["double"::S,"acc"::S,["us"::S,"lda"::S]$Lisp_ - ,["u"::S,"lda"::S]$Lisp,["a"::S,"lda"::S,7$Lisp]$Lisp,["rhs"::S,"lda"::S]$Lisp,["ub"::S,["*"::S,"ngx"::S,"ngy"::S]$Lisp]$Lisp_ - ]$Lisp_ - ,["integer"::S,"ngx"::S,"ngy"::S,"lda"::S,"maxit"::S_ - ,"iout"::S,"numit"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["us"::S,"u"::S,"numit"::S,"a"::S,"rhs"::S,"ub"::S,"ifail"::S]$Lisp,_ - [([ngxArg::Any,ngyArg::Any,ldaArg::Any,maxitArg::Any,accArg::Any,ioutArg::Any,ifailArg::Any,aArg::Any,rhsArg::Any,ubArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + maxitArg:Integer,accArg:DoubleFloat,ioutArg:Integer,_ + aArg:Matrix DoubleFloat,rhsArg:Matrix DoubleFloat,_ + ubArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "d03edf",_ + ["ngx"::S,"ngy"::S,"lda"::S,"maxit"::S,"acc"::S,"iout"::S,"numit"::S,_ + "ifail"::S,"us"::S,"u"::S,"a"::S,"rhs"::S,"ub"::S_ + ]$Lisp,_ + ["us"::S,"u"::S,"numit"::S]$Lisp,_ + [["double"::S,"acc"::S,["us"::S,"lda"::S]$Lisp_ + ,["u"::S,"lda"::S]$Lisp,["a"::S,"lda"::S,7$Lisp]$Lisp,_ + ["rhs"::S,"lda"::S]$Lisp,_ + ["ub"::S,["*"::S,"ngx"::S,"ngy"::S]$Lisp]$Lisp]$Lisp_ + ,["integer"::S,"ngx"::S,"ngy"::S,"lda"::S,"maxit"::S_ + ,"iout"::S,"numit"::S,"ifail"::S]$Lisp]$Lisp,_ + ["us"::S,"u"::S,"numit"::S,"a"::S,"rhs"::S,"ub"::S,"ifail"::S]$Lisp,_ + [([ngxArg::Any,ngyArg::Any,ldaArg::Any,maxitArg::Any,accArg::Any,_ + ioutArg::Any,ifailArg::Any,aArg::Any,rhsArg::Any,ubArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d03eef(xminArg:DoubleFloat,xmaxArg:DoubleFloat,yminArg:DoubleFloat,_ - ymaxArg:DoubleFloat,ngxArg:Integer,ngyArg:Integer,_ - ldaArg:Integer,schemeArg:String,ifailArg:Integer,_ - pdefArg:Union(fn:FileName,fp:Asp73(PDEF)),bndyArg:Union(fn:FileName,fp:Asp74(BNDY))): Result == - pushFortranOutputStack(pdefFilename := aspFilename "pdef")$FOP - if pdefArg case fn - then outputAsFortran(pdefArg.fn) - else outputAsFortran(pdefArg.fp) - popFortranOutputStack()$FOP - pushFortranOutputStack(bndyFilename := aspFilename "bndy")$FOP - if bndyArg case fn - then outputAsFortran(bndyArg.fn) - else outputAsFortran(bndyArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([pdefFilename,bndyFilename]$Lisp,_ - "d03eef",_ - ["xmin"::S,"xmax"::S,"ymin"::S,"ymax"::S,"ngx"::S_ - ,"ngy"::S,"lda"::S,"scheme"::S,"ifail"::S,"pdef"::S_ - ,"bndy"::S,"a"::S,"rhs"::S]$Lisp,_ - ["a"::S,"rhs"::S,"pdef"::S,"bndy"::S]$Lisp,_ - [["double"::S,"xmin"::S,"xmax"::S,"ymin"::S_ - ,"ymax"::S,["a"::S,"lda"::S,7$Lisp]$Lisp,["rhs"::S,"lda"::S]$Lisp,"pdef"::S,"bndy"::S]$Lisp_ - ,["integer"::S,"ngx"::S,"ngy"::S,"lda"::S,"ifail"::S_ - ]$Lisp_ - ,["character"::S,"scheme"::S]$Lisp_ - ]$Lisp,_ - ["a"::S,"rhs"::S,"ifail"::S]$Lisp,_ - [([xminArg::Any,xmaxArg::Any,yminArg::Any,ymaxArg::Any,ngxArg::Any,ngyArg::Any,ldaArg::Any,schemeArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ymaxArg:DoubleFloat,ngxArg:Integer,ngyArg:Integer,_ + ldaArg:Integer,schemeArg:String,ifailArg:Integer,_ + pdefArg:Union(fn:FileName,fp:Asp73(PDEF)),bndyArg:Union(fn:FileName,_ + fp:Asp74(BNDY))): Result == + pushFortranOutputStack(pdefFilename := aspFilename "pdef")$FOP + if pdefArg case fn + then outputAsFortran(pdefArg.fn) + else outputAsFortran(pdefArg.fp) + popFortranOutputStack()$FOP + pushFortranOutputStack(bndyFilename := aspFilename "bndy")$FOP + if bndyArg case fn + then outputAsFortran(bndyArg.fn) + else outputAsFortran(bndyArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([pdefFilename,bndyFilename]$Lisp,_ + "d03eef",_ + ["xmin"::S,"xmax"::S,"ymin"::S,"ymax"::S,"ngx"::S_ + ,"ngy"::S,"lda"::S,"scheme"::S,"ifail"::S,"pdef"::S_ + ,"bndy"::S,"a"::S,"rhs"::S]$Lisp,_ + ["a"::S,"rhs"::S,"pdef"::S,"bndy"::S]$Lisp,_ + [["double"::S,"xmin"::S,"xmax"::S,"ymin"::S,"ymax"::S,_ + ["a"::S,"lda"::S,7$Lisp]$Lisp,_ + ["rhs"::S,"lda"::S]$Lisp,"pdef"::S,"bndy"::S]$Lisp_ + ,["integer"::S,"ngx"::S,"ngy"::S,"lda"::S,"ifail"::S]$Lisp_ + ,["character"::S,"scheme"::S]$Lisp]$Lisp,_ + ["a"::S,"rhs"::S,"ifail"::S]$Lisp,_ + [([xminArg::Any,xmaxArg::Any,yminArg::Any,ymaxArg::Any,ngxArg::Any,_ + ngyArg::Any,ldaArg::Any,schemeArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result d03faf(xsArg:DoubleFloat,xfArg:DoubleFloat,lArg:Integer,_ - lbdcndArg:Integer,bdxsArg:Matrix DoubleFloat,bdxfArg:Matrix DoubleFloat,_ - ysArg:DoubleFloat,yfArg:DoubleFloat,mArg:Integer,_ - mbdcndArg:Integer,bdysArg:Matrix DoubleFloat,bdyfArg:Matrix DoubleFloat,_ - zsArg:DoubleFloat,zfArg:DoubleFloat,nArg:Integer,_ - nbdcndArg:Integer,bdzsArg:Matrix DoubleFloat,bdzfArg:Matrix DoubleFloat,_ - lambdaArg:DoubleFloat,ldimfArg:Integer,mdimfArg:Integer,_ - lwrkArg:Integer,fArg:ThreeDimensionalMatrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "d03faf",_ - ["xs"::S,"xf"::S,"l"::S,"lbdcnd"::S,"ys"::S_ - ,"yf"::S,"m"::S,"mbdcnd"::S,"zs"::S,"zf"::S_ - ,"n"::S,"nbdcnd"::S,"lambda"::S,"ldimf"::S,"mdimf"::S_ - ,"lwrk"::S,"pertrb"::S,"ifail"::S,"bdxs"::S,"bdxf"::S,"bdys"::S,"bdyf"::S,"bdzs"::S_ - ,"bdzf"::S,"f"::S,"w"::S]$Lisp,_ - ["pertrb"::S,"w"::S]$Lisp,_ - [["double"::S,"xs"::S,"xf"::S,["bdxs"::S,"mdimf"::S,["+"::S,"n"::S,1$Lisp]$Lisp]$Lisp_ - ,["bdxf"::S,"mdimf"::S,["+"::S,"n"::S,1$Lisp]$Lisp]$Lisp,"ys"::S,"yf"::S,["bdys"::S,"ldimf"::S,["+"::S,"n"::S,1$Lisp]$Lisp]$Lisp_ - ,["bdyf"::S,"ldimf"::S,["+"::S,"n"::S,1$Lisp]$Lisp]$Lisp,"zs"::S_ - ,"zf"::S,["bdzs"::S,"ldimf"::S,["+"::S,"m"::S,1$Lisp]$Lisp]$Lisp,["bdzf"::S,"ldimf"::S,["+"::S,"m"::S,1$Lisp]$Lisp]$Lisp_ - ,"lambda"::S,"pertrb"::S,["f"::S,"ldimf"::S,"mdimf"::S,["+"::S,"n"::S,1$Lisp]$Lisp]$Lisp,["w"::S,"lwrk"::S]$Lisp]$Lisp_ - ,["integer"::S,"l"::S,"lbdcnd"::S,"m"::S,"mbdcnd"::S_ - ,"n"::S,"nbdcnd"::S,"ldimf"::S,"mdimf"::S,"lwrk"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["pertrb"::S,"f"::S,"ifail"::S]$Lisp,_ - [([xsArg::Any,xfArg::Any,lArg::Any,lbdcndArg::Any,ysArg::Any,yfArg::Any,mArg::Any,mbdcndArg::Any,zsArg::Any,zfArg::Any,nArg::Any,nbdcndArg::Any,lambdaArg::Any,ldimfArg::Any,mdimfArg::Any,lwrkArg::Any,ifailArg::Any,bdxsArg::Any,bdxfArg::Any,bdysArg::Any,bdyfArg::Any,bdzsArg::Any,bdzfArg::Any,fArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + lbdcndArg:Integer,bdxsArg:Matrix DoubleFloat,_ + bdxfArg:Matrix DoubleFloat,_ + ysArg:DoubleFloat,yfArg:DoubleFloat,mArg:Integer,_ + mbdcndArg:Integer,bdysArg:Matrix DoubleFloat,_ + bdyfArg:Matrix DoubleFloat,_ + zsArg:DoubleFloat,zfArg:DoubleFloat,nArg:Integer,_ + nbdcndArg:Integer,bdzsArg:Matrix DoubleFloat,_ + bdzfArg:Matrix DoubleFloat,_ + lambdaArg:DoubleFloat,ldimfArg:Integer,mdimfArg:Integer,_ + lwrkArg:Integer,fArg:ThreeDimensionalMatrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "d03faf",_ + ["xs"::S,"xf"::S,"l"::S,"lbdcnd"::S,"ys"::S_ + ,"yf"::S,"m"::S,"mbdcnd"::S,"zs"::S,"zf"::S_ + ,"n"::S,"nbdcnd"::S,"lambda"::S,"ldimf"::S,"mdimf"::S_ + ,"lwrk"::S,"pertrb"::S,"ifail"::S,"bdxs"::S,"bdxf"::S,"bdys"::S,_ + "bdyf"::S,"bdzs"::S_ + ,"bdzf"::S,"f"::S,"w"::S]$Lisp,_ + ["pertrb"::S,"w"::S]$Lisp,_ + [["double"::S,"xs"::S,"xf"::S,["bdxs"::S,"mdimf"::S,_ + ["+"::S,"n"::S,1$Lisp]$Lisp]$Lisp_ + ,["bdxf"::S,"mdimf"::S,["+"::S,"n"::S,1$Lisp]$Lisp]$Lisp,"ys"::S,_ + "yf"::S,["bdys"::S,"ldimf"::S,["+"::S,"n"::S,1$Lisp]$Lisp]$Lisp_ + ,["bdyf"::S,"ldimf"::S,["+"::S,"n"::S,1$Lisp]$Lisp]$Lisp,"zs"::S_ + ,"zf"::S,["bdzs"::S,"ldimf"::S,["+"::S,"m"::S,1$Lisp]$Lisp]$Lisp,_ + ["bdzf"::S,"ldimf"::S,["+"::S,"m"::S,1$Lisp]$Lisp]$Lisp_ + ,"lambda"::S,"pertrb"::S,["f"::S,"ldimf"::S,"mdimf"::S,_ + ["+"::S,"n"::S,1$Lisp]$Lisp]$Lisp,["w"::S,"lwrk"::S]$Lisp]$Lisp_ + ,["integer"::S,"l"::S,"lbdcnd"::S,"m"::S,"mbdcnd"::S_ + ,"n"::S,"nbdcnd"::S,"ldimf"::S,"mdimf"::S,"lwrk"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["pertrb"::S,"f"::S,"ifail"::S]$Lisp,_ + [([xsArg::Any,xfArg::Any,lArg::Any,lbdcndArg::Any,ysArg::Any,_ + yfArg::Any,mArg::Any,mbdcndArg::Any,zsArg::Any,zfArg::Any,_ + nArg::Any,nbdcndArg::Any,lambdaArg::Any,ldimfArg::Any,mdimfArg::Any,_ + lwrkArg::Any,ifailArg::Any,bdxsArg::Any,bdxfArg::Any,bdysArg::Any,_ + bdyfArg::Any,bdzsArg::Any,bdzfArg::Any,fArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result @ <>= @@ -101097,7 +101725,6 @@ NagPartialDifferentialEquationsPackage(): Exports == Implementation where ++ Description: ++ This package uses the NAG Library to compute the zeros of a ++ polynomial with real or complex coefficients. -++ See \downlink{Manual Page}{manpageXXc02}. NagPolynomialRootsPackage(): Exports == Implementation where S ==> Symbol @@ -101128,40 +101755,39 @@ NagPolynomialRootsPackage(): Exports == Implementation where import AnyFunctions1(Integer) import AnyFunctions1(Boolean) - c02aff(aArg:Matrix DoubleFloat,nArg:Integer,scaleArg:Boolean,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "c02aff",_ - ["n"::S,"scale"::S,"ifail"::S,"a"::S,"z"::S,"w"::S]$Lisp,_ - ["z"::S,"w"::S]$Lisp,_ - [["double"::S,["a"::S,2$Lisp,["+"::S,"n"::S,1$Lisp]$Lisp]$Lisp_ - ,["z"::S,2$Lisp,"n"::S]$Lisp,["w"::S,["*"::S,["+"::S,"n"::S,1$Lisp]$Lisp,4$Lisp]$Lisp]$Lisp]$Lisp_ - ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ - ,["logical"::S,"scale"::S]$Lisp_ - ]$Lisp,_ - ["z"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,scaleArg::Any,ifailArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result - - + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "c02aff",_ + ["n"::S,"scale"::S,"ifail"::S,"a"::S,"z"::S,"w"::S]$Lisp,_ + ["z"::S,"w"::S]$Lisp,_ + [["double"::S,["a"::S,2$Lisp,["+"::S,"n"::S,1$Lisp]$Lisp]$Lisp_ + ,["z"::S,2$Lisp,"n"::S]$Lisp,["w"::S,["*"::S,_ + ["+"::S,"n"::S,1$Lisp]$Lisp,4$Lisp]$Lisp]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ + ,["logical"::S,"scale"::S]$Lisp_ + ]$Lisp,_ + ["z"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,scaleArg::Any,ifailArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result c02agf(aArg:Matrix DoubleFloat,nArg:Integer,scaleArg:Boolean,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "c02agf",_ - ["n"::S,"scale"::S,"ifail"::S,"a"::S,"z"::S,"w"::S]$Lisp,_ - ["z"::S,"w"::S]$Lisp,_ - [["double"::S,["a"::S,["+"::S,"n"::S,1$Lisp]$Lisp]$Lisp_ - ,["z"::S,2$Lisp,"n"::S]$Lisp,["w"::S,["*"::S,["+"::S,"n"::S,1$Lisp]$Lisp,2$Lisp]$Lisp]$Lisp]$Lisp_ - ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ - ,["logical"::S,"scale"::S]$Lisp_ - ]$Lisp,_ - ["z"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,scaleArg::Any,ifailArg::Any,aArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "c02agf",_ + ["n"::S,"scale"::S,"ifail"::S,"a"::S,"z"::S,"w"::S]$Lisp,_ + ["z"::S,"w"::S]$Lisp,_ + [["double"::S,["a"::S,["+"::S,"n"::S,1$Lisp]$Lisp]$Lisp_ + ,["z"::S,2$Lisp,"n"::S]$Lisp,["w"::S,["*"::S,_ + ["+"::S,"n"::S,1$Lisp]$Lisp,2$Lisp]$Lisp]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ + ,["logical"::S,"scale"::S]$Lisp_ + ]$Lisp,_ + ["z"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,scaleArg::Any,ifailArg::Any,aArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result @ <>= @@ -102017,7 +102643,6 @@ NagPolynomialRootsPackage(): Exports == Implementation where ++ continuous real functions of one or more variables. (Complex ++ equations must be expressed in terms of the equivalent larger ++ system of real equations.) -++ See \downlink{Manual Page}{manpageXXc05}. NagRootFindingPackage(): Exports == Implementation where S ==> Symbol @@ -102025,21 +102650,21 @@ NagRootFindingPackage(): Exports == Implementation where Exports ==> with c05adf : (DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat,_ - Integer,Union(fn:FileName,fp:Asp1(F))) -> Result + Integer,Union(fn:FileName,fp:Asp1(F))) -> Result ++ c05adf(a,b,eps,eta,ifail,f) ++ locates a zero of a continuous function in a given ++ interval by a combination of the methods of linear interpolation, ++ extrapolation and bisection. ++ See \downlink{Manual Page}{manpageXXc05adf}. c05nbf : (Integer,Integer,Matrix DoubleFloat,DoubleFloat,_ - Integer,Union(fn:FileName,fp:Asp6(FCN))) -> Result + Integer,Union(fn:FileName,fp:Asp6(FCN))) -> Result ++ c05nbf(n,lwa,x,xtol,ifail,fcn) ++ is an easy-to-use routine to find a solution of a system ++ of nonlinear equations by a modification of the Powell hybrid ++ method. ++ See \downlink{Manual Page}{manpageXXc05nbf}. c05pbf : (Integer,Integer,Integer,Matrix DoubleFloat,_ - DoubleFloat,Integer,Union(fn:FileName,fp:Asp35(FCN))) -> Result + DoubleFloat,Integer,Union(fn:FileName,fp:Asp35(FCN))) -> Result ++ c05pbf(n,ldfjac,lwa,x,xtol,ifail,fcn) ++ is an easy-to-use routine to find a solution of a system ++ of nonlinear equations by a modification of the Powell hybrid @@ -102061,71 +102686,74 @@ NagRootFindingPackage(): Exports == Implementation where import AnyFunctions1(Matrix DoubleFloat) import AnyFunctions1(Integer) - c05adf(aArg:DoubleFloat,bArg:DoubleFloat,epsArg:DoubleFloat,_ - etaArg:DoubleFloat,ifailArg:Integer,fArg:Union(fn:FileName,fp:Asp1(F))): Result == - pushFortranOutputStack(fFilename := aspFilename "f")$FOP - if fArg case fn - then outputAsFortran(fArg.fn) - else outputAsFortran(fArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([fFilename]$Lisp,_ - "c05adf",_ - ["a"::S,"b"::S,"eps"::S,"eta"::S,"x"::S_ - ,"ifail"::S,"f"::S]$Lisp,_ - ["x"::S,"f"::S]$Lisp,_ - [["double"::S,"a"::S,"b"::S,"eps"::S,"eta"::S_ - ,"x"::S,"f"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["x"::S,"ifail"::S]$Lisp,_ - [([aArg::Any,bArg::Any,epsArg::Any,etaArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + etaArg:DoubleFloat,ifailArg:Integer,_ + fArg:Union(fn:FileName,fp:Asp1(F))): Result == + pushFortranOutputStack(fFilename := aspFilename "f")$FOP + if fArg case fn + then outputAsFortran(fArg.fn) + else outputAsFortran(fArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([fFilename]$Lisp,_ + "c05adf",_ + ["a"::S,"b"::S,"eps"::S,"eta"::S,"x"::S_ + ,"ifail"::S,"f"::S]$Lisp,_ + ["x"::S,"f"::S]$Lisp,_ + [["double"::S,"a"::S,"b"::S,"eps"::S,"eta"::S_ + ,"x"::S,"f"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["x"::S,"ifail"::S]$Lisp,_ + [([aArg::Any,bArg::Any,epsArg::Any,etaArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result c05nbf(nArg:Integer,lwaArg:Integer,xArg:Matrix DoubleFloat,_ - xtolArg:DoubleFloat,ifailArg:Integer,fcnArg:Union(fn:FileName,fp:Asp6(FCN))): Result == - pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP - if fcnArg case fn - then outputAsFortran(fcnArg.fn) - else outputAsFortran(fcnArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([fcnFilename]$Lisp,_ - "c05nbf",_ - ["n"::S,"lwa"::S,"xtol"::S,"ifail"::S,"fcn"::S_ - ,"fvec"::S,"x"::S,"wa"::S]$Lisp,_ - ["fvec"::S,"wa"::S,"fcn"::S]$Lisp,_ - [["double"::S,["fvec"::S,"n"::S]$Lisp,["x"::S,"n"::S]$Lisp_ - ,"xtol"::S,["wa"::S,"lwa"::S]$Lisp,"fcn"::S]$Lisp_ - ,["integer"::S,"n"::S,"lwa"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["fvec"::S,"x"::S,"xtol"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,lwaArg::Any,xtolArg::Any,ifailArg::Any,xArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + xtolArg:DoubleFloat,ifailArg:Integer,_ + fcnArg:Union(fn:FileName,fp:Asp6(FCN))): Result == + pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP + if fcnArg case fn + then outputAsFortran(fcnArg.fn) + else outputAsFortran(fcnArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([fcnFilename]$Lisp,_ + "c05nbf",_ + ["n"::S,"lwa"::S,"xtol"::S,"ifail"::S,"fcn"::S_ + ,"fvec"::S,"x"::S,"wa"::S]$Lisp,_ + ["fvec"::S,"wa"::S,"fcn"::S]$Lisp,_ + [["double"::S,["fvec"::S,"n"::S]$Lisp,["x"::S,"n"::S]$Lisp_ + ,"xtol"::S,["wa"::S,"lwa"::S]$Lisp,"fcn"::S]$Lisp_ + ,["integer"::S,"n"::S,"lwa"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["fvec"::S,"x"::S,"xtol"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,lwaArg::Any,xtolArg::Any,ifailArg::Any,xArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result c05pbf(nArg:Integer,ldfjacArg:Integer,lwaArg:Integer,_ - xArg:Matrix DoubleFloat,xtolArg:DoubleFloat,ifailArg:Integer,_ - fcnArg:Union(fn:FileName,fp:Asp35(FCN))): Result == - pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP - if fcnArg case fn - then outputAsFortran(fcnArg.fn) - else outputAsFortran(fcnArg.fp) - popFortranOutputStack()$FOP - [(invokeNagman([fcnFilename]$Lisp,_ - "c05pbf",_ - ["n"::S,"ldfjac"::S,"lwa"::S,"xtol"::S,"ifail"::S_ - ,"fcn"::S,"fvec"::S,"fjac"::S,"x"::S,"wa"::S]$Lisp,_ - ["fvec"::S,"fjac"::S,"wa"::S,"fcn"::S]$Lisp,_ - [["double"::S,["fvec"::S,"n"::S]$Lisp,["fjac"::S,"ldfjac"::S,"n"::S]$Lisp_ - ,["x"::S,"n"::S]$Lisp,"xtol"::S,["wa"::S,"lwa"::S]$Lisp,"fcn"::S]$Lisp_ - ,["integer"::S,"n"::S,"ldfjac"::S,"lwa"::S_ - ,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["fvec"::S,"fjac"::S,"x"::S,"xtol"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,ldfjacArg::Any,lwaArg::Any,xtolArg::Any,ifailArg::Any,xArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + xArg:Matrix DoubleFloat,xtolArg:DoubleFloat,ifailArg:Integer,_ + fcnArg:Union(fn:FileName,fp:Asp35(FCN))): Result == + pushFortranOutputStack(fcnFilename := aspFilename "fcn")$FOP + if fcnArg case fn + then outputAsFortran(fcnArg.fn) + else outputAsFortran(fcnArg.fp) + popFortranOutputStack()$FOP + [(invokeNagman([fcnFilename]$Lisp,_ + "c05pbf",_ + ["n"::S,"ldfjac"::S,"lwa"::S,"xtol"::S,"ifail"::S_ + ,"fcn"::S,"fvec"::S,"fjac"::S,"x"::S,"wa"::S]$Lisp,_ + ["fvec"::S,"fjac"::S,"wa"::S,"fcn"::S]$Lisp,_ + [["double"::S,["fvec"::S,"n"::S]$Lisp,_ + ["fjac"::S,"ldfjac"::S,"n"::S]$Lisp_ + ,["x"::S,"n"::S]$Lisp,"xtol"::S,["wa"::S,"lwa"::S]$Lisp,"fcn"::S]$Lisp_ + ,["integer"::S,"n"::S,"ldfjac"::S,"lwa"::S_ + ,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["fvec"::S,"fjac"::S,"x"::S,"xtol"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,ldfjacArg::Any,lwaArg::Any,xtolArg::Any,_ + ifailArg::Any,xArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result @ <>= @@ -104371,7 +104999,6 @@ NagRootFindingPackage(): Exports == Implementation where ++ This package uses the NAG Library to calculate the discrete Fourier ++ transform of a sequence of real or complex data values, and ++ applies it to calculate convolutions and correlations. -++ See \downlink{Manual Page}{manpageXXc06}. NagSeriesSummationPackage(): Exports == Implementation where S ==> Symbol @@ -104394,34 +105021,35 @@ NagSeriesSummationPackage(): Exports == Implementation where ++ n complex data values. (No extra workspace required.) ++ See \downlink{Manual Page}{manpageXXc06ecf}. c06ekf : (Integer,Integer,Matrix DoubleFloat,Matrix DoubleFloat,_ - Integer) -> Result + Integer) -> Result ++ c06ekf(job,n,x,y,ifail) ++ calculates the circular convolution of two ++ real vectors of period n. No extra workspace is required. ++ See \downlink{Manual Page}{manpageXXc06ekf}. c06fpf : (Integer,Integer,String,Matrix DoubleFloat,_ - Matrix DoubleFloat,Integer) -> Result + Matrix DoubleFloat,Integer) -> Result ++ c06fpf(m,n,init,x,trig,ifail) ++ computes the discrete Fourier transforms of m sequences, ++ each containing n real data values. This routine is designed to ++ be particularly efficient on vector processors. ++ See \downlink{Manual Page}{manpageXXc06fpf}. c06fqf : (Integer,Integer,String,Matrix DoubleFloat,_ - Matrix DoubleFloat,Integer) -> Result + Matrix DoubleFloat,Integer) -> Result ++ c06fqf(m,n,init,x,trig,ifail) ++ computes the discrete Fourier transforms of m Hermitian ++ sequences, each containing n complex data values. This routine is ++ designed to be particularly efficient on vector processors. ++ See \downlink{Manual Page}{manpageXXc06fqf}. c06frf : (Integer,Integer,String,Matrix DoubleFloat,_ - Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result + Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result ++ c06frf(m,n,init,x,y,trig,ifail) ++ computes the discrete Fourier transforms of m sequences, ++ each containing n complex data values. This routine is designed ++ to be particularly efficient on vector processors. ++ See \downlink{Manual Page}{manpageXXc06frf}. c06fuf : (Integer,Integer,String,Matrix DoubleFloat,_ - Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,Integer) -> Result + Matrix DoubleFloat,Matrix DoubleFloat,Matrix DoubleFloat,_ + Integer) -> Result ++ c06fuf(m,n,init,x,y,trigm,trign,ifail) ++ computes the two-dimensional discrete Fourier transform of ++ a bivariate sequence of complex data values. This routine is @@ -104462,188 +105090,202 @@ NagSeriesSummationPackage(): Exports == Implementation where import AnyFunctions1(String) import AnyFunctions1(Matrix DoubleFloat) - c06eaf(nArg:Integer,xArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "c06eaf",_ - ["n"::S,"ifail"::S,"x"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,["x"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["x"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,ifailArg::Any,xArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "c06eaf",_ + ["n"::S,"ifail"::S,"x"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,["x"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["x"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,ifailArg::Any,xArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result c06ebf(nArg:Integer,xArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "c06ebf",_ - ["n"::S,"ifail"::S,"x"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,["x"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["x"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,ifailArg::Any,xArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "c06ebf",_ + ["n"::S,"ifail"::S,"x"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,["x"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["x"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,ifailArg::Any,xArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result c06ecf(nArg:Integer,xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "c06ecf",_ - ["n"::S,"ifail"::S,"x"::S,"y"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,["x"::S,"n"::S]$Lisp,["y"::S,"n"::S]$Lisp_ - ]$Lisp_ - ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["x"::S,"y"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,ifailArg::Any,xArg::Any,yArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "c06ecf",_ + ["n"::S,"ifail"::S,"x"::S,"y"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,["x"::S,"n"::S]$Lisp,["y"::S,"n"::S]$Lisp_ + ]$Lisp_ + ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["x"::S,"y"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,ifailArg::Any,xArg::Any,yArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result c06ekf(jobArg:Integer,nArg:Integer,xArg:Matrix DoubleFloat,_ - yArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "c06ekf",_ - ["job"::S,"n"::S,"ifail"::S,"x"::S,"y"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,["x"::S,"n"::S]$Lisp,["y"::S,"n"::S]$Lisp_ - ]$Lisp_ - ,["integer"::S,"job"::S,"n"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["x"::S,"y"::S,"ifail"::S]$Lisp,_ - [([jobArg::Any,nArg::Any,ifailArg::Any,xArg::Any,yArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + yArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "c06ekf",_ + ["job"::S,"n"::S,"ifail"::S,"x"::S,"y"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,["x"::S,"n"::S]$Lisp,["y"::S,"n"::S]$Lisp_ + ]$Lisp_ + ,["integer"::S,"job"::S,"n"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["x"::S,"y"::S,"ifail"::S]$Lisp,_ + [([jobArg::Any,nArg::Any,ifailArg::Any,xArg::Any,yArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result c06fpf(mArg:Integer,nArg:Integer,initArg:String,_ - xArg:Matrix DoubleFloat,trigArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "c06fpf",_ - ["m"::S,"n"::S,"init"::S,"ifail"::S,"x"::S,"trig"::S,"work"::S]$Lisp,_ - ["work"::S]$Lisp,_ - [["double"::S,["x"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp_ - ,["trig"::S,["*"::S,2$Lisp,"n"::S]$Lisp]$Lisp,["work"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"ifail"::S]$Lisp_ - ,["character"::S,"init"::S]$Lisp_ - ]$Lisp,_ - ["x"::S,"trig"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,nArg::Any,initArg::Any,ifailArg::Any,xArg::Any,trigArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + xArg:Matrix DoubleFloat,trigArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "c06fpf",_ + ["m"::S,"n"::S,"init"::S,"ifail"::S,"x"::S,"trig"::S,"work"::S]$Lisp,_ + ["work"::S]$Lisp,_ + [["double"::S,["x"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp_ + ,["trig"::S,["*"::S,2$Lisp,"n"::S]$Lisp]$Lisp,_ + ["work"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"ifail"::S]$Lisp_ + ,["character"::S,"init"::S]$Lisp_ + ]$Lisp,_ + ["x"::S,"trig"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,nArg::Any,initArg::Any,ifailArg::Any,_ + xArg::Any,trigArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result c06fqf(mArg:Integer,nArg:Integer,initArg:String,_ - xArg:Matrix DoubleFloat,trigArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "c06fqf",_ - ["m"::S,"n"::S,"init"::S,"ifail"::S,"x"::S,"trig"::S,"work"::S]$Lisp,_ - ["work"::S]$Lisp,_ - [["double"::S,["x"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp_ - ,["trig"::S,["*"::S,2$Lisp,"n"::S]$Lisp]$Lisp,["work"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"ifail"::S]$Lisp_ - ,["character"::S,"init"::S]$Lisp_ - ]$Lisp,_ - ["x"::S,"trig"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,nArg::Any,initArg::Any,ifailArg::Any,xArg::Any,trigArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + xArg:Matrix DoubleFloat,trigArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "c06fqf",_ + ["m"::S,"n"::S,"init"::S,"ifail"::S,"x"::S,"trig"::S,"work"::S]$Lisp,_ + ["work"::S]$Lisp,_ + [["double"::S,["x"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp_ + ,["trig"::S,["*"::S,2$Lisp,"n"::S]$Lisp]$Lisp,_ + ["work"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"ifail"::S]$Lisp_ + ,["character"::S,"init"::S]$Lisp_ + ]$Lisp,_ + ["x"::S,"trig"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,nArg::Any,initArg::Any,ifailArg::Any,xArg::Any,_ + trigArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result c06frf(mArg:Integer,nArg:Integer,initArg:String,_ - xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,trigArg:Matrix DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "c06frf",_ - ["m"::S,"n"::S,"init"::S,"ifail"::S,"x"::S,"y"::S,"trig"::S,"work"::S]$Lisp,_ - ["work"::S]$Lisp,_ - [["double"::S,["x"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp_ - ,["y"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp,["trig"::S,["*"::S,2$Lisp,"n"::S]$Lisp]$Lisp,["work"::S,["*"::S,["*"::S,2$Lisp,"m"::S]$Lisp,"n"::S]$Lisp]$Lisp_ - ]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"ifail"::S]$Lisp_ - ,["character"::S,"init"::S]$Lisp_ - ]$Lisp,_ - ["x"::S,"y"::S,"trig"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,nArg::Any,initArg::Any,ifailArg::Any,xArg::Any,yArg::Any,trigArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,_ + trigArg:Matrix DoubleFloat,_ + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "c06frf",_ + ["m"::S,"n"::S,"init"::S,"ifail"::S,"x"::S,"y"::S,"trig"::S,_ + "work"::S]$Lisp,_ + ["work"::S]$Lisp,_ + [["double"::S,["x"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp_ + ,["y"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp,["trig"::S,_ + ["*"::S,2$Lisp,"n"::S]$Lisp]$Lisp,["work"::S,_ + ["*"::S,["*"::S,2$Lisp,"m"::S]$Lisp,"n"::S]$Lisp]$Lisp]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"ifail"::S]$Lisp_ + ,["character"::S,"init"::S]$Lisp]$Lisp,_ + ["x"::S,"y"::S,"trig"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,nArg::Any,initArg::Any,ifailArg::Any,_ + xArg::Any,yArg::Any,trigArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result c06fuf(mArg:Integer,nArg:Integer,initArg:String,_ - xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,trigmArg:Matrix DoubleFloat,_ - trignArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "c06fuf",_ - ["m"::S,"n"::S,"init"::S,"ifail"::S,"x"::S,"y"::S,"trigm"::S,"trign"::S,"work"::S_ - ]$Lisp,_ - ["work"::S]$Lisp,_ - [["double"::S,["x"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp_ - ,["y"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp,["trigm"::S,["*"::S,2$Lisp,"m"::S]$Lisp]$Lisp,["trign"::S,["*"::S,2$Lisp,"n"::S]$Lisp]$Lisp_ - ,["work"::S,["*"::S,["*"::S,2$Lisp,"m"::S]$Lisp,"n"::S]$Lisp]$Lisp]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"ifail"::S]$Lisp_ - ,["character"::S,"init"::S]$Lisp_ - ]$Lisp,_ - ["x"::S,"y"::S,"trigm"::S,"trign"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,nArg::Any,initArg::Any,ifailArg::Any,xArg::Any,yArg::Any,trigmArg::Any,trignArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + xArg:Matrix DoubleFloat,yArg:Matrix DoubleFloat,_ + trigmArg:Matrix DoubleFloat,_ + trignArg:Matrix DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "c06fuf",_ + ["m"::S,"n"::S,"init"::S,"ifail"::S,"x"::S,"y"::S,"trigm"::S,_ + "trign"::S,"work"::S]$Lisp,_ + ["work"::S]$Lisp,_ + [["double"::S,["x"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp_ + ,["y"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp,["trigm"::S,_ + ["*"::S,2$Lisp,"m"::S]$Lisp]$Lisp,["trign"::S,_ + ["*"::S,2$Lisp,"n"::S]$Lisp]$Lisp_ + ,["work"::S,["*"::S,["*"::S,2$Lisp,"m"::S]$Lisp,_ + "n"::S]$Lisp]$Lisp]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"ifail"::S]$Lisp_ + ,["character"::S,"init"::S]$Lisp_ + ]$Lisp,_ + ["x"::S,"y"::S,"trigm"::S,"trign"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,nArg::Any,initArg::Any,ifailArg::Any,xArg::Any,_ + yArg::Any,trigmArg::Any,trignArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result c06gbf(nArg:Integer,xArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "c06gbf",_ - ["n"::S,"ifail"::S,"x"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,["x"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["x"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,ifailArg::Any,xArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "c06gbf",_ + ["n"::S,"ifail"::S,"x"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,["x"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["x"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,ifailArg::Any,xArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result c06gcf(nArg:Integer,yArg:Matrix DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "c06gcf",_ - ["n"::S,"ifail"::S,"y"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,["y"::S,"n"::S]$Lisp]$Lisp_ - ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["y"::S,"ifail"::S]$Lisp,_ - [([nArg::Any,ifailArg::Any,yArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "c06gcf",_ + ["n"::S,"ifail"::S,"y"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,["y"::S,"n"::S]$Lisp]$Lisp_ + ,["integer"::S,"n"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["y"::S,"ifail"::S]$Lisp,_ + [([nArg::Any,ifailArg::Any,yArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result c06gqf(mArg:Integer,nArg:Integer,xArg:Matrix DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "c06gqf",_ - ["m"::S,"n"::S,"ifail"::S,"x"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,["x"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp_ - ]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["x"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,nArg::Any,ifailArg::Any,xArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "c06gqf",_ + ["m"::S,"n"::S,"ifail"::S,"x"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,["x"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp_ + ]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["x"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,nArg::Any,ifailArg::Any,xArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result c06gsf(mArg:Integer,nArg:Integer,xArg:Matrix DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "c06gsf",_ - ["m"::S,"n"::S,"ifail"::S,"x"::S,"u"::S,"v"::S]$Lisp,_ - ["u"::S,"v"::S]$Lisp,_ - [["double"::S,["x"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp_ - ,["u"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp,["v"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["u"::S,"v"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,nArg::Any,ifailArg::Any,xArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "c06gsf",_ + ["m"::S,"n"::S,"ifail"::S,"x"::S,"u"::S,"v"::S]$Lisp,_ + ["u"::S,"v"::S]$Lisp,_ + [["double"::S,["x"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp_ + ,["u"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp,_ + ["v"::S,["*"::S,"m"::S,"n"::S]$Lisp]$Lisp]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["u"::S,"v"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,nArg::Any,ifailArg::Any,xArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result @ <>= @@ -111989,7 +112631,7 @@ NagSeriesSummationPackage(): Exports == Implementation where ++ Description: ++ This package uses the NAG Library to compute some commonly ++ occurring physical and mathematical functions. -++ See \downlink{Manual Page}{manpageXXs}. + NagSpecialFunctionsPackage(): Exports == Implementation where S ==> Symbol FOP ==> FortranOutputStackPackage @@ -112014,8 +112656,8 @@ NagSpecialFunctionsPackage(): Exports == Implementation where ++ returns the value of the sine integral ++ See \downlink{Manual Page}{manpageXXs13adf}. s14aaf : (DoubleFloat,Integer) -> Result - ++ s14aaf(x,ifail) returns the value of the Gamma function (Gamma)(x), via - ++ the routine name. + ++ s14aaf(x,ifail) returns the value of the Gamma function (Gamma)(x), + ++ via the routine name. ++ See \downlink{Manual Page}{manpageXXs14aaf}. s14abf : (DoubleFloat,Integer) -> Result ++ s14abf(x,ifail) returns a value for the log, ln(Gamma(x)), via @@ -112081,7 +112723,7 @@ NagSpecialFunctionsPackage(): Exports == Implementation where ++ Bi(x), via the routine name. ++ See \downlink{Manual Page}{manpageXXs17akf}. s17dcf : (DoubleFloat,Complex DoubleFloat,Integer,String,_ - Integer) -> Result + Integer) -> Result ++ s17dcf(fnu,z,n,scale,ifail) ++ returns a sequence of values for the Bessel functions ++ Y (z) for complex z, non-negative (nu) and n=0,1,...,N-1, @@ -112089,7 +112731,7 @@ NagSpecialFunctionsPackage(): Exports == Implementation where ++ with an option for exponential scaling. ++ See \downlink{Manual Page}{manpageXXs17dcf}. s17def : (DoubleFloat,Complex DoubleFloat,Integer,String,_ - Integer) -> Result + Integer) -> Result ++ s17def(fnu,z,n,scale,ifail) ++ returns a sequence of values for the Bessel functions ++ J (z) for complex z, non-negative (nu) and n=0,1,...,N-1, @@ -112109,7 +112751,7 @@ NagSpecialFunctionsPackage(): Exports == Implementation where ++ scaling. ++ See \downlink{Manual Page}{manpageXXs17dhf}. s17dlf : (Integer,DoubleFloat,Complex DoubleFloat,Integer,_ - String,Integer) -> Result + String,Integer) -> Result ++ s17dlf(m,fnu,z,n,scale,ifail) ++ returns a sequence of values for the Hankel functions ++ (1) (2) @@ -112142,7 +112784,7 @@ NagSpecialFunctionsPackage(): Exports == Implementation where ++ 1 ++ See \downlink{Manual Page}{manpageXXs18aff}. s18dcf : (DoubleFloat,Complex DoubleFloat,Integer,String,_ - Integer) -> Result + Integer) -> Result ++ s18dcf(fnu,z,n,scale,ifail) ++ returns a sequence of values for the modified Bessel functions ++ K (z) for complex z, non-negative (nu) and @@ -112150,7 +112792,7 @@ NagSpecialFunctionsPackage(): Exports == Implementation where ++ n=0,1,...,N-1, with an option for exponential scaling. ++ See \downlink{Manual Page}{manpageXXs18dcf}. s18def : (DoubleFloat,Complex DoubleFloat,Integer,String,_ - Integer) -> Result + Integer) -> Result ++ s18def(fnu,z,n,scale,ifail) ++ returns a sequence of values for the modified Bessel functions ++ I (z) for complex z, non-negative (nu) and @@ -112204,7 +112846,7 @@ NagSpecialFunctionsPackage(): Exports == Implementation where ++ the second kind, via the routine name. ++ See \downlink{Manual Page}{manpageXXs21bcf}. s21bdf : (DoubleFloat,DoubleFloat,DoubleFloat,DoubleFloat,_ - Integer) -> Result + Integer) -> Result ++ s21bdf(x,y,z,r,ifail) ++ returns a value of the symmetrised elliptic integral of ++ the third kind, via the routine name. @@ -112224,539 +112866,540 @@ NagSpecialFunctionsPackage(): Exports == Implementation where import AnyFunctions1(DoubleFloat) import AnyFunctions1(String) - s01eaf(zArg:Complex DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s01eaf",_ - ["z"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["integer"::S,"ifail"::S]$Lisp_ - ,["double complex"::S,"s01eafResult"::S,"z"::S]$Lisp_ - ]$Lisp,_ - ["s01eafResult"::S,"ifail"::S]$Lisp,_ - [([zArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s01eaf",_ + ["z"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["integer"::S,"ifail"::S]$Lisp_ + ,["double complex"::S,"s01eafResult"::S,"z"::S]$Lisp_ + ]$Lisp,_ + ["s01eafResult"::S,"ifail"::S]$Lisp,_ + [([zArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s13aaf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s13aaf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s13aafResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s13aafResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s13aaf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s13aafResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s13aafResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s13acf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s13acf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s13acfResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s13acfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s13acf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s13acfResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s13acfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s13adf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s13adf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s13adfResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s13adfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s13adf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s13adfResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s13adfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s14aaf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s14aaf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s14aafResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s14aafResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s14aaf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s14aafResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s14aafResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s14abf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s14abf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s14abfResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s14abfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s14abf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s14abfResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s14abfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s14baf(aArg:DoubleFloat,xArg:DoubleFloat,tolArg:DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s14baf",_ - ["a"::S,"x"::S,"tol"::S,"p"::S,"q"::S_ - ,"ifail"::S]$Lisp,_ - ["p"::S,"q"::S]$Lisp,_ - [["double"::S,"a"::S,"x"::S,"tol"::S,"p"::S_ - ,"q"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["p"::S,"q"::S,"ifail"::S]$Lisp,_ - [([aArg::Any,xArg::Any,tolArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "s14baf",_ + ["a"::S,"x"::S,"tol"::S,"p"::S,"q"::S_ + ,"ifail"::S]$Lisp,_ + ["p"::S,"q"::S]$Lisp,_ + [["double"::S,"a"::S,"x"::S,"tol"::S,"p"::S_ + ,"q"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["p"::S,"q"::S,"ifail"::S]$Lisp,_ + [([aArg::Any,xArg::Any,tolArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s15adf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s15adf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s15adfResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s15adfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s15adf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s15adfResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s15adfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s15aef(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s15aef",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s15aefResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s15aefResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s15aef",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s15aefResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s15aefResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s17acf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s17acf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s17acfResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s17acfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s17acf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s17acfResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s17acfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s17adf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s17adf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s17adfResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s17adfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s17adf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s17adfResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s17adfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s17aef(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s17aef",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s17aefResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s17aefResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s17aef",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s17aefResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s17aefResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s17aff(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s17aff",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s17affResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s17affResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s17aff",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s17affResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s17affResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s17agf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s17agf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s17agfResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s17agfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s17agf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s17agfResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s17agfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s17ahf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s17ahf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s17ahfResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s17ahfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s17ahf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s17ahfResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s17ahfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s17ajf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s17ajf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s17ajfResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s17ajfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s17ajf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s17ajfResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s17ajfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s17akf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s17akf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s17akfResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s17akfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s17akf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s17akfResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s17akfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s17dcf(fnuArg:DoubleFloat,zArg:Complex DoubleFloat,nArg:Integer,_ - scaleArg:String,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s17dcf",_ - ["fnu"::S,"z"::S,"n"::S,"scale"::S,"nz"::S_ - ,"ifail"::S,"cy"::S,"cwrk"::S]$Lisp,_ - ["cy"::S,"nz"::S,"cwrk"::S]$Lisp,_ - [["double"::S,"fnu"::S]$Lisp_ - ,["integer"::S,"n"::S,"nz"::S,"ifail"::S]$Lisp_ - ,["character"::S,"scale"::S]$Lisp_ - ,["double complex"::S,"z"::S,["cy"::S,"n"::S]$Lisp,["cwrk"::S,"n"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["cy"::S,"nz"::S,"ifail"::S]$Lisp,_ - [([fnuArg::Any,zArg::Any,nArg::Any,scaleArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + scaleArg:String,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "s17dcf",_ + ["fnu"::S,"z"::S,"n"::S,"scale"::S,"nz"::S_ + ,"ifail"::S,"cy"::S,"cwrk"::S]$Lisp,_ + ["cy"::S,"nz"::S,"cwrk"::S]$Lisp,_ + [["double"::S,"fnu"::S]$Lisp_ + ,["integer"::S,"n"::S,"nz"::S,"ifail"::S]$Lisp_ + ,["character"::S,"scale"::S]$Lisp_ + ,["double complex"::S,"z"::S,["cy"::S,"n"::S]$Lisp,_ + ["cwrk"::S,"n"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["cy"::S,"nz"::S,"ifail"::S]$Lisp,_ + [([fnuArg::Any,zArg::Any,nArg::Any,scaleArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s17def(fnuArg:DoubleFloat,zArg:Complex DoubleFloat,nArg:Integer,_ - scaleArg:String,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s17def",_ - ["fnu"::S,"z"::S,"n"::S,"scale"::S,"nz"::S_ - ,"ifail"::S,"cy"::S]$Lisp,_ - ["cy"::S,"nz"::S]$Lisp,_ - [["double"::S,"fnu"::S]$Lisp_ - ,["integer"::S,"n"::S,"nz"::S,"ifail"::S]$Lisp_ - ,["character"::S,"scale"::S]$Lisp_ - ,["double complex"::S,"z"::S,["cy"::S,"n"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["cy"::S,"nz"::S,"ifail"::S]$Lisp,_ - [([fnuArg::Any,zArg::Any,nArg::Any,scaleArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + scaleArg:String,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "s17def",_ + ["fnu"::S,"z"::S,"n"::S,"scale"::S,"nz"::S_ + ,"ifail"::S,"cy"::S]$Lisp,_ + ["cy"::S,"nz"::S]$Lisp,_ + [["double"::S,"fnu"::S]$Lisp_ + ,["integer"::S,"n"::S,"nz"::S,"ifail"::S]$Lisp_ + ,["character"::S,"scale"::S]$Lisp_ + ,["double complex"::S,"z"::S,["cy"::S,"n"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["cy"::S,"nz"::S,"ifail"::S]$Lisp,_ + [([fnuArg::Any,zArg::Any,nArg::Any,scaleArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s17dgf(derivArg:String,zArg:Complex DoubleFloat,scaleArg:String,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s17dgf",_ - ["deriv"::S,"z"::S,"scale"::S,"ai"::S,"nz"::S_ - ,"ifail"::S]$Lisp,_ - ["ai"::S,"nz"::S]$Lisp,_ - [["integer"::S,"nz"::S,"ifail"::S]$Lisp_ - ,["character"::S,"deriv"::S,"scale"::S]$Lisp_ - ,["double complex"::S,"z"::S,"ai"::S]$Lisp_ - ]$Lisp,_ - ["ai"::S,"nz"::S,"ifail"::S]$Lisp,_ - [([derivArg::Any,zArg::Any,scaleArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "s17dgf",_ + ["deriv"::S,"z"::S,"scale"::S,"ai"::S,"nz"::S_ + ,"ifail"::S]$Lisp,_ + ["ai"::S,"nz"::S]$Lisp,_ + [["integer"::S,"nz"::S,"ifail"::S]$Lisp_ + ,["character"::S,"deriv"::S,"scale"::S]$Lisp_ + ,["double complex"::S,"z"::S,"ai"::S]$Lisp_ + ]$Lisp,_ + ["ai"::S,"nz"::S,"ifail"::S]$Lisp,_ + [([derivArg::Any,zArg::Any,scaleArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s17dhf(derivArg:String,zArg:Complex DoubleFloat,scaleArg:String,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s17dhf",_ - ["deriv"::S,"z"::S,"scale"::S,"bi"::S,"ifail"::S_ - ]$Lisp,_ - ["bi"::S]$Lisp,_ - [["integer"::S,"ifail"::S]$Lisp_ - ,["character"::S,"deriv"::S,"scale"::S]$Lisp_ - ,["double complex"::S,"z"::S,"bi"::S]$Lisp_ - ]$Lisp,_ - ["bi"::S,"ifail"::S]$Lisp,_ - [([derivArg::Any,zArg::Any,scaleArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "s17dhf",_ + ["deriv"::S,"z"::S,"scale"::S,"bi"::S,"ifail"::S_ + ]$Lisp,_ + ["bi"::S]$Lisp,_ + [["integer"::S,"ifail"::S]$Lisp_ + ,["character"::S,"deriv"::S,"scale"::S]$Lisp_ + ,["double complex"::S,"z"::S,"bi"::S]$Lisp_ + ]$Lisp,_ + ["bi"::S,"ifail"::S]$Lisp,_ + [([derivArg::Any,zArg::Any,scaleArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s17dlf(mArg:Integer,fnuArg:DoubleFloat,zArg:Complex DoubleFloat,_ - nArg:Integer,scaleArg:String,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s17dlf",_ - ["m"::S,"fnu"::S,"z"::S,"n"::S,"scale"::S_ - ,"nz"::S,"ifail"::S,"cy"::S]$Lisp,_ - ["cy"::S,"nz"::S]$Lisp,_ - [["double"::S,"fnu"::S]$Lisp_ - ,["integer"::S,"m"::S,"n"::S,"nz"::S,"ifail"::S_ - ]$Lisp_ - ,["character"::S,"scale"::S]$Lisp_ - ,["double complex"::S,"z"::S,["cy"::S,"n"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["cy"::S,"nz"::S,"ifail"::S]$Lisp,_ - [([mArg::Any,fnuArg::Any,zArg::Any,nArg::Any,scaleArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + nArg:Integer,scaleArg:String,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "s17dlf",_ + ["m"::S,"fnu"::S,"z"::S,"n"::S,"scale"::S_ + ,"nz"::S,"ifail"::S,"cy"::S]$Lisp,_ + ["cy"::S,"nz"::S]$Lisp,_ + [["double"::S,"fnu"::S]$Lisp_ + ,["integer"::S,"m"::S,"n"::S,"nz"::S,"ifail"::S_ + ]$Lisp_ + ,["character"::S,"scale"::S]$Lisp_ + ,["double complex"::S,"z"::S,["cy"::S,"n"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["cy"::S,"nz"::S,"ifail"::S]$Lisp,_ + [([mArg::Any,fnuArg::Any,zArg::Any,nArg::Any,scaleArg::Any,_ + ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s18acf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s18acf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s18acfResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s18acfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s18acf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s18acfResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s18acfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s18adf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s18adf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s18adfResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s18adfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s18adf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s18adfResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s18adfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s18aef(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s18aef",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s18aefResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s18aefResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s18aef",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s18aefResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s18aefResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s18aff(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s18aff",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s18affResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s18affResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s18aff",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s18affResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s18affResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s18dcf(fnuArg:DoubleFloat,zArg:Complex DoubleFloat,nArg:Integer,_ - scaleArg:String,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s18dcf",_ - ["fnu"::S,"z"::S,"n"::S,"scale"::S,"nz"::S_ - ,"ifail"::S,"cy"::S]$Lisp,_ - ["cy"::S,"nz"::S]$Lisp,_ - [["double"::S,"fnu"::S]$Lisp_ - ,["integer"::S,"n"::S,"nz"::S,"ifail"::S]$Lisp_ - ,["character"::S,"scale"::S]$Lisp_ - ,["double complex"::S,"z"::S,["cy"::S,"n"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["cy"::S,"nz"::S,"ifail"::S]$Lisp,_ - [([fnuArg::Any,zArg::Any,nArg::Any,scaleArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + scaleArg:String,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "s18dcf",_ + ["fnu"::S,"z"::S,"n"::S,"scale"::S,"nz"::S_ + ,"ifail"::S,"cy"::S]$Lisp,_ + ["cy"::S,"nz"::S]$Lisp,_ + [["double"::S,"fnu"::S]$Lisp_ + ,["integer"::S,"n"::S,"nz"::S,"ifail"::S]$Lisp_ + ,["character"::S,"scale"::S]$Lisp_ + ,["double complex"::S,"z"::S,["cy"::S,"n"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["cy"::S,"nz"::S,"ifail"::S]$Lisp,_ + [([fnuArg::Any,zArg::Any,nArg::Any,scaleArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s18def(fnuArg:DoubleFloat,zArg:Complex DoubleFloat,nArg:Integer,_ - scaleArg:String,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s18def",_ - ["fnu"::S,"z"::S,"n"::S,"scale"::S,"nz"::S_ - ,"ifail"::S,"cy"::S]$Lisp,_ - ["cy"::S,"nz"::S]$Lisp,_ - [["double"::S,"fnu"::S]$Lisp_ - ,["integer"::S,"n"::S,"nz"::S,"ifail"::S]$Lisp_ - ,["character"::S,"scale"::S]$Lisp_ - ,["double complex"::S,"z"::S,["cy"::S,"n"::S]$Lisp]$Lisp_ - ]$Lisp,_ - ["cy"::S,"nz"::S,"ifail"::S]$Lisp,_ - [([fnuArg::Any,zArg::Any,nArg::Any,scaleArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + scaleArg:String,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "s18def",_ + ["fnu"::S,"z"::S,"n"::S,"scale"::S,"nz"::S_ + ,"ifail"::S,"cy"::S]$Lisp,_ + ["cy"::S,"nz"::S]$Lisp,_ + [["double"::S,"fnu"::S]$Lisp_ + ,["integer"::S,"n"::S,"nz"::S,"ifail"::S]$Lisp_ + ,["character"::S,"scale"::S]$Lisp_ + ,["double complex"::S,"z"::S,["cy"::S,"n"::S]$Lisp]$Lisp_ + ]$Lisp,_ + ["cy"::S,"nz"::S,"ifail"::S]$Lisp,_ + [([fnuArg::Any,zArg::Any,nArg::Any,scaleArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s19aaf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s19aaf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s19aafResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s19aafResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s19aaf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s19aafResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s19aafResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s19abf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s19abf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s19abfResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s19abfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s19abf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s19abfResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s19abfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s19acf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s19acf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s19acfResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s19acfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s19acf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s19acfResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s19acfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s19adf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s19adf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s19adfResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s19adfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s19adf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s19adfResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s19adfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s20acf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s20acf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s20acfResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s20acfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s20acf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s20acfResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s20acfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s20adf(xArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s20adf",_ - ["x"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s20adfResult"::S,"x"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s20adfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s20adf",_ + ["x"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s20adfResult"::S,"x"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s20adfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s21baf(xArg:DoubleFloat,yArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s21baf",_ - ["x"::S,"y"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s21bafResult"::S,"x"::S,"y"::S_ - ]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s21bafResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,yArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + [(invokeNagman(NIL$Lisp,_ + "s21baf",_ + ["x"::S,"y"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s21bafResult"::S,"x"::S,"y"::S_ + ]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s21bafResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,yArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s21bbf(xArg:DoubleFloat,yArg:DoubleFloat,zArg:DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s21bbf",_ - ["x"::S,"y"::S,"z"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s21bbfResult"::S,"x"::S,"y"::S_ - ,"z"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s21bbfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,yArg::Any,zArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "s21bbf",_ + ["x"::S,"y"::S,"z"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s21bbfResult"::S,"x"::S,"y"::S_ + ,"z"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s21bbfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,yArg::Any,zArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s21bcf(xArg:DoubleFloat,yArg:DoubleFloat,zArg:DoubleFloat,_ - ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s21bcf",_ - ["x"::S,"y"::S,"z"::S,"ifail"::S]$Lisp,_ - []$Lisp,_ - [["double"::S,"s21bcfResult"::S,"x"::S,"y"::S_ - ,"z"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s21bcfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,yArg::Any,zArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "s21bcf",_ + ["x"::S,"y"::S,"z"::S,"ifail"::S]$Lisp,_ + []$Lisp,_ + [["double"::S,"s21bcfResult"::S,"x"::S,"y"::S_ + ,"z"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s21bcfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,yArg::Any,zArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result s21bdf(xArg:DoubleFloat,yArg:DoubleFloat,zArg:DoubleFloat,_ - rArg:DoubleFloat,ifailArg:Integer): Result == - [(invokeNagman(NIL$Lisp,_ - "s21bdf",_ - ["x"::S,"y"::S,"z"::S,"r"::S,"ifail"::S_ - ]$Lisp,_ - []$Lisp,_ - [["double"::S,"s21bdfResult"::S,"x"::S,"y"::S_ - ,"z"::S,"r"::S]$Lisp_ - ,["integer"::S,"ifail"::S]$Lisp_ - ]$Lisp,_ - ["s21bdfResult"::S,"ifail"::S]$Lisp,_ - [([xArg::Any,yArg::Any,zArg::Any,rArg::Any,ifailArg::Any ])_ - @List Any]$Lisp)$Lisp)_ - pretend List (Record(key:Symbol,entry:Any))]$Result + rArg:DoubleFloat,ifailArg:Integer): Result == + [(invokeNagman(NIL$Lisp,_ + "s21bdf",_ + ["x"::S,"y"::S,"z"::S,"r"::S,"ifail"::S_ + ]$Lisp,_ + []$Lisp,_ + [["double"::S,"s21bdfResult"::S,"x"::S,"y"::S_ + ,"z"::S,"r"::S]$Lisp_ + ,["integer"::S,"ifail"::S]$Lisp_ + ]$Lisp,_ + ["s21bdfResult"::S,"ifail"::S]$Lisp,_ + [([xArg::Any,yArg::Any,zArg::Any,rArg::Any,ifailArg::Any ])_ + @List Any]$Lisp)$Lisp)_ + pretend List (Record(key:Symbol,entry:Any))]$Result @ <>= @@ -112824,6 +113467,7 @@ NewSparseUnivariatePolynomialFunctions2(R:Ring, S:Ring): with ++ result is known to be in the original integral domain ++ The packages defined in this file provide fast fraction free rational ++ interpolation algorithms. (see FAMR2, FFFG, FFFGF, NEWTON) + NewtonInterpolation F: Exports == Implementation where F: IntegralDomain Exports == with @@ -112890,12 +113534,12 @@ NewtonInterpolation F: Exports == Implementation where ++ Examples: ++ References: ++ Description: -++ This package provides a division and related operations for -++ \spadtype{MonogenicLinearOperator}s over a \spadtype{Field}. -++ Since the multiplication is in general non-commutative, -++ these operations all have left- and right-hand versions. -++ This package provides the operations based on left-division. - -- [q,r] = leftDivide(a,b) means a=b*q+r +++ This package provides a division and related operations for +++ \spadtype{MonogenicLinearOperator}s over a \spadtype{Field}. +++ Since the multiplication is in general non-commutative, +++ these operations all have left- and right-hand versions. +++ This package provides the operations based on left-division.\br +++ \tab{5}[q,r] = leftDivide(a,b) means a=b*q+r NonCommutativeOperatorDivision(P, F): PDcat == PDdef where P: MonogenicLinearOperator(F) @@ -112941,7 +113585,7 @@ NonCommutativeOperatorDivision(P, F): PDcat == PDdef where iv:F := inv leadingCoefficient b while degree r >= degree b and r ^= 0 repeat h := monomial(iv*leadingCoefficient r, - (degree r - degree b)::NonNegativeInteger)$P + (degree r - degree b)::NonNegativeInteger)$P r := r - b*h q := q + h [q,r] @@ -112997,9 +113641,9 @@ NonCommutativeOperatorDivision(P, F): PDcat == PDdef where ++ AMS Classification: ++ Keywords: ++ Description: -++ \spadtype{NoneFunctions1} implements functions on \spadtype{None}. -++ It particular it includes a particulary dangerous coercion from -++ any other type to \spadtype{None}. +++ \spadtype{NoneFunctions1} implements functions on \spadtype{None}. +++ It particular it includes a particulary dangerous coercion from +++ any other type to \spadtype{None}. NoneFunctions1(S:Type): Exports == Implementation where Exports ==> with @@ -113030,10 +113674,12 @@ NoneFunctions1(S:Type): Exports == Implementation where ++ Author: Manuel Bronstein ++ Date Created: 2 September 1991 ++ Date Last Updated: 14 October 1994 -++ Description: NonLinearFirstOrderODESolver provides a function +++ Keywords: differential equation, ODE +++ Description: +++ NonLinearFirstOrderODESolver provides a function ++ for finding closed form first integrals of nonlinear ordinary ++ differential equations of order 1. -++ Keywords: differential equation, ODE + NonLinearFirstOrderODESolver(R, F): Exports == Implementation where R: Join(OrderedSet, EuclideanDomain, RetractableTo Integer, LinearlyExplicitRingOver Integer, CharacteristicZero) @@ -113320,10 +113966,7 @@ NonLinearSolvePackage(R:IntegralDomain): Exports == Implementation where ++ Also See: ++ AMS Classifications: ++ Keywords: -++ Description: -++ A package for computing normalized assocites of univariate polynomials -++ with coefficients in a tower of simple extensions of a field.\newline -++ References : +++ References: ++ [1] D. LAZARD "A new method for solving algebraic systems of ++ positive dimension" Discr. App. Math. 33:147-160,1991 ++ [2] M. MORENO MAZA and R. RIOBOO "Computations of gcd over @@ -113332,7 +113975,9 @@ NonLinearSolvePackage(R:IntegralDomain): Exports == Implementation where ++ [3] M. MORENO MAZA "Calculs de pgcd au-dessus des tours ++ d'extensions simples et resolution des systemes d'equations ++ algebriques" These, Universite P.etM. Curie, Paris, 1997. -++ Version: 1. +++ Description: +++ A package for computing normalized assocites of univariate polynomials +++ with coefficients in a tower of simple extensions of a field. NormalizationPackage(R,E,V,P,TS): Exports == Implementation where @@ -113582,7 +114227,8 @@ NormInMonogenicAlgebra(R, PolR, E, PolE): Exports == Implementation where <>= )abbrev package NORMRETR NormRetractPackage ++ Description: -++ This package \undocumented +++ This package has no description + NormRetractPackage(F, ExtF, SUEx, ExtP, n):C == T where F : FiniteFieldCategory ExtF : FiniteAlgebraicExtensionField(F) @@ -113595,11 +114241,11 @@ NormRetractPackage(F, ExtF, SUEx, ExtP, n):C == T where C ==> with normFactors : ExtP -> List ExtP - ++ normFactors(x) \undocumented + ++ normFactors(x) \undocumented retractIfCan : ExtP -> Union(P, "failed") - ++ retractIfCan(x) \undocumented + ++ retractIfCan(x) \undocumented Frobenius : ExtP -> ExtP - ++ Frobenius(x) \undocumented + ++ Frobenius(x) \undocumented T ==> add @@ -113660,6 +114306,7 @@ NormRetractPackage(F, ExtF, SUEx, ExtP, n):C == T where ++ process. Used by \spadtype{MultivariateLifting}. ++ This package will work for every euclidean domain R which has property ++ F, i.e. there exists a factor operation in \spad{R[x]}. + NPCoef(BP,E,OV,R,P) : C == T where OV : OrderedSet @@ -113681,9 +114328,9 @@ NPCoef(BP,E,OV,R,P) : C == T where C == with npcoef : (USP,List(BP),List(P)) -> DetCoef - ++ npcoef \undocumented + ++ npcoef \undocumented listexp : BP -> List(NNI) - ++ listexp \undocumented + ++ listexp \undocumented T == add ---- Local Functions ---- @@ -113840,10 +114487,11 @@ NPCoef(BP,E,OV,R,P) : C == T where ++ Examples: ++ References: ++ Description: -++ In this package F is a framed algebra over the integers (typically -++ \spad{F = Z[a]} for some algebraic integer a). The package provides -++ functions to compute the integral closure of Z in the quotient -++ quotient field of F. +++ In this package F is a framed algebra over the integers (typically +++ \spad{F = Z[a]} for some algebraic integer a). The package provides +++ functions to compute the integral closure of Z in the quotient +++ quotient field of F. + NumberFieldIntegralBasis(UP,F): Exports == Implementation where UP : UnivariatePolynomialCategory Integer F : FramedAlgebra(Integer,UP) @@ -114155,7 +114803,7 @@ NumberFormats(): NFexports == NFimplementation where ScanFloatIgnoreSpacesIfCan s == s := contract s - not check s => "failed" + not check s => "failed" sex := interpret(packageTran(ncParseFromString(s)$Lisp)$Lisp)$Lisp sCheck := car(car(sex)) if (sCheck=sexfloat) = true then @@ -114300,7 +114948,7 @@ NumberFormats(): NFexports == NFimplementation where ++ Examples: ++ References: ++ Description: -++ This package provides polynomials as functions on a ring. +++ This package provides polynomials as functions on a ring. NumberTheoreticPolynomialFunctions(R: CommutativeRing): Exports == Impl where NNI ==> NonNegativeInteger @@ -114388,7 +115036,8 @@ NumberTheoreticPolynomialFunctions(R: CommutativeRing): Exports == Impl where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: Numeric provides real and complex numerical evaluation +++ Description: +++ Numeric provides real and complex numerical evaluation ++ functions for various symbolic types. Numeric(S:ConvertibleTo Float): with @@ -114843,39 +115492,37 @@ Numeric(S:ConvertibleTo Float): with ++ References: ++ Description: ++ This package is a suite of functions for the numerical integration of an -++ ordinary differential equation of n variables: +++ ordinary differential equation of n variables:\br +++ \tab{5}dy/dx = f(y,x)\tab{5}y is an n-vector\br +++ All the routines are based on a 4-th order Runge-Kutta kernel. +++ These routines generally have as arguments:\br +++ n, the number of dependent variables;\br +++ x1, the initial point;\br +++ h, the step size;\br +++ y, a vector of initial conditions of length n\br +++ which upon exit contains the solution at \spad{x1 + h};\br ++ -++ \center{dy/dx = f(y,x)\space{5}y is an n-vector} -++ -++ \par All the routines are based on a 4-th order Runge-Kutta kernel. -++ These routines generally have as arguments: -++ n, the number of dependent variables; -++ x1, the initial point; -++ h, the step size; -++ y, a vector of initial conditions of length n which upon exit contains the solution at \spad{x1 + h}; ++ \spad{derivs}, a function which computes the right hand side of the -++ ordinary differential equation: \spad{derivs(dydx,y,x)} computes \spad{dydx}, -++ a vector which contains the derivative information. -++ -++ \par In order of increasing complexity:\begin{items} +++ ordinary differential equation: \spad{derivs(dydx,y,x)} computes +++ \spad{dydx}, a vector which contains the derivative information. ++ -++ \item \spad{rk4(y,n,x1,h,derivs)} advances the solution vector to -++ \spad{x1 + h} and return the values in y. +++ In order of increasing complexity:\br +++ \tab{5}\spad{rk4(y,n,x1,h,derivs)} advances the solution vector to\br +++ \tab{5}\spad{x1 + h} and return the values in y.\br ++ -++ \item \spad{rk4(y,n,x1,h,derivs,t1,t2,t3,t4)} is the same as -++ \spad{rk4(y,n,x1,h,derivs)} except that you must provide 4 scratch -++ arrays t1-t4 of size n. +++ \tab{5}\spad{rk4(y,n,x1,h,derivs,t1,t2,t3,t4)} is the same as\br +++ \tab{5}\spad{rk4(y,n,x1,h,derivs)} except that you must provide 4 scratch\br +++ \tab{5}arrays t1-t4 of size n.\br ++ -++ \item Starting with y at x1, \spad{rk4f(y,n,x1,x2,ns,derivs)} -++ uses \spad{ns} fixed -++ steps of a 4-th order Runge-Kutta integrator to advance the -++ solution vector to x2 and return the values in y. -++ Argument x2, is the final point, and -++ \spad{ns}, the number of steps to take. +++ \tab{5}Starting with y at x1, \spad{rk4f(y,n,x1,x2,ns,derivs)}\br +++ \tab{5}uses \spad{ns} fixed steps of a 4-th order Runge-Kutta\br +++ \tab{5}integrator to advance the solution vector to x2 and return\br +++ \tab{5}the values in y. Argument x2, is the final point, and\br +++ \tab{5}\spad{ns}, the number of steps to take. ++ -++ \item \spad{rk4qc(y,n,x1,step,eps,yscal,derivs)} takes a 5-th order -++ Runge-Kutta step with monitoring -++ of local truncation to ensure accuracy and adjust stepsize. +++ \spad{rk4qc(y,n,x1,step,eps,yscal,derivs)} takes a 5-th order +++ Runge-Kutta step with monitoring of local truncation to ensure +++ accuracy and adjust stepsize. ++ The function takes two half steps and one full step and scales ++ the difference in solutions at the final point. If the error is ++ within \spad{eps}, the step is taken and the result is returned. @@ -114884,19 +115531,20 @@ Numeric(S:ConvertibleTo Float): with ++ reached. Upon input, an trial step size must be given and upon ++ return, an estimate of the next step size to use is returned as ++ well as the step size which produced the desired accuracy. -++ The scaled error is computed as -++ \center{\spad{error = MAX(ABS((y2steps(i) - y1step(i))/yscal(i)))}} +++ The scaled error is computed as\br +++ \tab{5}\spad{error = MAX(ABS((y2steps(i) - y1step(i))/yscal(i)))}\br ++ and this is compared against \spad{eps}. If this is greater -++ than \spad{eps}, the step size is reduced accordingly to -++ \center{\spad{hnew = 0.9 * hdid * (error/eps)**(-1/4)}} +++ than \spad{eps}, the step size is reduced accordingly to\br +++ \tab{5}\spad{hnew = 0.9 * hdid * (error/eps)**(-1/4)}\br ++ If the error criterion is satisfied, then we check if the ++ step size was too fine and return a more efficient one. If -++ \spad{error > \spad{eps} * (6.0E-04)} then the next step size should be -++ \center{\spad{hnext = 0.9 * hdid * (error/\spad{eps})**(-1/5)}} +++ \spad{error > \spad{eps} * (6.0E-04)} then the next step size should be\br +++ \tab{5}\spad{hnext = 0.9 * hdid * (error/\spad{eps})**(-1/5)}\br ++ Otherwise \spad{hnext = 4.0 * hdid} is returned. ++ A more detailed discussion of this and related topics can be ++ found in the book "Numerical Recipies" by W.Press, B.P. Flannery, ++ S.A. Teukolsky, W.T. Vetterling published by Cambridge University Press. +++ ++ Argument \spad{step} is a record of 3 floating point ++ numbers \spad{(try , did , next)}, ++ \spad{eps} is the required accuracy, @@ -114906,26 +115554,27 @@ Numeric(S:ConvertibleTo Float): with ++ On output, \spad{step.did} contains the step size which achieved the ++ accuracy and \spad{step.next} is the next step size to use. ++ -++ \item \spad{rk4qc(y,n,x1,step,eps,yscal,derivs,t1,t2,t3,t4,t5,t6,t7)} is the +++ \spad{rk4qc(y,n,x1,step,eps,yscal,derivs,t1,t2,t3,t4,t5,t6,t7)} is the ++ same as \spad{rk4qc(y,n,x1,step,eps,yscal,derivs)} except that the user ++ must provide the 7 scratch arrays \spad{t1-t7} of size n. ++ -++ \item \spad{rk4a(y,n,x1,x2,eps,h,ns,derivs)} +++ \spad{rk4a(y,n,x1,x2,eps,h,ns,derivs)} ++ is a driver program which uses \spad{rk4qc} to integrate n ordinary ++ differential equations starting at x1 to x2, keeping the local ++ truncation error to within \spad{eps} by changing the local step size. -++ The scaling vector is defined as -++ \center{\spad{yscal(i) = abs(y(i)) + abs(h*dydx(i)) + tiny}} +++ The scaling vector is defined as\br +++ \tab{5}\spad{yscal(i) = abs(y(i)) + abs(h*dydx(i)) + tiny}\br ++ where \spad{y(i)} is the solution at location x, \spad{dydx} is the ++ ordinary differential equation's right hand side, h is the current ++ step size and \spad{tiny} is 10 times the ++ smallest positive number representable. +++ ++ The user must supply an estimate for a trial step size and ++ the maximum number of calls to \spad{rk4qc} to use. ++ Argument x2 is the final point, ++ \spad{eps} is local truncation, ++ \spad{ns} is the maximum number of call to \spad{rk4qc} to use. -++ \end{items} + NumericalOrdinaryDifferentialEquations(): Exports == Implementation where L ==> List V ==> Vector @@ -114943,7 +115592,7 @@ NumericalOrdinaryDifferentialEquations(): Exports == Implementation where rk4 : (V NF,I,NF,NF, (V NF,V NF,NF) -> VOID) -> VOID ++ rk4(y,n,x1,h,derivs) uses a 4-th order Runge-Kutta method ++ to numerically integrate the ordinary differential equation - ++ {\em dy/dx = f(y,x)} of n variables, where y is an n-vector. + ++ dy/dx = f(y,x) of n variables, where y is an n-vector. ++ Argument y is a vector of initial conditions of length n which upon exit ++ contains the solution at \spad{x1 + h}, n is the number of dependent ++ variables, x1 is the initial point, h is the step size, and @@ -114959,13 +115608,13 @@ NumericalOrdinaryDifferentialEquations(): Exports == Implementation where rk4a : (V NF,I,NF,NF,NF,NF,I,(V NF,V NF,NF) -> VOID ) -> VOID ++ rk4a(y,n,x1,x2,eps,h,ns,derivs) is a driver function for the ++ numerical integration of an ordinary differential equation - ++ {\em dy/dx = f(y,x)} of n variables, where y is an n-vector + ++ dy/dx = f(y,x) of n variables, where y is an n-vector ++ using a 4-th order Runge-Kutta method. ++ For details, see \con{NumericalOrdinaryDifferentialEquations}. rk4qc : (V NF,I,NF,RK4STEP,NF,V NF,(V NF,V NF,NF) -> VOID) -> VOID ++ rk4qc(y,n,x1,step,eps,yscal,derivs) is a subfunction for the ++ numerical integration of an ordinary differential equation - ++ {\em dy/dx = f(y,x)} of n variables, where y is an n-vector + ++ dy/dx = f(y,x) of n variables, where y is an n-vector ++ using a 4-th order Runge-Kutta method. ++ This function takes a 5-th order Runge-Kutta step with monitoring ++ of local truncation to ensure accuracy and adjust stepsize. @@ -114974,7 +115623,7 @@ NumericalOrdinaryDifferentialEquations(): Exports == Implementation where ,V NF,V NF,V NF,V NF,V NF,V NF,V NF) -> VOID ++ rk4qc(y,n,x1,step,eps,yscal,derivs,t1,t2,t3,t4,t5,t6,t7) is a ++ subfunction for the numerical integration of an ordinary differential - ++ equation {\em dy/dx = f(y,x)} of n variables, where y is an n-vector + ++ equation dy/dx = f(y,x) of n variables, where y is an n-vector ++ using a 4-th order Runge-Kutta method. ++ This function takes a 5-th order Runge-Kutta step with monitoring ++ of local truncation to ensure accuracy and adjust stepsize. @@ -114982,7 +115631,7 @@ NumericalOrdinaryDifferentialEquations(): Exports == Implementation where rk4f : (V NF,I,NF,NF,I,(V NF,V NF,NF) -> VOID ) -> VOID ++ rk4f(y,n,x1,x2,ns,derivs) uses a 4-th order Runge-Kutta method ++ to numerically integrate the ordinary differential equation - ++ {\em dy/dx = f(y,x)} of n variables, where y is an n-vector. + ++ dy/dx = f(y,x) of n variables, where y is an n-vector. ++ Starting with y at x1, this function uses \spad{ns} fixed ++ steps of a 4-th order Runge-Kutta integrator to advance the ++ solution vector to x2 and return the values in y. @@ -115227,40 +115876,40 @@ NumericalOrdinaryDifferentialEquations(): Exports == Implementation where ++ step size (for open and closed versions), fast convergence ++ can be obtained if the integrand is sufficiently smooth. ++ -++ Each routine returns a Record of type TrapAns, which contains\indent{3} -++ \newline value (\spadtype{Float}):\tab{20} estimate of the integral -++ \newline error (\spadtype{Float}):\tab{20} estimate of the error in the computation -++ \newline totalpts (\spadtype{Integer}):\tab{20} total number of function evaluations -++ \newline success (\spadtype{Boolean}):\tab{20} if the integral was computed within the user specified error criterion -++ \indent{0}\indent{0} +++ Each routine returns a Record of type TrapAns, which contains +++ value Float: estimate of the integral +++ error Float: estimate of the error in the computation +++ totalpts Integer: total number of function evaluations +++ success Boolean: if the integral was computed within the user +++ specified error criterion ++ To produce this estimate, each routine generates an internal -++ sequence of sub-estimates, denoted by {\em S(i)}, depending on the +++ sequence of sub-estimates, denoted by S(i), depending on the ++ routine, to which the various convergence criteria are applied. ++ The user must supply a relative accuracy, \spad{eps_r}, and an absolute -++ accuracy, \spad{eps_a}. Convergence is obtained when either -++ \center{\spad{ABS(S(i) - S(i-1)) < eps_r * ABS(S(i-1))}} -++ \center{or \spad{ABS(S(i) - S(i-1)) < eps_a}} +++ accuracy, \spad{eps_a}. Convergence is obtained when either\br +++ \tab{5}\spad{ABS(S(i) - S(i-1)) < eps_r * ABS(S(i-1))}\br +++ \tab{5}or \spad{ABS(S(i) - S(i-1)) < eps_a} ++ are true statements. ++ ++ The routines come in three families and three flavors: -++ \newline\tab{3} closed:\tab{20}romberg,\tab{30}simpson,\tab{42}trapezoidal -++ \newline\tab{3} open: \tab{20}rombergo,\tab{30}simpsono,\tab{42}trapezoidalo -++ \newline\tab{3} adaptive closed:\tab{20}aromberg,\tab{30}asimpson,\tab{42}atrapezoidal -++ \par -++ The {\em S(i)} for the trapezoidal family is the value of the +++ closed: romberg, simpson, trapezoidal +++ open: rombergo, simpsono, trapezoidalo +++ adaptive closed: aromberg, asimpson, atrapezoidal +++ +++ The S(i) for the trapezoidal family is the value of the ++ integral using an equally spaced absicca trapezoidal rule for ++ that level of refinement. -++ \par -++ The {\em S(i)} for the simpson family is the value of the integral +++ +++ The S(i) for the simpson family is the value of the integral ++ using an equally spaced absicca simpson rule for that level of ++ refinement. -++ \par -++ The {\em S(i)} for the romberg family is the estimate of the integral +++ +++ The S(i) for the romberg family is the estimate of the integral ++ using an equally spaced absicca romberg method. For -++ the \spad{i}-th level, this is an appropriate combination of all the +++ the i-th level, this is an appropriate combination of all the ++ previous trapezodial estimates so that the error term starts -++ with the \spad{2*(i+1)} power only. -++ \par +++ with the 2*(i+1) power only. +++ ++ The three families come in a closed version, where the formulas ++ include the endpoints, an open version where the formulas do not ++ include the endpoints and an adaptive version, where the user @@ -115269,22 +115918,24 @@ NumericalOrdinaryDifferentialEquations(): Exports == Implementation where ++ convergence parmeters for each subinterval. This is useful ++ where a large number of points are needed only in a small fraction ++ of the entire domain. -++ \par -++ Each routine takes as arguments: -++ \newline f\tab{10} integrand -++ \newline a\tab{10} starting point -++ \newline b\tab{10} ending point -++ \newline \spad{eps_r}\tab{10} relative error -++ \newline \spad{eps_a}\tab{10} absolute error -++ \newline \spad{nmin} \tab{10} refinement level when to start checking for convergence (> 1) -++ \newline \spad{nmax} \tab{10} maximum level of refinement -++ \par -++ The adaptive routines take as an additional parameter -++ \newline \spad{nint}\tab{10} the number of independent intervals to apply a closed -++ family integrator of the same name. -++ \par Notes: -++ \newline Closed family level i uses \spad{1 + 2**i} points. -++ \newline Open family level i uses \spad{1 + 3**i} points. +++ +++ Each routine takes as arguments:\br +++ f integrand\br +++ a starting point\br +++ b ending point\br +++ eps_r relative error\br +++ eps_a absolute error\br +++ nmin refinement level when to start checking for convergence (> 1)\br +++ nmax maximum level of refinement\br +++ +++ The adaptive routines take as an additional parameter, +++ nint, the number of independent intervals to apply a closed +++ family integrator of the same name. +++ +++ Notes:\br +++ Closed family level i uses \spad{1 + 2**i} points.\br +++ Open family level i uses \spad{1 + 3**i} points.\br + NumericalQuadrature(): Exports == Implementation where L ==> List V ==> Vector @@ -115787,8 +116438,8 @@ NumericalQuadrature(): Exports == Implementation where ++ This package computes explicitly eigenvalues and eigenvectors of ++ matrices with entries over the complex rational numbers. ++ The results are expressed either as complex floating numbers or as -++ complex rational numbers -++ depending on the type of the precision parameter. +++ complex rational numbers depending on the type of the precision parameter. + NumericComplexEigenPackage(Par) : C == T where Par : Join(Field,OrderedRing) -- Float or RationalNumber @@ -115878,8 +116529,9 @@ NumericComplexEigenPackage(Par) : C == T ++ AMS Classifications: 11J70 11A55 11K50 11Y65 30B70 40A15 ++ Keywords: continued fraction ++ References: -++ Description: \spadtype{NumericContinuedFraction} provides functions -++ for converting floating point numbers to continued fractions. +++ Description: +++ \spadtype{NumericContinuedFraction} provides functions +++ for converting floating point numbers to continued fractions. NumericContinuedFraction(F): Exports == Implementation where F : FloatingPointSystem @@ -115944,6 +116596,7 @@ NumericContinuedFraction(F): Exports == Implementation where ++ matrices with entries over the Rational Numbers. ++ The results are expressed as floating numbers or as rational numbers ++ depending on the type of the parameter Par. + NumericRealEigenPackage(Par) : C == T where Par : Join(Field,OrderedRing) -- Float or RationalNumber @@ -116027,7 +116680,9 @@ NumericRealEigenPackage(Par) : C == T ++ Date Last Updated: 5 June 1990 ++ Keywords: ++ Examples: +++ Description: ++ Package for constructing tubes around 3-dimensional parametric curves. + NumericTubePlot(Curve): Exports == Implementation where Curve : PlottableSpaceCurveCategory B ==> Boolean @@ -116143,7 +116798,6 @@ NumericTubePlot(Curve): Exports == Implementation where <>= )abbrev package OCTCT2 OctonionCategoryFunctions2 ---% OctonionCategoryFunctions2 ++ Author: Johannes Grabmeier ++ Date Created: 10 September 1990 ++ Date Last Updated: 10 September 1990 @@ -116154,10 +116808,9 @@ NumericTubePlot(Curve): Exports == Implementation where ++ Keywords: octonion, non-associative algebra, Cayley-Dixon ++ References: ++ Description: -++ OctonionCategoryFunctions2 implements functions between -++ two octonion domains defined over different rings. -++ The function map is used -++ to coerce between octonion types. +++ OctonionCategoryFunctions2 implements functions between +++ two octonion domains defined over different rings. +++ The function map is used to coerce between octonion types. OctonionCategoryFunctions2(OR,R,OS,S) : Exports == Implementation where @@ -116202,6 +116855,7 @@ OctonionCategoryFunctions2(OR,R,OS,S) : Exports == ++ \spadtype{ODEIntegration} provides an interface to the integrator. ++ This package is intended for use ++ by the differential equations solver but not at top-level. + ODEIntegration(R, F): Exports == Implementation where R: Join(OrderedSet, EuclideanDomain, RetractableTo Integer, LinearlyExplicitRingOver Integer, CharacteristicZero) @@ -116308,7 +116962,8 @@ ODEIntegration(R, F): Exports == Implementation where ++ Date Created: 20 March 1991 ++ Date Last Updated: 2 February 1994 ++ Description: -++ \spad{ODETools} provides tools for the linear ODE solver. +++ \spad{ODETools} provides tools for the linear ODE solver. + ODETools(F, LODO): Exports == Implementation where N ==> NonNegativeInteger L ==> List F @@ -116337,7 +116992,7 @@ ODETools(F, LODO): Exports == Implementation where ++ solution h of the equation \spad{op y = g} where \spad{[f1,...,fm]} ++ are linearly independent and \spad{op(fi)=0}. ++ The value "failed" is returned if no particular solution is found. - ++ Note: the method of variations of parameters is used. + ++ Note that the method of variations of parameters is used. Implementation ==> add import LinearSystemMatrixPackage(F, V, V, M) @@ -116389,8 +117044,10 @@ ODETools(F, LODO): Exports == Implementation where <>= )abbrev package ARRAY12 OneDimensionalArrayFunctions2 +++ Description: ++ This package provides tools for operating on one-dimensional arrays ++ with unary and binary functions involving different underlying types + OneDimensionalArrayFunctions2(A, B): Exports == Implementation where A, B: Type @@ -116416,7 +117073,7 @@ OneDimensionalArrayFunctions2(A, B): Exports == Implementation where ++ successive element of the ++ one-dimensional array \spad{a} and an accumulant initialized to r. ++ For example, \spad{reduce(_+$Integer,[1,2,3],0)} - ++ does \spad{3+(2+(1+0))}. Note: third argument r + ++ does \spad{3+(2+(1+0))}. Note that third argument r ++ may be regarded as the identity element for the function f. ++ ++X T1:=OneDimensionalArrayFunctions2(Integer,Integer) @@ -116453,11 +117110,12 @@ OneDimensionalArrayFunctions2(A, B): Exports == Implementation where <>= )abbrev package ONECOMP2 OnePointCompletionFunctions2 -++ Lifting of maps to one-point completions ++ Author: Manuel Bronstein -++ Description: Lifting of maps to one-point completions. ++ Date Created: 4 Oct 1989 ++ Date Last Updated: 4 Oct 1989 +++ Description: +++ Lifting of maps to one-point completions. + OnePointCompletionFunctions2(R, S): Exports == Implementation where R, S: SetCategory @@ -116516,7 +117174,8 @@ OnePointCompletionFunctions2(R, S): Exports == Implementation where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: \spadtype{OpenMathPackage} provides some simple utilities +++ Description: +++ \spadtype{OpenMathPackage} provides some simple utilities ++ to make reading OpenMath objects easier. OpenMathPackage(): with @@ -116611,7 +117270,8 @@ OpenMathPackage(): with ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: \spadtype{OpenMathServerPackage} provides the necessary +++ Description: +++ \spadtype{OpenMathServerPackage} provides the necessary ++ operations to run AXIOM as an OpenMath server, reading/writing objects ++ to/from a port. Please note the facilities available here are very basic. ++ The idea is that a user calls e.g. \axiom{Omserve(4000,60)} and then @@ -116681,7 +117341,9 @@ OpenMathServerPackage(): with <>= )abbrev package OPQUERY OperationsQuery +++ Description: ++ This package exports tools to create AXIOM Library information databases. + OperationsQuery(): Exports == Implementation where Exports == with getDatabase: String -> Database(IndexCard) @@ -116708,11 +117370,12 @@ OperationsQuery(): Exports == Implementation where <>= )abbrev package ORDCOMP2 OrderedCompletionFunctions2 -++ Lifting of maps to ordered completions ++ Author: Manuel Bronstein -++ Description: Lifting of maps to ordered completions. ++ Date Created: 4 Oct 1989 ++ Date Last Updated: 4 Oct 1989 +++ Description: +++ Lifting of maps to ordered completions. + OrderedCompletionFunctions2(R, S): Exports == Implementation where R, S: SetCategory @@ -116770,7 +117433,7 @@ OrderedCompletionFunctions2(R, S): Exports == Implementation where ++ Keywords: ++ References: ++ Description: -++ This package provides ordering functions on vectors which +++ This package provides ordering functions on vectors which ++ are suitable parameters for OrderedDirectProduct. OrderingFunctions(dim,S) : T == C where @@ -116864,7 +117527,7 @@ OrderingFunctions(dim,S) : T == C where ++ Examples: ++ References: ++ Description: -++ This package provides orthogonal polynomials as functions on a ring. +++ This package provides orthogonal polynomials as functions on a ring. OrthogonalPolynomialFunctions(R: CommutativeRing): Exports == Impl where NNI ==> NonNegativeInteger @@ -116985,7 +117648,8 @@ OrthogonalPolynomialFunctions(R: CommutativeRing): Exports == Impl where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: OutPackage allows pretty-printing from programs. +++ Description: +++ OutPackage allows pretty-printing from programs. OutputPackage: with output: String -> Void @@ -117003,7 +117667,7 @@ OutputPackage: with ++ outputList(l) displays the concatenated components of the ++ list l on the ``algebra output'' stream, as defined by ++ \spadsyscom{set output algebra}; quotes are stripped - ++ from strings. + ++ from strings. == add --ExpressionPackage() @@ -117022,8 +117686,8 @@ OutputPackage: with output(s,e) == output blankSeparate [s:E, e] outputList(l) == -- MGR - output hconcat - [if retractable?(x)$AnyFunctions1(String) then + output hconcat + [if retractable?(x)$AnyFunctions1(String) then message(retract(x)$AnyFunctions1(String))$OutputForm else x::OutputForm @@ -117048,8 +117712,6 @@ OutputPackage: with <>= )abbrev package PADEPAC PadeApproximantPackage -++ This package computes reliable Pad&ea. approximants using -++ a generalized Viskovatov continued fraction algorithm. ++ Authors: Trager,Burge, Hassner & Watt. ++ Date Created: April 1987 ++ Date Last Updated: 12 April 1990 @@ -117057,6 +117719,9 @@ OutputPackage: with ++ Examples: ++ References: ++ "Pade Approximants, Part I: Basic Theory", Baker & Graves-Morris. +++ Description: +++ This package computes reliable Pad&ea. approximants using +++ a generalized Viskovatov continued fraction algorithm. PadeApproximantPackage(R: Field, x:Symbol, pt:R): Exports == Implementation where PS ==> UnivariateTaylorSeries(R,x,pt) @@ -117115,8 +117780,6 @@ PadeApproximantPackage(R: Field, x:Symbol, pt:R): Exports == Implementation wher <>= )abbrev package PADE PadeApproximants -++ This package computes reliable Pad&ea. approximants using -++ a generalized Viskovatov continued fraction algorithm. ++ Authors: Burge, Hassner & Watt. ++ Date Created: April 1987 ++ Date Last Updated: 12 April 1990 @@ -117124,6 +117787,10 @@ PadeApproximantPackage(R: Field, x:Symbol, pt:R): Exports == Implementation wher ++ Examples: ++ References: ++ "Pade Approximants, Part I: Basic Theory", Baker & Graves-Morris. +++ Description: +++ This package computes reliable Pad&ea. approximants using +++ a generalized Viskovatov continued fraction algorithm. + PadeApproximants(R,PS,UP): Exports == Implementation where R: Field -- IntegralDomain PS: UnivariateTaylorSeriesCategory R @@ -117349,7 +118016,7 @@ PAdicWildFunctionFieldIntegralBasis(K,R,UP,F): Exports == Implementation where ++ \spad{(bij, i = 1..n, j = 1..n)}, then ++ \spad{wi = sum(bij * vj, j = 1..n)}. reducedDiscriminant: UP -> R - ++ reducedDiscriminant(up) \undocumented + ++ reducedDiscriminant(up) \undocumented Implementation ==> add import IntegralBasisTools(R, UP, F) @@ -117533,13 +118200,15 @@ PAdicWildFunctionFieldIntegralBasis(K,R,UP,F): Exports == Implementation where <>= )abbrev package YSTREAM ParadoxicalCombinatorsForStreams -++ Computation of fixed points of mappings on streams ++ Author: Burge, Watt (revised by Williamson) ++ Date Created: 1986 ++ Date Last Updated: 21 October 1989 ++ Keywords: stream, fixed point ++ Examples: ++ References: +++ Description: +++ Computation of fixed points of mappings on streams + ParadoxicalCombinatorsForStreams(A):Exports == Implementation where ++ This package implements fixed-point computations on streams. A : Type @@ -117612,30 +118281,6 @@ ParadoxicalCombinatorsForStreams(A):Exports == Implementation where \end{tabular} \begin{verbatim} -++ This package completely solves a parametric linear system of equations -++ by decomposing the set of all parametric values for which the linear -++ system is consistent into a union of quasi-algebraic sets (which need -++ not be irredundant, but most of the time is). Each quasi-algebraic -++ set is described by a list of polynomials that vanish on the set, and -++ a list of polynomials that vanish at no point of the set. -++ For each quasi-algebraic set, the solution of the linear system -++ is given, as a particular solution and a basis of the homogeneous -++ system. -++ The parametric linear system should be given in matrix form, with -++ a coefficient matrix and a right hand side vector. The entries -++ of the coefficient matrix and right hand side vector should be -++ polynomials in the parametric variables, over a Euclidean domain -++ of characteristic zero. -++ -++ If the system is homogeneous, the right hand side need not be given. -++ The right hand side can also be replaced by an indeterminate vector, -++ in which case, the conditions required for consistency will also be -++ given. -++ -++ The package has other facilities for saving results to external -++ files, as well as solving the system for a specified minimum rank. -++ Altogether there are 12 mode maps for psolve, as explained below. - -- modified to conform with new runtime system 06/04/90 -- updated with comments for MB, 02/16/94 -- also cleaned up some unnecessary arguments in regime routine @@ -117663,7 +118308,33 @@ ParadoxicalCombinatorsForStreams(A):Exports == Implementation where \end{verbatim} <>= )abbrev package PLEQN ParametricLinearEquations -++ Author: William Sit, spring 89 +++ Author: William Sit, spring 89 +++ Description: +++ This package completely solves a parametric linear system of equations +++ by decomposing the set of all parametric values for which the linear +++ system is consistent into a union of quasi-algebraic sets (which need +++ not be irredundant, but most of the time is). Each quasi-algebraic +++ set is described by a list of polynomials that vanish on the set, and +++ a list of polynomials that vanish at no point of the set. +++ For each quasi-algebraic set, the solution of the linear system +++ is given, as a particular solution and a basis of the homogeneous +++ system. +++ +++ The parametric linear system should be given in matrix form, with +++ a coefficient matrix and a right hand side vector. The entries +++ of the coefficient matrix and right hand side vector should be +++ polynomials in the parametric variables, over a Euclidean domain +++ of characteristic zero. +++ +++ If the system is homogeneous, the right hand side need not be given. +++ The right hand side can also be replaced by an indeterminate vector, +++ in which case, the conditions required for consistency will also be +++ given. +++ +++ The package has other facilities for saving results to external +++ files, as well as solving the system for a specified minimum rank. +++ Altogether there are 12 mode maps for psolve, as explained below. + ParametricLinearEquations(R,Var,Expon,GR): Declaration == Definition where @@ -118261,10 +118932,11 @@ ParametricLinearEquations(R,Var,Expon,GR): <>= )abbrev package PARPC2 ParametricPlaneCurveFunctions2 ++ Description: -++ This package \undocumented +++ This package has no description + ParametricPlaneCurveFunctions2(CF1: Type, CF2:Type): with map: (CF1 -> CF2, ParametricPlaneCurve(CF1)) -> ParametricPlaneCurve(CF2) - ++ map(f,x) \undocumented + ++ map(f,x) \undocumented == add map(f, c) == curve(f coordinate(c,1), f coordinate(c, 2)) @@ -118286,10 +118958,11 @@ ParametricPlaneCurveFunctions2(CF1: Type, CF2:Type): with <>= )abbrev package PARSC2 ParametricSpaceCurveFunctions2 ++ Description: -++ This package \undocumented +++ This package has no description + ParametricSpaceCurveFunctions2(CF1: Type, CF2:Type): with map: (CF1 -> CF2, ParametricSpaceCurve(CF1)) -> ParametricSpaceCurve(CF2) - ++ map(f,x) \undocumented + ++ map(f,x) \undocumented == add map(f, c) == curve(f coordinate(c,1), f coordinate(c,2), f coordinate(c,3)) @@ -118311,10 +118984,11 @@ ParametricSpaceCurveFunctions2(CF1: Type, CF2:Type): with <>= )abbrev package PARSU2 ParametricSurfaceFunctions2 ++ Description: -++ This package \undocumented +++ This package has no description + ParametricSurfaceFunctions2(CF1: Type, CF2:Type): with map: (CF1 -> CF2, ParametricSurface(CF1)) -> ParametricSurface(CF2) - ++ map(f,x) \undocumented + ++ map(f,x) \undocumented == add map(f, c) == surface(f coordinate(c,1), f coordinate(c,2), f coordinate(c,3)) @@ -118432,11 +119106,11 @@ o )show PartialFractionPackage ++ Keywords: partial fraction, factorization, euclidean domain ++ References: ++ Description: -++ The package \spadtype{PartialFractionPackage} gives an easier -++ to use interfact the domain \spadtype{PartialFraction}. -++ The user gives a fraction of polynomials, and a variable and -++ the package converts it to the proper datatype for the -++ \spadtype{PartialFraction} domain. +++ The package \spadtype{PartialFractionPackage} gives an easier +++ to use interfact the domain \spadtype{PartialFraction}. +++ The user gives a fraction of polynomials, and a variable and +++ the package converts it to the proper datatype for the +++ \spadtype{PartialFraction} domain. PartialFractionPackage(R): Cat == Capsule where -- R : UniqueFactorizationDomain -- not yet supported @@ -118512,10 +119186,11 @@ PartialFractionPackage(R): Cat == Capsule where ++ AMS Classifications: ++ Keywords: partition, permutation ++ References: -++ Description: PartitionsAndPermutations contains -++ functions for generating streams of integer partitions, -++ and streams of sequences of integers +++ Description: +++ PartitionsAndPermutations contains functions for generating streams of +++ integer partitions, and streams of sequences of integers ++ composed from a multi-set. + PartitionsAndPermutations: Exports == Implementation where I ==> Integer L ==> List @@ -118637,12 +119312,13 @@ PartitionsAndPermutations: Exports == Implementation where <>= )abbrev package PATTERN1 PatternFunctions1 -++ Utilities for handling patterns ++ Author: Manuel Bronstein ++ Date Created: 28 Nov 1989 ++ Date Last Updated: 5 Jul 1990 -++ Description: Tools for patterns; ++ Keywords: pattern, matching. +++ Description: +++ Utilities for handling patterns + PatternFunctions1(R:SetCategory, D:Type): with suchThat : (Pattern R, D -> Boolean) -> Pattern R ++ suchThat(p, f) makes a copy of p and adds the predicate @@ -118718,12 +119394,13 @@ PatternFunctions1(R:SetCategory, D:Type): with <>= )abbrev package PATTERN2 PatternFunctions2 -++ Lifting of maps to patterns ++ Author: Manuel Bronstein ++ Date Created: 28 Nov 1989 ++ Date Last Updated: 12 Jan 1990 -++ Description: Lifts maps to patterns; ++ Keywords: pattern, matching. +++ Description: +++ Lifts maps to patterns + PatternFunctions2(R:SetCategory, S:SetCategory): with map: (R -> S, Pattern R) -> Pattern S ++ map(f, p) applies f to all the leaves of p and @@ -118777,9 +119454,10 @@ PatternFunctions2(R:SetCategory, S:SetCategory): with ++ Author: Manuel Bronstein ++ Date Created: 3 Dec 1989 ++ Date Last Updated: 29 Jun 1990 -++ Description: -++ This package provides the top-level pattern macthing functions. ++ Keywords: pattern, matching. +++ Description: +++ This package provides the top-level pattern macthing functions. + PatternMatch(Base, Subject, Pat): Exports == Implementation where Base : SetCategory Subject: PatternMatchable Base @@ -118870,12 +119548,13 @@ PatternMatch(Base, Subject, Pat): Exports == Implementation where <>= )abbrev package PMASS PatternMatchAssertions -++ Assertions for pattern-matching ++ Author: Manuel Bronstein -++ Description: Attaching assertions to symbols for pattern matching. ++ Date Created: 21 Mar 1989 ++ Date Last Updated: 23 May 1990 ++ Keywords: pattern, matching. +++ Description: +++ Attaching assertions to symbols for pattern matching. + PatternMatchAssertions(): Exports == Implementation where FE ==> Expression Integer @@ -118921,13 +119600,13 @@ PatternMatchAssertions(): Exports == Implementation where <>= )abbrev package PMFS PatternMatchFunctionSpace -++ Pattern matching on function spaces ++ Author: Manuel Bronstein ++ Date Created: 15 Mar 1990 ++ Date Last Updated: 20 June 1991 -++ Description: -++ This package provides pattern matching functions on function spaces. ++ Keywords: pattern, matching, function, space. +++ Description: +++ This package provides pattern matching functions on function spaces. + PatternMatchFunctionSpace(S, R, F): Exports== Implementation where S: SetCategory R: Join(IntegralDomain, OrderedSet, PatternMatchable S) @@ -119009,13 +119688,13 @@ PatternMatchFunctionSpace(S, R, F): Exports== Implementation where <>= )abbrev package PMINS PatternMatchIntegerNumberSystem -++ Pattern matching on integer number systems ++ Author: Manuel Bronstein ++ Date Created: 29 Nov 1989 ++ Date Last Updated: 22 Mar 1990 -++ Description: -++ This package provides pattern matching functions on integers. ++ Keywords: pattern, matching, integer. +++ Description: +++ This package provides pattern matching functions on integers. + PatternMatchIntegerNumberSystem(I:IntegerNumberSystem): with patternMatch: (I, Pattern Integer, PatternMatchResult(Integer, I)) -> PatternMatchResult(Integer, I) @@ -119115,6 +119794,7 @@ PatternMatchIntegerNumberSystem(I:IntegerNumberSystem): with ++ \spadtype{PatternMatchIntegration} provides functions that use ++ the pattern matcher to find some indefinite and definite integrals ++ involving special functions and found in the litterature. + PatternMatchIntegration(R, F): Exports == Implementation where R : Join(OrderedSet, RetractableTo Integer, GcdDomain, LinearlyExplicitRingOver Integer) @@ -119445,13 +120125,13 @@ PatternMatchIntegration(R, F): Exports == Implementation where <>= )abbrev package PMKERNEL PatternMatchKernel -++ Pattern matching on kernels ++ Author: Manuel Bronstein ++ Date Created: 12 Jan 1990 ++ Date Last Updated: 4 May 1992 -++ Description: -++ This package provides pattern matching functions on kernels. ++ Keywords: pattern, matching, kernel. +++ Description: +++ This package provides pattern matching functions on kernels. + PatternMatchKernel(S, E): Exports == Implementation where S: SetCategory E: Join(OrderedSet, RetractableTo Kernel %, @@ -119555,13 +120235,13 @@ PatternMatchKernel(S, E): Exports == Implementation where <>= )abbrev package PMLSAGG PatternMatchListAggregate -++ Pattern matching for list aggregates ++ Author: Manuel Bronstein ++ Date Created: 4 Dec 1989 ++ Date Last Updated: 29 Jun 1990 -++ Description: -++ This package provides pattern matching functions on lists. ++ Keywords: pattern, matching, list. +++ Description: +++ This package provides pattern matching functions on lists. + PatternMatchListAggregate(S, R, L): Exports == Implementation where S: SetCategory R: PatternMatchable S @@ -119614,13 +120294,13 @@ PatternMatchListAggregate(S, R, L): Exports == Implementation where <>= )abbrev package PMPLCAT PatternMatchPolynomialCategory -++ Pattern matching on polynomial objects ++ Author: Manuel Bronstein ++ Date Created: 9 Jan 1990 ++ Date Last Updated: 20 June 1991 -++ Description: -++ This package provides pattern matching functions on polynomials. ++ Keywords: pattern, matching, polynomial. +++ Description: +++ This package provides pattern matching functions on polynomials. + PatternMatchPolynomialCategory(S,E,V,R,P):Exports== Implementation where S: SetCategory E: OrderedAbelianMonoidSup @@ -119714,14 +120394,13 @@ PatternMatchPolynomialCategory(S,E,V,R,P):Exports== Implementation where <>= )abbrev package PMDOWN PatternMatchPushDown -++ Pattern matching in towers ++ Author: Manuel Bronstein ++ Date Created: 1 Dec 1989 ++ Date Last Updated: 16 August 1995 -++ Description: -++ This packages provides tools for matching recursively -++ in type towers. ++ Keywords: pattern, matching, quotient, field. +++ Description: +++ This packages provides tools for matching recursively in type towers. + PatternMatchPushDown(S, A, B): Exports == Implementation where S: SetCategory A: PatternMatchable S @@ -119739,7 +120418,7 @@ PatternMatchPushDown(S, A, B): Exports == Implementation where ++ patternMatch(expr, pat, res) matches the pattern pat to the ++ expression expr; res contains the variables of pat which ++ are already matched and their matches. - ++ Note: this function handles type towers by changing the predicates + ++ Note that this function handles type towers by changing the predicates ++ and calling the matching function provided by \spad{A}. Implementation ==> add @@ -119828,13 +120507,13 @@ PatternMatchPushDown(S, A, B): Exports == Implementation where <>= )abbrev package PMQFCAT PatternMatchQuotientFieldCategory -++ Pattern matching on quotient objects ++ Author: Manuel Bronstein ++ Date Created: 1 Dec 1989 ++ Date Last Updated: 20 June 1991 -++ Description: -++ This package provides pattern matching functions on quotients. ++ Keywords: pattern, matching, quotient, field. +++ Description: +++ This package provides pattern matching functions on quotients. + PatternMatchQuotientFieldCategory(S,R,Q):Exports == Implementation where S: SetCategory R: Join(IntegralDomain, PatternMatchable S, ConvertibleTo Pattern S) @@ -119879,12 +120558,13 @@ PatternMatchQuotientFieldCategory(S,R,Q):Exports == Implementation where <>= )abbrev package PATRES2 PatternMatchResultFunctions2 -++ Lifts maps to pattern matching results ++ Author: Manuel Bronstein ++ Date Created: 1 Dec 1989 ++ Date Last Updated: 14 Dec 1989 -++ Description: Lifts maps to pattern matching results. ++ Keywords: pattern, matching. +++ Description: +++ Lifts maps to pattern matching results. + PatternMatchResultFunctions2(R, A, B): Exports == Implementation where R: SetCategory A: SetCategory @@ -119919,13 +120599,13 @@ PatternMatchResultFunctions2(R, A, B): Exports == Implementation where <>= )abbrev package PMSYM PatternMatchSymbol -++ Pattern matching on symbols ++ Author: Manuel Bronstein ++ Date Created: 9 Jan 1990 ++ Date Last Updated: 20 June 1991 -++ Description: -++ This package provides pattern matching functions on symbols. ++ Keywords: pattern, matching, symbol. +++ Description: +++ This package provides pattern matching functions on symbols. + PatternMatchSymbol(S:SetCategory): with patternMatch: (Symbol, Pattern S, PatternMatchResult(S, Symbol)) -> PatternMatchResult(S, Symbol) @@ -119963,13 +120643,13 @@ PatternMatchSymbol(S:SetCategory): with <>= )abbrev package PMTOOLS PatternMatchTools -++ Tools for the pattern matcher ++ Author: Manuel Bronstein ++ Date Created: 13 Mar 1990 ++ Date Last Updated: 4 February 1992 -++ Description: -++ This package provides tools for the pattern matcher. ++ Keywords: pattern, matching, tools. +++ Description: +++ This package provides tools for the pattern matcher. + PatternMatchTools(S, R, P): Exports == Implementation where S: SetCategory R: Join(Ring, OrderedSet) @@ -120234,8 +120914,9 @@ o )show Permanent ++ S.G.Williamson, Combinatorics for Computer Science, ++ Computer Science Press, 1985. ++ Description: -++ Permanent implements the functions {\em permanent}, the -++ permanent for square matrices. +++ Permanent implements the functions permanent, the +++ permanent for square matrices. + Permanent(n : PositiveInteger, R : Ring with commutative("*")): public == private where I ==> Integer @@ -120251,26 +120932,25 @@ Permanent(n : PositiveInteger, R : Ring with commutative("*")): permanent: SM -> R ++ permanent(x) computes the permanent of a square matrix x. - ++ The {\em permanent} is equivalent to + ++ The permanent is equivalent to ++ the \spadfun{determinant} except that coefficients have ++ no change of sign. This function ++ is much more difficult to compute than the - ++ {\em determinant}. The formula used is by H.J. Ryser, + ++ determinant. The formula used is by H.J. Ryser, ++ improved by [Nijenhuis and Wilf, Ch. 19]. - ++ Note: permanent(x) choose one of three algorithms, depending + ++ Note that permanent(x) choose one of three algorithms, depending ++ on the underlying ring R and on n, the number of rows (and - ++ columns) of x:\begin{items} - ++ \item 1. if 2 has an inverse in R we can use the algorithm of - ++ [Nijenhuis and Wilf, ch.19,p.158]; if 2 has no inverse, - ++ some modifications are necessary: - ++ \item 2. if {\em n > 6} and R is an integral domain with characteristic - ++ different from 2 (the algorithm works if and only 2 is not a - ++ zero-divisor of R and {\em characteristic()$R ^= 2}, - ++ but how to check that for any given R ?), - ++ the local function {\em permanent2} is called; - ++ \item 3. else, the local function {\em permanent3} is called - ++ (works for all commutative rings R). - ++ \end{items} + ++ columns) of x:\br + ++ if 2 has an inverse in R we can use the algorithm of + ++ [Nijenhuis and Wilf, ch.19,p.158]; if 2 has no inverse, + ++ some modifications are necessary:\br + ++ if n > 6 and R is an integral domain with characteristic + ++ different from 2 (the algorithm works if and only 2 is not a + ++ zero-divisor of R and characteristic()$R ^= 2, + ++ but how to check that for any given R ?), + ++ the local function permanent2 is called;\br + ++ else, the local function permanent3 is called + ++ (works for all commutative rings R). private ==> add @@ -120445,12 +121125,12 @@ Permanent(n : PositiveInteger, R : Ring with commutative("*")): ++ J. Conway, R. Curtis, S. Norton, R. Parker, R. Wilson: ++ Atlas of Finite Groups, Oxford, Clarendon Press, 1987 ++ Description: -++ PermutationGroupExamples provides permutation groups for -++ some classes of groups: symmetric, alternating, dihedral, cyclic, -++ direct products of cyclic, which are in fact the finite abelian groups -++ of symmetric groups called Young subgroups. -++ Furthermore, Rubik's group as permutation group of 48 integers and a list -++ of sporadic simple groups derived from the atlas of finite groups. +++ PermutationGroupExamples provides permutation groups for +++ some classes of groups: symmetric, alternating, dihedral, cyclic, +++ direct products of cyclic, which are in fact the finite abelian groups +++ of symmetric groups called Young subgroups. +++ Furthermore, Rubik's group as permutation group of 48 integers and a list +++ of sporadic simple groups derived from the atlas of finite groups. PermutationGroupExamples():public == private where @@ -120464,99 +121144,99 @@ PermutationGroupExamples():public == private where public ==> with symmetricGroup: PI -> PERMGRP I - ++ symmetricGroup(n) constructs the symmetric group {\em Sn} + ++ symmetricGroup(n) constructs the symmetric group Sn ++ acting on the integers 1,...,n, generators are the - ++ {\em n}-cycle {\em (1,...,n)} and the 2-cycle {\em (1,2)}. + ++ n-cycle (1,...,n) and the 2-cycle (1,2). symmetricGroup: L I -> PERMGRP I ++ symmetricGroup(li) constructs the symmetric group acting on - ++ the integers in the list {\em li}, generators are the - ++ cycle given by {\em li} and the 2-cycle {\em (li.1,li.2)}. - ++ Note: duplicates in the list will be removed. + ++ the integers in the list li, generators are the + ++ cycle given by li and the 2-cycle (li.1,li.2). + ++ Note that duplicates in the list will be removed. alternatingGroup: PI -> PERMGRP I - ++ alternatingGroup(n) constructs the alternating group {\em An} + ++ alternatingGroup(n) constructs the alternating group An ++ acting on the integers 1,...,n, generators are in general the - ++ {\em n-2}-cycle {\em (3,...,n)} and the 3-cycle {\em (1,2,3)} - ++ if 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)} + ++ n-2-cycle (3,...,n) and the 3-cycle (1,2,3) + ++ if n is odd and the product of the 2-cycle (1,2) with + ++ n-2-cycle (3,...,n) and the 3-cycle (1,2,3) ++ if n is even. alternatingGroup: L I -> PERMGRP I ++ alternatingGroup(li) constructs the alternating group acting - ++ on the integers in the list {\em li}, generators are in general the - ++ {\em n-2}-cycle {\em (li.3,...,li.n)} and the 3-cycle - ++ {\em (li.1,li.2,li.3)}, if n is odd and - ++ product of the 2-cycle {\em (li.1,li.2)} with - ++ {\em n-2}-cycle {\em (li.3,...,li.n)} and the 3-cycle - ++ {\em (li.1,li.2,li.3)}, if n is even. - ++ Note: duplicates in the list will be removed. + ++ on the integers in the list li, generators are in general the + ++ n-2-cycle (li.3,...,li.n) and the 3-cycle + ++ (li.1,li.2,li.3), if n is odd and + ++ product of the 2-cycle (li.1,li.2) with + ++ n-2-cycle (li.3,...,li.n) and the 3-cycle + ++ (li.1,li.2,li.3), if n is even. + ++ Note that duplicates in the list will be removed. abelianGroup: L PI -> PERMGRP I ++ abelianGroup([n1,...,nk]) constructs the abelian group that - ++ is the direct product of cyclic groups with order {\em ni}. + ++ is the direct product of cyclic groups with order ni. cyclicGroup: PI -> PERMGRP I ++ cyclicGroup(n) constructs the cyclic group of order n acting ++ on the integers 1,...,n. cyclicGroup: L I -> PERMGRP I ++ cyclicGroup([i1,...,ik]) constructs the cyclic group of - ++ order k acting on the integers {\em i1},...,{\em ik}. - ++ Note: duplicates in the list will be removed. + ++ order k acting on the integers i1,...,ik. + ++ Note that duplicates in the list will be removed. dihedralGroup: PI -> PERMGRP I ++ dihedralGroup(n) constructs the dihedral group of order 2n ++ acting on integers 1,...,N. dihedralGroup: L I -> PERMGRP I ++ dihedralGroup([i1,...,ik]) constructs the dihedral group of - ++ order 2k acting on the integers out of {\em i1},...,{\em ik}. - ++ Note: duplicates in the list will be removed. + ++ order 2k acting on the integers out of i1,...,ik. + ++ Note that duplicates in the list will be removed. mathieu11: L I -> PERMGRP I ++ mathieu11(li) constructs the mathieu group acting on the 11 - ++ integers given in the list {\em li}. - ++ Note: duplicates in the list will be removed. - ++ error, if {\em li} has less or more than 11 different entries. + ++ integers given in the list li. + ++ Note that duplicates in the list will be removed. + ++ error, if li has less or more than 11 different entries. mathieu11: () -> PERMGRP I ++ mathieu11 constructs the mathieu group acting on the ++ integers 1,...,11. mathieu12: L I -> PERMGRP I ++ mathieu12(li) constructs the mathieu group acting on the 12 - ++ integers given in the list {\em li}. - ++ Note: duplicates in the list will be removed - ++ Error: if {\em li} has less or more than 12 different entries. + ++ integers given in the list li. + ++ Note that duplicates in the list will be removed + ++ Error: if li has less or more than 12 different entries. mathieu12: () -> PERMGRP I ++ mathieu12 constructs the mathieu group acting on the ++ integers 1,...,12. mathieu22: L I -> PERMGRP I ++ mathieu22(li) constructs the mathieu group acting on the 22 - ++ integers given in the list {\em li}. - ++ Note: duplicates in the list will be removed. - ++ Error: if {\em li} has less or more than 22 different entries. + ++ integers given in the list li. + ++ Note that duplicates in the list will be removed. + ++ Error: if li has less or more than 22 different entries. mathieu22: () -> PERMGRP I ++ mathieu22 constructs the mathieu group acting on the ++ integers 1,...,22. mathieu23: L I -> PERMGRP I ++ mathieu23(li) constructs the mathieu group acting on the 23 - ++ integers given in the list {\em li}. - ++ Note: duplicates in the list will be removed. - ++ Error: if {\em li} has less or more than 23 different entries. + ++ integers given in the list li. + ++ Note that duplicates in the list will be removed. + ++ Error: if li has less or more than 23 different entries. mathieu23: () -> PERMGRP I ++ mathieu23 constructs the mathieu group acting on the ++ integers 1,...,23. mathieu24: L I -> PERMGRP I ++ mathieu24(li) constructs the mathieu group acting on the 24 - ++ integers given in the list {\em li}. - ++ Note: duplicates in the list will be removed. - ++ Error: if {\em li} has less or more than 24 different entries. + ++ integers given in the list li. + ++ Note that duplicates in the list will be removed. + ++ Error: if li has less or more than 24 different entries. mathieu24: () -> PERMGRP I ++ mathieu24 constructs the mathieu group acting on the ++ integers 1,...,24. janko2: L I -> PERMGRP I ++ janko2(li) constructs the janko group acting on the 100 - ++ integers given in the list {\em li}. - ++ Note: duplicates in the list will be removed. - ++ Error: if {\em li} has less or more than 100 different entries + ++ integers given in the list li. + ++ Note that duplicates in the list will be removed. + ++ Error: if li has less or more than 100 different entries janko2: () -> PERMGRP I ++ janko2 constructs the janko group acting on the ++ integers 1,...,100. rubiksGroup: () -> PERMGRP I ++ rubiksGroup constructs the permutation group representing - ++ Rubic's Cube acting on integers {\em 10*i+j} for - ++ {\em 1 <= i <= 6}, {\em 1 <= j <= 8}. + ++ Rubic's Cube acting on integers 10*i+j for + ++ 1 <= i <= 6, 1 <= j <= 8. ++ The faces of Rubik's Cube are labelled in the obvious way ++ Front, Right, Up, Down, Left, Back and numbered from 1 to 6 ++ in this given ordering, the pieces on each face @@ -120564,7 +121244,7 @@ PermutationGroupExamples():public == private where ++ from 1 to 8 starting with the piece in the upper left ++ corner. The moves of the cube are represented as permutations ++ on these pieces, represented as a two digit - ++ integer {\em ij} where i is the numer of theface (1 to 6) + ++ integer ij where i is the numer of theface (1 to 6) ++ and j is the number of the piece on this face. ++ The remaining ambiguities are resolved by looking ++ at the 6 generators, which represent a 90 degree turns of the @@ -120607,10 +121287,10 @@ PermutationGroupExamples():public == private where ++ \end{verbatim} youngGroup: L I -> PERMGRP I ++ youngGroup([n1,...,nk]) constructs the direct product of the - ++ symmetric groups {\em Sn1},...,{\em Snk}. + ++ symmetric groups Sn1,...,Snk. youngGroup: Partition -> PERMGRP I ++ youngGroup(lambda) constructs the direct product of the symmetric - ++ groups given by the parts of the partition {\em lambda}. + ++ groups given by the parts of the partition lambda. private ==> add @@ -120820,13 +121500,13 @@ PermutationGroupExamples():public == private where <>= )abbrev package PICOERCE PiCoercions -++ Coercions from %pi to symbolic or numeric domains ++ Author: Manuel Bronstein -++ Description: -++ Provides a coercion from the symbolic fractions in %pi with -++ integer coefficients to any Expression type. ++ Date Created: 21 Feb 1990 ++ Date Last Updated: 21 Feb 1990 +++ Description: +++ Provides a coercion from the symbolic fractions in %pi with +++ integer coefficients to any Expression type. + PiCoercions(R:Join(OrderedSet, IntegralDomain)): with coerce: Pi -> Expression R ++ coerce(f) returns f as an Expression(R). @@ -120871,14 +121551,16 @@ PiCoercions(R:Join(OrderedSet, IntegralDomain)): with ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: PlotFunctions1 provides facilities for plotting curves +++ Description: +++ PlotFunctions1 provides facilities for plotting curves ++ where functions SF -> SF are specified by giving an expression + PlotFunctions1(S:ConvertibleTo InputForm): with plot : (S, Symbol, Segment DoubleFloat) -> Plot ++ plot(fcn,x,seg) plots the graph of \spad{y = f(x)} on a interval plot : (S, S, Symbol, Segment DoubleFloat) -> Plot - ++ plot(f,g,t,seg) plots the graph of \spad{x = f(t)}, \spad{y = g(t)} as t - ++ ranges over an interval. + ++ plot(f,g,t,seg) plots the graph of \spad{x = f(t)}, \spad{y = g(t)} + ++ as t ranges over an interval. plotPolar : (S, Symbol, Segment DoubleFloat) -> Plot ++ plotPolar(f,theta,seg) plots the graph of \spad{r = f(theta)} as ++ theta ranges over an interval @@ -120920,6 +121602,7 @@ PlotFunctions1(S:ConvertibleTo InputForm): with ++ References: ++ Description: ++ This package exports plotting tools + PlotTools(): Exports == Implementation where L ==> List -- Pt ==> TwoDimensionalPoint @@ -120933,7 +121616,7 @@ PlotTools(): Exports == Implementation where Exports ==> with calcRanges: L L Pt -> L SEG SF - ++ calcRanges(l) \undocumented + ++ calcRanges(l) \undocumented Implementation ==> add import GraphicsDefaults @@ -121006,12 +121689,13 @@ PlotTools(): Exports == Implementation where <>= )abbrev package PTFUNC2 PointFunctions2 ++ Description: -++ This package \undocumented +++ This package has no description + PointFunctions2(R1:Ring,R2:Ring):Exports == Implementation where Exports == with map : ((R1->R2),Point(R1)) -> Point(R2) - ++ map(f,p) \undocumented + ++ map(f,p) \undocumented Implementation ==> add import Point(R1) @@ -121050,7 +121734,8 @@ PointFunctions2(R1:Ring,R2:Ring):Exports == Implementation where <>= )abbrev package PTPACK PointPackage ++ Description: -++ This package \undocumented +++ This package has no description + PointPackage(R:Ring):Exports == Implementation where POINT ==> Point(R) @@ -121155,15 +121840,14 @@ PointPackage(R:Ring):Exports == Implementation where <>= )abbrev package PFO PointsOfFiniteOrder -++ Finds the order of a divisor on a curve ++ Author: Manuel Bronstein ++ Date Created: 1988 ++ Date Last Updated: 22 July 1998 +++ Keywords: divisor, algebraic, curve. ++ Description: ++ This package provides function for testing whether a divisor on a ++ curve is a torsion divisor. -++ Keywords: divisor, algebraic, curve. -++ Examples: )r PFO INPUT + PointsOfFiniteOrder(R0, F, UP, UPUP, R): Exports == Implementation where R0 : Join(OrderedSet, IntegralDomain, RetractableTo Integer) F : FunctionSpace R0 @@ -121191,11 +121875,11 @@ PointsOfFiniteOrder(R0, F, UP, UPUP, R): Exports == Implementation where Exports ==> with order : FD -> Union(N, "failed") - ++ order(f) \undocumented + ++ order(f) \undocumented torsion? : FD -> Boolean - ++ torsion?(f) \undocumented + ++ torsion?(f) \undocumented torsionIfCan : FD -> Union(Record(order:N, function:R), "failed") - ++ torsionIfCan(f)\ undocumented + ++ torsionIfCan(f)\ undocumented Implementation ==> add import IntegerPrimesPackage(Z) @@ -121454,15 +122138,14 @@ PointsOfFiniteOrder(R0, F, UP, UPUP, R): Exports == Implementation where <>= )abbrev package PFOQ PointsOfFiniteOrderRational -++ Finds the order of a divisor on a rational curve ++ Author: Manuel Bronstein ++ Date Created: 25 Aug 1988 ++ Date Last Updated: 3 August 1993 +++ Keywords: divisor, algebraic, curve. ++ Description: ++ This package provides function for testing whether a divisor on a ++ curve is a torsion divisor. -++ Keywords: divisor, algebraic, curve. -++ Examples: )r PFOQ INPUT + PointsOfFiniteOrderRational(UP, UPUP, R): Exports == Implementation where UP : UnivariatePolynomialCategory Fraction Integer UPUP : UnivariatePolynomialCategory Fraction UP @@ -121476,11 +122159,11 @@ PointsOfFiniteOrderRational(UP, UPUP, R): Exports == Implementation where Exports ==> with order : FD -> Union(N, "failed") - ++ order(f) \undocumented + ++ order(f) \undocumented torsion? : FD -> Boolean - ++ torsion?(f) \undocumented + ++ torsion?(f) \undocumented torsionIfCan: FD -> Union(Record(order:N, function:R), "failed") - ++ torsionIfCan(f) \undocumented + ++ torsionIfCan(f) \undocumented Implementation ==> add import PointsOfFiniteOrderTools(UP, UPUP) @@ -121555,10 +122238,12 @@ PointsOfFiniteOrderRational(UP, UPUP, R): Exports == Implementation where <>= )abbrev package PFOTOOLS PointsOfFiniteOrderTools -++ Utilities for PFOQ and PFO ++ Author: Manuel Bronstein ++ Date Created: 25 Aug 1988 ++ Date Last Updated: 11 Jul 1990 +++ Description: +++ Utilities for PFOQ and PFO + PointsOfFiniteOrderTools(UP, UPUP): Exports == Implementation where UP : UnivariatePolynomialCategory Fraction Integer UPUP : UnivariatePolynomialCategory Fraction UP @@ -121572,15 +122257,15 @@ PointsOfFiniteOrderTools(UP, UPUP): Exports == Implementation where getGoodPrime : Z -> PI ++ getGoodPrime n returns the smallest prime not dividing n badNum : UP -> Record(den:Z, gcdnum:Z) - ++ badNum(p) \undocumented + ++ badNum(p) \undocumented badNum : UPUP -> Z - ++ badNum(u) \undocumented + ++ badNum(u) \undocumented mix : List Record(den:Z, gcdnum:Z) -> Z - ++ mix(l) \undocumented + ++ mix(l) \undocumented doubleDisc : UPUP -> Z - ++ doubleDisc(u) \undocumented + ++ doubleDisc(u) \undocumented polyred : UPUP -> UPUP - ++ polyred(u) \undocumented + ++ polyred(u) \undocumented Implementation ==> add import IntegerPrimesPackage(Z) @@ -121633,6 +122318,7 @@ PointsOfFiniteOrderTools(UP, UPUP): Exports == Implementation where ++ Author : P.Gianni, Summer '88 ++ Description: ++ Package with the conversion functions among different kind of polynomials + PolToPol(lv,R) : C == T where @@ -121729,7 +122415,7 @@ PolToPol(lv,R) : C == T ++ References: ++ Description: ++ Groebner functions for P F -++ This package is an interface package to the groebner basis +++ This package is an interface package to the groebner basis ++ package which allows you to compute groebner bases for polynomials ++ in either lexicographic ordering or total degree ordering refined ++ by reverse lex. The input is the ordinary polynomial type which @@ -121800,8 +122486,10 @@ PolyGroebner(F) : C == T )abbrev package PAN2EXPR PolynomialAN2Expression ++ Author: Barry Trager ++ Date Created: 8 Oct 1991 -++ Description: This package provides a coerce from polynomials over +++ Description: +++ This package provides a coerce from polynomials over ++ algebraic numbers to \spadtype{Expression AlgebraicNumber}. + PolynomialAN2Expression():Target == Implementation where EXPR ==> Expression(Integer) AN ==> AlgebraicNumber @@ -121911,14 +122599,15 @@ PolynomialCategoryLifting(E,Vars,R,P,S): Exports == Implementation where <>= )abbrev package POLYCATQ PolynomialCategoryQuotientFunctions -++ Manipulations on polynomial quotients ++ Author: Manuel Bronstein ++ Date Created: March 1988 ++ Date Last Updated: 9 July 1990 -++ Description: -++ This package transforms multivariate polynomials or fractions into -++ univariate polynomials or fractions, and back. ++ Keywords: polynomial, fraction, transformation +++ Description: +++ Manipulations on polynomial quotients +++ This package transforms multivariate polynomials or fractions into +++ univariate polynomials or fractions, and back. + PolynomialCategoryQuotientFunctions(E, V, R, P, F): Exports == Implementation where E: OrderedAbelianMonoidSup @@ -122055,15 +122744,16 @@ PolynomialCategoryQuotientFunctions(E, V, R, P, F): {\bf Exports:}\\ \cross{PCOMP}{compose} -Polynomial composition and decomposition functions\\ -If f = g o h then g = leftFactor(f, h) and h = rightFactor(f, g) <>= )abbrev package PCOMP PolynomialComposition +++ References: Kozen and Landau, Cornell University TR 86-773 ++ Description: -++ This package \undocumented +++ Polynomial composition and decomposition functions\br +++ If f = g o h then g=leftFactor(f,h) and h=rightFactor(f,g) + PolynomialComposition(UP: UnivariatePolynomialCategory(R), R: Ring): with compose: (UP, UP) -> UP - ++ compose(p,q) \undocumented + ++ compose(p,q) \undocumented == add compose(g, h) == r: UP := 0 @@ -122091,13 +122781,13 @@ PolynomialComposition(UP: UnivariatePolynomialCategory(R), R: Ring): with \cross{PDECOMP}{rightFactorCandidate} \end{tabular} -Polynomial composition and decomposition functions\\ -If f = g o h then g = leftFactor(f, h) and h = rightFactor(f, g) <>= )abbrev package PDECOMP PolynomialDecomposition +++ References: Kozen and Landau, Cornell University TR 86-773 ++ Description: -++ This package \undocumented --- Ref: Kozen and Landau, Cornell University TR 86-773 +++ Polynomial composition and decomposition functions\br +++ If f = g o h then g=leftFactor(f,h) and h=rightFactor(f,g) + PolynomialDecomposition(UP, F): PDcat == PDdef where F:Field UP:UnivariatePolynomialCategory F @@ -122106,13 +122796,13 @@ PolynomialDecomposition(UP, F): PDcat == PDdef where PDcat == with decompose: UP -> List UP - ++ decompose(up) \undocumented + ++ decompose(up) \undocumented decompose: (UP, NNI, NNI) -> Union(LR, "failed") - ++ decompose(up,m,n) \undocumented + ++ decompose(up,m,n) \undocumented leftFactor: (UP, UP) -> Union(UP, "failed") - ++ leftFactor(p,q) \undocumented + ++ leftFactor(p,q) \undocumented rightFactorCandidate: (UP, NNI) -> UP - ++ rightFactorCandidate(p,n) \undocumented + ++ rightFactorCandidate(p,n) \undocumented PDdef == add leftFactor(f, h) == g: UP := 0 @@ -122174,9 +122864,11 @@ PolynomialDecomposition(UP, F): PDcat == PDdef where <>= )abbrev package PFBR PolynomialFactorizationByRecursion -++ Description: PolynomialFactorizationByRecursion(R,E,VarSet,S) +++ Description: +++ PolynomialFactorizationByRecursion(R,E,VarSet,S) ++ is used for factorization of sparse univariate polynomials over ++ a domain S of multivariate polynomials over R. + PolynomialFactorizationByRecursion(R,E, VarSet:OrderedSet, S): public == private where R:PolynomialFactorizationExplicit @@ -122213,8 +122905,7 @@ PolynomialFactorizationByRecursion(R,E, VarSet:OrderedSet, S): public == ++ randomR produces a random element of R bivariateSLPEBR: (List SupS, SupS, VarSet) -> Union(List SupS,"failed") ++ bivariateSLPEBR(lp,p,v) implements - ++ the bivariate case of - ++ \spadfunFrom{solveLinearPolynomialEquationByRecursion}{PolynomialFactorizationByRecursionUnivariate}; + ++ the bivariate case of solveLinearPolynomialEquationByRecursion ++ its implementation depends on R factorSFBRlcUnit: (List VarSet, SupS) -> Factored SupS ++ factorSFBRlcUnit(p) returns the square free factorization of @@ -122488,11 +123179,13 @@ PolynomialFactorizationByRecursion(R,E, VarSet:OrderedSet, S): public == <>= )abbrev package PFBRU PolynomialFactorizationByRecursionUnivariate +++ Description: ++ PolynomialFactorizationByRecursionUnivariate ++ R is a \spadfun{PolynomialFactorizationExplicit} domain, ++ S is univariate polynomials over R ++ We are interested in handling SparseUnivariatePolynomials over ++ S, is a variable we shall call z + PolynomialFactorizationByRecursionUnivariate(R, S): public == private where R:PolynomialFactorizationExplicit S:UnivariatePolynomialCategory(R) @@ -122752,7 +123445,7 @@ PolynomialFactorizationByRecursionUnivariate(R, S): public == private where ++ Keywords: ++ References: ++ Description: -++ This package takes a mapping between coefficient rings, and lifts +++ This package takes a mapping between coefficient rings, and lifts ++ it to a mapping between polynomials over those rings. PolynomialFunctions2(R:Ring, S:Ring): with @@ -122797,17 +123490,16 @@ PolynomialFunctions2(R:Ring, S:Ring): with ++ Keywords: ++ References: ++ Description: -++ This package computes multivariate polynomial gcd's using +++ This package computes multivariate polynomial gcd's using ++ a hensel lifting strategy. The contraint on the coefficient ++ domain is imposed by the lifting strategy. It is assumed that ++ the coefficient domain has the property that almost all specializations ++ preserve the degree of the gcd. -I ==> Integer -NNI ==> NonNegativeInteger -PI ==> PositiveInteger - PolynomialGcdPackage(E,OV,R,P):C == T where + I ==> Integer + NNI ==> NonNegativeInteger + PI ==> PositiveInteger R : EuclideanDomain P : PolynomialCategory(R,E,OV) OV : OrderedSet @@ -123191,6 +123883,7 @@ PolynomialGcdPackage(E,OV,R,P):C == T where )abbrev package PINTERP PolynomialInterpolation ++ Description: ++ This package exports interpolation algorithms + PolynomialInterpolation(xx, F): Cat == Body where xx: Symbol F: Field @@ -123199,9 +123892,9 @@ PolynomialInterpolation(xx, F): Cat == Body where Cat ==> with interpolate: (UP(xx,F), List F, List F) -> UP(xx,F) - ++ interpolate(u,lf,lg) \undocumented + ++ interpolate(u,lf,lg) \undocumented interpolate: (List F, List F) -> SUP F - ++ interpolate(lf,lg) \undocumented + ++ interpolate(lf,lg) \undocumented Body ==> add PIA ==> PolynomialInterpolationAlgorithms @@ -123232,13 +123925,14 @@ PolynomialInterpolation(xx, F): Cat == Body where )abbrev package PINTERPA PolynomialInterpolationAlgorithms ++ Description: ++ This package exports interpolation algorithms + PolynomialInterpolationAlgorithms(F, P): Cat == Body where F: Field P: UnivariatePolynomialCategory(F) Cat ==> with LagrangeInterpolation: (List F, List F) -> P - ++ LagrangeInterpolation(l1,l2) \undocumented + ++ LagrangeInterpolation(l1,l2) \undocumented Body ==> add LagrangeInterpolation(lx, ly) == @@ -123294,6 +123988,7 @@ PolynomialInterpolationAlgorithms(F, P): Cat == Body where ++ Description: ++ This package provides various polynomial number theoretic functions ++ over the integers. + PolynomialNumberTheoryFunctions(): Exports == Implementation where I ==> Integer RN ==> Fraction I @@ -123308,42 +124003,46 @@ PolynomialNumberTheoryFunctions(): Exports == Implementation where ++ \spad{B(0,x) = 1} and initial condition comes from \spad{B(n) = B(n,0)}. chebyshevT: I -> SUP I ++ chebyshevT(n) returns the nth Chebyshev polynomial \spad{T[n](x)}. - ++ Note: Chebyshev polynomials of the first kind, denoted \spad{T[n](x)}, + ++ Note that 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)}. chebyshevU: I -> SUP I ++ chebyshevU(n) returns the nth Chebyshev polynomial \spad{U[n](x)}. - ++ Note: Chebyshev polynomials of the second kind, denoted \spad{U[n](x)}, + ++ Note that 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)}. cyclotomic: I -> SUP I ++ cyclotomic(n) returns the nth cyclotomic polynomial \spad{phi[n](x)}. - ++ Note: \spad{phi[n](x)} is the factor of \spad{x**n - 1} whose roots + ++ Note that \spad{phi[n](x)} is the factor of \spad{x**n - 1} whose roots ++ are the primitive nth roots of unity. euler : I -> SUP RN ++ euler(n) returns the nth Euler polynomial \spad{E[n](x)}. - ++ Note: Euler polynomials denoted \spad{E(n,x)} computed by solving the - ++ differential equation \spad{differentiate(E(n,x),x) = n E(n-1,x)} where - ++ \spad{E(0,x) = 1} and initial condition comes from \spad{E(n) = 2**n E(n,1/2)}. + ++ Note that Euler polynomials denoted \spad{E(n,x)} computed by solving + ++ the differential equation + ++ \spad{differentiate(E(n,x),x) = n E(n-1,x)} where + ++ \spad{E(0,x) = 1} and initial condition comes + ++ from \spad{E(n) = 2**n E(n,1/2)}. fixedDivisor: SUP I -> I ++ fixedDivisor(a) for \spad{a(x)} in \spad{Z[x]} is the largest integer ++ f such that f divides \spad{a(x=k)} for all integers k. - ++ Note: fixed divisor of \spad{a} is + ++ Note that fixed divisor of \spad{a} is ++ \spad{reduce(gcd,[a(x=k) for k in 0..degree(a)])}. hermite : I -> SUP I ++ hermite(n) returns the nth Hermite polynomial \spad{H[n](x)}. - ++ Note: Hermite polynomials, denoted \spad{H[n](x)}, are computed from + ++ Note that Hermite polynomials, denoted \spad{H[n](x)}, are computed from ++ the two term recurrence. The generating function is: ++ \spad{exp(2*t*x-t**2) = sum(H[n](x)*t**n/n!, n=0..infinity)}. laguerre : I -> SUP I ++ laguerre(n) returns the nth Laguerre polynomial \spad{L[n](x)}. - ++ Note: Laguerre polynomials, denoted \spad{L[n](x)}, are computed from - ++ the two term recurrence. The generating function is: + ++ Note that Laguerre polynomials, denoted \spad{L[n](x)}, are computed + ++ from the two term recurrence. The generating function is: ++ \spad{exp(x*t/(t-1))/(1-t) = sum(L[n](x)*t**n/n!, n=0..infinity)}. legendre : I -> SUP RN ++ legendre(n) returns the nth Legendre polynomial \spad{P[n](x)}. - ++ Note: Legendre polynomials, denoted \spad{P[n](x)}, are computed from - ++ the two term recurrence. The generating function is: + ++ Note that Legendre polynomials, denoted \spad{P[n](x)}, are computed + ++ from the two term recurrence. The generating function is: ++ \spad{1/sqrt(1-2*t*x+t**2) = sum(P[n](x)*t**n, n=0..infinity)}. Implementation ==> add import IntegerPrimesPackage(I) @@ -123510,9 +124209,10 @@ PolynomialNumberTheoryFunctions(): Exports == Implementation where ++ Author: Manuel Bronstein ++ Date Created: 15 July 1988 ++ Date Last Updated: 10 November 1993 -++ Description: computes n-th roots of quotients of -++ multivariate polynomials +++ Description: +++ Computes n-th roots of quotients of multivariate polynomials -- not visible to the user + PolynomialRoots(E, V, R, P, F):Exports == Implementation where E: OrderedAbelianMonoidSup V: OrderedSet @@ -123520,11 +124220,11 @@ PolynomialRoots(E, V, R, P, F):Exports == Implementation where P: PolynomialCategory(R, E, V) F: Field with numer : $ -> P - ++ numer(x) \undocumented + ++ numer(x) \undocumented denom : $ -> P - ++ denom(x) \undocumented + ++ denom(x) \undocumented coerce: P -> $ - ++ coerce(p) \undocumented + ++ coerce(p) \undocumented N ==> NonNegativeInteger Z ==> Integer @@ -123542,7 +124242,7 @@ PolynomialRoots(E, V, R, P, F):Exports == Implementation where ++ froot(f, n) returns \spad{[m,c,r]} such ++ that \spad{f**(1/n) = c * r**(1/m)}. nthr: (P, N) -> Record(exponent:N,coef:P,radicand:List P) - ++ nthr(p,n) should be local but conditional + ++ nthr(p,n) should be local but conditional Implementation ==> add import FactoredFunctions Z @@ -123697,7 +124397,6 @@ PolynomialRoots(E, V, R, P, F):Exports == Implementation where ++ The aim of many of the operations of this package is to remove certain ++ factors in some polynomials in order to avoid unnecessary computations ++ in algorithms involving splitting techniques by partial factorization. -++ Version: 3 PolynomialSetUtilitiesPackage (R,E,V,P) : Exports == Implementation where @@ -124544,40 +125243,40 @@ PolynomialSolveByFormulas(UP, F): PSFcat == PSFdef where PSFcat == with solve: UP -> L F - ++ solve(u) \undocumented + ++ solve(u) \undocumented particularSolution: UP -> F - ++ particularSolution(u) \undocumented + ++ particularSolution(u) \undocumented mapSolve: (UP, F -> F) -> Record(solns: L F, maps: L Record(arg:F,res:F)) - ++ mapSolve(u,f) \undocumented + ++ mapSolve(u,f) \undocumented linear: UP -> L F - ++ linear(u) \undocumented + ++ linear(u) \undocumented quadratic: UP -> L F - ++ quadratic(u) \undocumented + ++ quadratic(u) \undocumented cubic: UP -> L F - ++ cubic(u) \undocumented + ++ cubic(u) \undocumented quartic: UP -> L F - ++ quartic(u) \undocumented + ++ quartic(u) \undocumented -- Arguments give coefs from high to low degree. linear: (F, F) -> L F - ++ linear(f,g) \undocumented + ++ linear(f,g) \undocumented quadratic: (F, F, F) -> L F - ++ quadratic(f,g,h) \undocumented + ++ quadratic(f,g,h) \undocumented cubic: (F, F, F, F) -> L F - ++ cubic(f,g,h,i) \undocumented + ++ cubic(f,g,h,i) \undocumented quartic: (F, F, F, F, F) -> L F - ++ quartic(f,g,h,i,j) \undocumented + ++ quartic(f,g,h,i,j) \undocumented aLinear: (F, F) -> F - ++ aLinear(f,g) \undocumented + ++ aLinear(f,g) \undocumented aQuadratic: (F, F, F) -> F - ++ aQuadratic(f,g,h) \undocumented + ++ aQuadratic(f,g,h) \undocumented aCubic: (F, F, F, F) -> F - ++ aCubic(f,g,h,j) \undocumented + ++ aCubic(f,g,h,j) \undocumented aQuartic: (F, F, F, F, F) -> F - ++ aQuartic(f,g,h,i,k) \undocumented + ++ aQuartic(f,g,h,i,k) \undocumented PSFdef == add @@ -124824,7 +125523,8 @@ PolynomialSolveByFormulas(UP, F): PSFcat == PSFdef where ++ Description: ++ This package computes square-free decomposition of multivariate ++ polynomials over a coefficient ring which is an arbitrary gcd domain. -++ The requirement on the coefficient domain guarantees that the \spadfun{content} can be +++ The requirement on the coefficient domain guarantees that the +++ \spadfun{content} can be ++ removed so that factors will be primitive as well as square-free. ++ Over an infinite ring of finite characteristic,it may not be possible to ++ guarantee that the factors are square-free. @@ -125012,10 +125712,11 @@ PolynomialToUnivariatePolynomial(x:Symbol, R:Ring): with ++ Examples: ++ References: ++ Description: -++ PowerSeriesLimitPackage implements limits of expressions -++ in one or more variables as one of the variables approaches a -++ limiting value. Included are two-sided limits, left- and right- -++ hand limits, and limits at plus or minus infinity. +++ PowerSeriesLimitPackage implements limits of expressions +++ in one or more variables as one of the variables approaches a +++ limiting value. Included are two-sided limits, left- and right- +++ hand limits, and limits at plus or minus infinity. + PowerSeriesLimitPackage(R,FE): Exports == Implementation where R : Join(GcdDomain,OrderedSet,RetractableTo Integer,_ LinearlyExplicitRingOver Integer) @@ -125542,6 +126243,7 @@ PowerSeriesLimitPackage(R,FE): Exports == Implementation where ++ \spadtype{PrecomputedAssociatedEquations} stores some generic ++ precomputations which speed up the computations of the ++ associated equations needed for factoring operators. + PrecomputedAssociatedEquations(R, L): Exports == Implementation where R: IntegralDomain L: LinearOrdinaryDifferentialOperatorCategory R @@ -125650,8 +126352,10 @@ PrecomputedAssociatedEquations(R, L): Exports == Implementation where <>= )abbrev package PRIMARR2 PrimitiveArrayFunctions2 +++ Description: ++ This package provides tools for operating on primitive arrays ++ with unary and binary functions involving different underlying types + PrimitiveArrayFunctions2(A, B): Exports == Implementation where A, B: Type @@ -125676,7 +126380,7 @@ PrimitiveArrayFunctions2(A, B): Exports == Implementation where ++ successive element of the ++ primitive array \spad{a} and an accumulant initialized to r. ++ For example, \spad{reduce(_+$Integer,[1,2,3],0)} - ++ does \spad{3+(2+(1+0))}. Note: third argument r + ++ does \spad{3+(2+(1+0))}. Note that third argument r ++ may be regarded as the identity element for the function f. ++ ++X T1:=PrimitiveArrayFunctions2(Integer,Integer) @@ -125713,14 +126417,14 @@ PrimitiveArrayFunctions2(A, B): Exports == Implementation where <>= )abbrev package PRIMELT PrimitiveElement -++ Computation of primitive elements. ++ Author: Manuel Bronstein ++ Date Created: 6 Jun 1990 ++ Date Last Updated: 25 April 1991 -++ Description: -++ PrimitiveElement provides functions to compute primitive elements -++ in algebraic extensions; ++ Keywords: algebraic, extension, primitive. +++ Description: +++ PrimitiveElement provides functions to compute primitive elements +++ in algebraic extensions; + PrimitiveElement(F): Exports == Implementation where F : Join(Field, CharacteristicZero) @@ -125841,9 +126545,10 @@ PrimitiveElement(F): Exports == Implementation where ++ Date Created: 1 March 1991 ++ Date Last Updated: 1 February 1994 ++ Description: -++ \spad{PrimitiveRatDE} provides functions for in-field solutions of linear -++ ordinary differential equations, in the transcendental case. -++ The derivation to use is given by the parameter \spad{L}. +++ \spad{PrimitiveRatDE} provides functions for in-field solutions of linear +++ ordinary differential equations, in the transcendental case. +++ The derivation to use is given by the parameter \spad{L}. + PrimitiveRatDE(F, UP, L, LQ): Exports == Implementation where F : Join(Field, CharacteristicZero, RetractableTo Fraction Integer) UP : UnivariatePolynomialCategory F @@ -126038,7 +126743,9 @@ PrimitiveRatDE(F, UP, L, LQ): Exports == Implementation where ++ Author: Manuel Bronstein ++ Date Created: 22 October 1991 ++ Date Last Updated: 2 February 1993 -++ Description: In-field solution of Riccati equations, primitive case. +++ Description: +++ In-field solution of Riccati equations, primitive case. + PrimitiveRatRicDE(F, UP, L, LQ): Exports == Implementation where F : Join(Field, CharacteristicZero, RetractableTo Fraction Integer) UP : UnivariatePolynomialCategory F @@ -126315,7 +127022,9 @@ PrimitiveRatRicDE(F, UP, L, LQ): Exports == Implementation where ++ AMS Classifications: ++ Keywords: print ++ References: -++ Description: PrintPackage provides a print function for output forms. +++ Description: +++ PrintPackage provides a print function for output forms. + PrintPackage(): with print : OutputForm -> Void ++ print(o) writes the output form o on standard output using the @@ -126344,13 +127053,13 @@ PrintPackage(): with <>= )abbrev package PSEUDLIN PseudoLinearNormalForm -++ Normal forms of pseudo-linear operators ++ Author: Bruno Zuercher ++ Date Created: November 1993 ++ Date Last Updated: 12 April 1994 ++ Description: -++ PseudoLinearNormalForm provides a function for computing a block-companion -++ form for pseudo-linear operators. +++ PseudoLinearNormalForm provides a function for computing a block-companion +++ form for pseudo-linear operators. + PseudoLinearNormalForm(K:Field): Exports == Implementation where ER ==> Record(C: Matrix K, g: Vector K) REC ==> Record(R: Matrix K, A: Matrix K, Ainv: Matrix K) @@ -126554,7 +127263,7 @@ algebraic factorization, integration). <>= )abbrev package PRS PseudoRemainderSequence -++ Author: Ducos Lionel +++ Author: Ducos Lionel (Lionel.Ducos@mathlabo.univ-poitiers.fr) ++ Date Created: january 1995 ++ Date Last Updated: 5 february 1999 ++ Basic Functions: @@ -126562,23 +127271,15 @@ algebraic factorization, integration). ++ Also See: ++ AMS Classifications: ++ Keywords: -++ Description: This package contains some functions: -++ \axiomOpFrom{discriminant}{PseudoRemainderSequence}, -++ \axiomOpFrom{resultant}{PseudoRemainderSequence}, -++ \axiomOpFrom{subResultantGcd}{PseudoRemainderSequence}, -++ \axiomOpFrom{chainSubResultants}{PseudoRemainderSequence}, -++ \axiomOpFrom{degreeSubResultant}{PseudoRemainderSequence}, -++ \axiomOpFrom{lastSubResultant}{PseudoRemainderSequence}, -++ \axiomOpFrom{resultantEuclidean}{PseudoRemainderSequence}, -++ \axiomOpFrom{subResultantGcdEuclidean}{PseudoRemainderSequence}, -++ \axiomOpFrom{semiSubResultantGcdEuclidean1}{PseudoRemainderSequence}, -++ \axiomOpFrom{semiSubResultantGcdEuclidean2}{PseudoRemainderSequence}, etc. -++ This procedures are coming from improvements -++ of the subresultants algorithm. -++ Version : 7 -++ References : Lionel Ducos "Optimizations of the subresultant algorithm" -++ to appear in the Journal of Pure and Applied Algebra. -++ Author : Ducos Lionel \axiom{Lionel.Ducos@mathlabo.univ-poitiers.fr} +++ References : +++ Lionel Ducos "Optimizations of the subresultant algorithm" +++ to appear in the Journal of Pure and Applied Algebra. +++ Description: +++ This package contains some functions: discriminant, resultant, +++ subResultantGcd, chainSubResultants, degreeSubResultant, lastSubResultant, +++ resultantEuclidean, subResultantGcdEuclidean, semiSubResultantGcdEuclidean1, +++ semiSubResultantGcdEuclidean2\br +++ These procedures come from improvements of the subresultants algorithm. PseudoRemainderSequence(R, polR) : Specification == Implementation where R : IntegralDomain @@ -126600,7 +127301,7 @@ PseudoRemainderSequence(R, polR) : Specification == Implementation where Record(coef2 : polR, resultant : R) ++ \axiom{semiResultantEuclidean2(P,Q)} carries out the equality ++ \axiom{...P + coef2*Q = resultant(P,Q)}. - ++ Warning: \axiom{degree(P) >= degree(Q)}. + ++ Warning. \axiom{degree(P) >= degree(Q)}. semiResultantEuclidean1 : (polR, polR) -> Record(coef1 : polR, resultant : R) @@ -126622,7 +127323,7 @@ PseudoRemainderSequence(R, polR) : Specification == Implementation where ++ \axiom{semiIndiceSubResultantEuclidean(P, Q, i)} returns ++ the subresultant \axiom{S_i(P,Q)} and carries out the equality ++ \axiom{...P + coef2*Q = S_i(P,Q)} - ++ Warning: \axiom{degree(P) >= degree(Q)}. + ++ Warning. \axiom{degree(P) >= degree(Q)}. degreeSubResultant : (polR, polR, NNI) -> polR ++ \axiom{degreeSubResultant(P, Q, d)} computes @@ -126639,7 +127340,7 @@ PseudoRemainderSequence(R, polR) : Specification == Implementation where ++ \axiom{indiceSubResultant(P, Q, i)} returns ++ a subresultant \axiom{S} of degree \axiom{d} ++ and carries out the equality \axiom{...P + coef2*Q = S_i}. - ++ Warning: \axiom{degree(P) >= degree(Q)}. + ++ Warning. \axiom{degree(P) >= degree(Q)}. lastSubResultant : (polR, polR) -> polR ++ \axiom{lastSubResultant(P, Q)} computes @@ -126656,7 +127357,7 @@ PseudoRemainderSequence(R, polR) : Specification == Implementation where ++ \axiom{semiLastSubResultantEuclidean(P, Q)} computes ++ the last non zero subresultant \axiom{S} ++ and carries out the equality \axiom{...P + coef2*Q = S}. - ++ Warning: \axiom{degree(P) >= degree(Q)}. + ++ Warning. \axiom{degree(P) >= degree(Q)}. subResultantGcd : (polR, polR) -> polR ++ \axiom{subResultantGcd(P, Q)} returns the gcd @@ -126675,7 +127376,7 @@ PseudoRemainderSequence(R, polR) : Specification == Implementation where ++ \axiom{...P + coef2*Q = +/- S_i(P,Q)} ++ where the degree (not the indice) ++ of the subresultant \axiom{S_i(P,Q)} is the smaller as possible. - ++ Warning: \axiom{degree(P) >= degree(Q)}. + ++ Warning. \axiom{degree(P) >= degree(Q)}. semiSubResultantGcdEuclidean1: (polR, polR)->Record(coef1: polR, gcd: polR) ++ \axiom{semiSubResultantGcdEuclidean1(P,Q)} carries out the equality @@ -126696,7 +127397,7 @@ PseudoRemainderSequence(R, polR) : Specification == Implementation where Record(coef2 : polR, discriminant : R) ++ \axiom{discriminantEuclidean(P)} carries out the equality ++ \axiom{...P + coef2 * D(P) = discriminant(P)}. - ++ Warning: \axiom{degree(P) >= degree(Q)}. + ++ Warning. \axiom{degree(P) >= degree(Q)}. chainSubResultants : (polR, polR) -> List(polR) ++ \axiom{chainSubResultants(P, Q)} computes the list @@ -127501,14 +128202,15 @@ PseudoRemainderSequence(R, polR) : Specification == Implementation where <>= )abbrev package INTPAF PureAlgebraicIntegration -++ Integration of pure algebraic functions; ++ Author: Manuel Bronstein ++ Date Created: 27 May 1988 ++ Date Last Updated: 24 June 1994 ++ Description: +++ Integration of pure algebraic functions; ++ This package provides functions for integration, limited integration, ++ extended integration and the risch differential equation for ++ pure algebraic integrands; + PureAlgebraicIntegration(R, F, L): Exports == Implementation where R: Join(GcdDomain,RetractableTo Integer,OrderedSet, CharacteristicZero, LinearlyExplicitRingOver Integer) @@ -127902,8 +128604,10 @@ PureAlgebraicIntegration(R, F, L): Exports == Implementation where ++ Author: Manuel Bronstein ++ Date Created: 21 August 1991 ++ Date Last Updated: 3 February 1994 -++ Description: In-field solution of an linear ordinary differential equation, +++ Description: +++ In-field solution of an linear ordinary differential equation, ++ pure algebraic case. + PureAlgebraicLODE(F, UP, UPUP, R): Exports == Implementation where F : Join(Field, CharacteristicZero, RetractableTo Integer, RetractableTo Fraction Integer) @@ -127956,29 +128660,31 @@ PureAlgebraicLODE(F, UP, UPUP, R): Exports == Implementation where <>= )abbrev package PUSHVAR PushVariables -++ This package \undocumented{} +++ Description: +++ This package has no description + PushVariables(R,E,OV,PPR):C == T where E : OrderedAbelianMonoidSup OV: OrderedSet with convert: % -> Symbol - ++ convert(x) converts x to a symbol + ++ convert(x) converts x to a symbol variable: Symbol -> Union(%, "failed") - ++ variable(s) makes an element from symbol s or fails + ++ variable(s) makes an element from symbol s or fails R : Ring PR ==> Polynomial R PPR: PolynomialCategory(PR,E,OV) SUP ==> SparseUnivariatePolynomial C == with pushdown : (PPR, OV) -> PPR - ++ pushdown(p,v) \undocumented{} + ++ pushdown(p,v) \undocumented{} pushdown : (PPR, List OV) -> PPR - ++ pushdown(p,lv) \undocumented{} + ++ pushdown(p,lv) \undocumented{} pushup : (PPR, OV) -> PPR - ++ pushup(p,v) \undocumented{} + ++ pushup(p,v) \undocumented{} pushup : (PPR, List OV) -> PPR - ++ pushup(p,lv) \undocumented{} + ++ pushup(p,lv) \undocumented{} map : ((PR -> PPR), PPR) -> PPR - ++ map(f,p) \undocumented{} + ++ map(f,p) \undocumented{} T == add pushdown(g:PPR,x:OV) : PPR == @@ -128073,6 +128779,7 @@ PushVariables(R,E,OV,PPR):C == T where ++ basis of radical ideals and ++ is inefficient and restricted when compared to the ++ two in \spadtype{QuasiAlgebraicSet}. + QuasiAlgebraicSet2(vl,nv) : C == T where vl : List Symbol nv : NonNegativeInteger @@ -128188,10 +128895,6 @@ QuasiAlgebraicSet2(vl,nv) : C == T where ++ Also See: `tosedom.spad' ++ AMS Classifications: ++ Keywords: -++ Description: -++ A package for removing redundant quasi-components and redundant -++ branches when decomposing a variety by means of quasi-components -++ of regular triangular sets. \newline ++ References : ++ [1] D. LAZARD "A new method for solving algebraic systems of ++ positive dimension" Discr. App. Math. 33:147-160,1991 @@ -128200,7 +128903,10 @@ QuasiAlgebraicSet2(vl,nv) : C == T where ++ algebriques" These, Universite P.etM. Curie, Paris, 1997. ++ [3] M. MORENO MAZA "A new algorithm for computing triangular ++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. -++ Version: 3. +++ Description: +++ A package for removing redundant quasi-components and redundant +++ branches when decomposing a variety by means of quasi-components +++ of regular triangular sets. QuasiComponentPackage(R,E,V,P,TS): Exports == Implementation where @@ -128240,7 +128946,7 @@ QuasiComponentPackage(R,E,V,P,TS): Exports == Implementation where ++ has higher rank than \axiom{us} w.r.t. Riit and Wu ordering. algebraicSort: Split -> Split ++ \axiom{algebraicSort(lts)} sorts \axiom{lts} w.r.t - ++ \axiomOpFrom{supDimElseRittWu?}{QuasiComponentPackage}. + ++ supDimElseRittWu? moreAlgebraic?: (TS,TS) -> Boolean ++ \axiom{moreAlgebraic?(ts,us)} returns false iff \axiom{ts} ++ and \axiom{us} are both empty, or \axiom{ts} @@ -128256,7 +128962,7 @@ QuasiComponentPackage(R,E,V,P,TS): Exports == Implementation where ++ \axiom{internalSubPolSet?(lp1,lp2)} returns true iff \axiom{lp1} is ++ a sub-set of \axiom{lp2} assuming that these lists are sorted ++ increasingly w.r.t. - ++ \axiomOpFrom{infRittWu?}{RecursivePolynomialCategory}. + ++ infRittWu? from RecursivePolynomialCategory. internalInfRittWu?: (LP, LP) -> Boolean ++ \axiom{internalInfRittWu?(lp1,lp2)} ++ is an internal subroutine, exported only for developement. @@ -128271,7 +128977,7 @@ QuasiComponentPackage(R,E,V,P,TS): Exports == Implementation where ++ inclusion) otherwise returns \axiom{"failed"}. subQuasiComponent?: (TS,TS) -> Boolean ++ \axiom{subQuasiComponent?(ts,us)} returns true iff - ++ \axiomOpFrom{internalSubQuasiComponent?}{QuasiComponentPackage} + ++ internalSubQuasiComponent? ++ returs true. subQuasiComponent?: (TS,Split) -> Boolean ++ \axiom{subQuasiComponent?(ts,lus)} returns true iff @@ -128590,6 +129296,7 @@ QuasiComponentPackage(R,E,V,P,TS): Exports == Implementation where ++ Description: ++ This package extends a function between integral domains ++ to a mapping between their quotient fields. + QuotientFieldCategoryFunctions2(A, B, R, S): Exports == Impl where A, B: IntegralDomain R : QuotientFieldCategory(A) @@ -128719,9 +129426,9 @@ o )show QuaternionCategoryFunctions2 ++ AMS Classifications: 11R52 ++ Keywords: quaternions, division ring, map ++ Description: -++ \spadtype{QuaternionCategoryFunctions2} implements functions between -++ two quaternion domains. The function \spadfun{map} is used by -++ the system interpreter to coerce between quaternion types. +++ \spadtype{QuaternionCategoryFunctions2} implements functions between +++ two quaternion domains. The function \spadfun{map} is used by +++ the system interpreter to coerce between quaternion types. QuaternionCategoryFunctions2(QR,R,QS,S) : Exports == Implementation where @@ -128783,6 +129490,7 @@ QuaternionCategoryFunctions2(QR,R,QS,S) : Exports == ++ rational functions over the integers. ++ (see \spadtype{Fraction Polynomial Integer}). ++ The eigenvalues and eigenvectors are expressed in terms of radicals. + RadicalEigenPackage() : C == T where R ==> Integer @@ -129440,6 +130148,7 @@ o )show RealSolvePackage ++ This package tries to find solutions ++ expressed in terms of radicals for systems of equations ++ of rational functions with coefficients in an integral domain R. + RadicalSolvePackage(R): Cat == Capsule where R : Join(EuclideanDomain, OrderedSet, CharacteristicZero) PI ==> PositiveInteger @@ -129766,7 +130475,8 @@ RadicalSolvePackage(R): Cat == Capsule where ++ Examples: ++ References: ++ Description: -++ This package provides tools for creating radix expansions. +++ This package provides tools for creating radix expansions. + RadixUtilities: Exports == Implementation where Exports ==> with radix: (Fraction Integer,Integer) -> Any @@ -129800,13 +130510,14 @@ RadixUtilities: Exports == Implementation where )abbrev package RDIST RandomDistributions ++ Description: ++ This package exports random distributions + RandomDistributions(S: SetCategory): with uniform: Set S -> (() -> S) - ++ uniform(s) \undocumented + ++ uniform(s) \undocumented weighted: List Record(value: S, weight: Integer) -> (()->S) - ++ weighted(l) \undocumented + ++ weighted(l) \undocumented rdHack1: (Vector S,Vector Integer,Integer)->(()->S) - ++ rdHack1(v,u,n) \undocumented + ++ rdHack1(v,u,n) \undocumented == add import RandomNumberSource() @@ -129875,34 +130586,35 @@ RandomDistributions(S: SetCategory): with )abbrev package RFDIST RandomFloatDistributions ++ Description: ++ This package exports random floating-point distributions + RationalNumber==> Fraction Integer RandomFloatDistributions(): Cat == Body where NNI ==> NonNegativeInteger Cat ==> with uniform01: () -> Float - ++ uniform01() \undocumented + ++ uniform01() \undocumented normal01: () -> Float - ++ normal01() \undocumented + ++ normal01() \undocumented exponential1:() -> Float - ++ exponential1() \undocumented + ++ exponential1() \undocumented chiSquare1: NNI -> Float - ++ chiSquare1(n) \undocumented + ++ chiSquare1(n) \undocumented uniform: (Float, Float) -> (() -> Float) - ++ uniform(f,g) \undocumented + ++ uniform(f,g) \undocumented normal: (Float, Float) -> (() -> Float) - ++ normal(f,g) \undocumented + ++ normal(f,g) \undocumented exponential: (Float) -> (() -> Float) - ++ exponential(f) \undocumented + ++ exponential(f) \undocumented chiSquare: (NNI) -> (() -> Float) - ++ chiSquare(n) \undocumented + ++ chiSquare(n) \undocumented Beta: (NNI, NNI) -> (() -> Float) - ++ Beta(n,m) \undocumented + ++ Beta(n,m) \undocumented F: (NNI, NNI) -> (() -> Float) - ++ F(n,m) \undocumented + ++ F(n,m) \undocumented t: (NNI) -> (() -> Float) - ++ t(n) \undocumented + ++ t(n) \undocumented Body ==> add @@ -129987,6 +130699,7 @@ RandomFloatDistributions(): Cat == Body where )abbrev package RIDIST RandomIntegerDistributions ++ Description: ++ This package exports integer distributions + RandomIntegerDistributions(): with uniform: Segment Integer -> (() -> Integer) ++ uniform(s) as @@ -130060,14 +130773,15 @@ RandomIntegerDistributions(): with ++ Keywords: ++ Examples: ++ References: -++ Description:Random number generators ---% RandomNumberSource -++ All random numbers used in the system should originate from -++ the same generator. This package is intended to be the source. +++ Description: +++ Random number generators. +++ All random numbers used in the system should originate from +++ the same generator. This package is intended to be the source. -- -- Possible improvements: -- 1) Start where the user left off -- 2) Be able to switch between methods in the random number source. + RandomNumberSource(): with -- If r := randnum() then 0 <= r < size(). randnum: () -> Integer @@ -130132,18 +130846,21 @@ RandomNumberSource(): with ++ Author: P. Gianni ++ Date created: ?? ++ Date last updated: December 1993 +++ Keywords: factorization, hensel, rational number +++ Description: ++ Factorization of extended polynomials with rational coefficients. ++ This package implements factorization of extended polynomials ++ whose coefficients are rational numbers. It does this by taking the ++ lcm of the coefficients of the polynomial and creating a polynomial -++ with integer coefficients. The algorithm in \spadtype{GaloisGroupFactorizer} is then +++ with integer coefficients. The algorithm in +++ \spadtype{GaloisGroupFactorizer} is then ++ used to factor the integer polynomial. The result is normalized ++ with respect to the original lcm of the denominators. -++ Keywords: factorization, hensel, rational number -I ==> Integer -RN ==> Fraction Integer + RationalFactorize(RP) : public == private where + I ==> Integer + RN ==> Fraction Integer BP ==> SparseUnivariatePolynomial(I) RP : UnivariatePolynomialCategory RN @@ -130208,15 +130925,15 @@ RationalFactorize(RP) : public == private where <>= )abbrev package RF RationalFunction -++ Top-level manipulations of rational functions ++ Author: Manuel Bronstein ++ Date Created: 1987 ++ Date Last Updated: 18 April 1991 -++ Description: -++ Utilities that provide the same top-level manipulations on -++ fractions than on polynomials. ++ Keywords: polynomial, fraction +++ Description: +++ Utilities that provide the same top-level manipulations on +++ fractions than on polynomials. -- Do not make into a domain! + RationalFunction(R:IntegralDomain): Exports == Implementation where V ==> Symbol P ==> Polynomial R @@ -130296,14 +131013,13 @@ RationalFunction(R:IntegralDomain): Exports == Implementation where <>= )abbrev package DEFINTRF RationalFunctionDefiniteIntegration -++ Definite integration of rational functions. ++ Author: Manuel Bronstein ++ Date Created: 2 October 1989 ++ Date Last Updated: 2 February 1993 ++ Description: -++ \spadtype{RationalFunctionDefiniteIntegration} provides functions to -++ compute definite integrals of rational functions. - +++ Definite integration of rational functions. +++ \spadtype{RationalFunctionDefiniteIntegration} provides functions to +++ compute definite integrals of rational functions. RationalFunctionDefiniteIntegration(R): Exports == Implementation where R : Join(EuclideanDomain, OrderedSet, CharacteristicZero, @@ -130402,7 +131118,6 @@ RationalFunctionDefiniteIntegration(R): Exports == Implementation where <>= )abbrev package RFFACT RationalFunctionFactor -++ Factorisation in UP FRAC POLY INT ++ Author: Patrizia Gianni ++ Date Created: ??? ++ Date Last Updated: ??? @@ -130519,15 +131234,13 @@ RationalFunctionFactorizer(R) : C == T <>= )abbrev package INTRF RationalFunctionIntegration -++ Integration of rational functions ++ Author: Manuel Bronstein ++ Date Created: 1987 ++ Date Last Updated: 29 Mar 1990 ++ Keywords: polynomial, fraction, integration. ++ Description: -++ This package provides functions for the integration -++ of rational functions. -++ Examples: )r INTRF INPUT +++ This package provides functions for the integration of rational functions. + RationalFunctionIntegration(F): Exports == Implementation where F: Join(IntegralDomain, RetractableTo Integer, CharacteristicZero) @@ -130598,12 +131311,13 @@ RationalFunctionIntegration(F): Exports == Implementation where <>= )abbrev package LIMITRF RationalFunctionLimitPackage -++ Computation of limits for rational functions ++ Author: Manuel Bronstein ++ Date Created: 4 October 1989 ++ Date Last Updated: 26 November 1991 -++ Description: Computation of limits for rational functions. ++ Keywords: limit, rational function. +++ Description: +++ Computation of limits for rational functions. + RationalFunctionLimitPackage(R:GcdDomain):Exports==Implementation where Z ==> Integer P ==> Polynomial R @@ -130760,12 +131474,12 @@ RationalFunctionLimitPackage(R:GcdDomain):Exports==Implementation where <>= )abbrev package SIGNRF RationalFunctionSign ---%% RationalFunctionSign ++ Author: Manuel Bronstein ++ Date Created: 23 August 1989 ++ Date Last Updated: 26 November 1991 ++ Description: ++ Find the sign of a rational function around a point or infinity. + RationalFunctionSign(R:GcdDomain): Exports == Implementation where SE ==> Symbol P ==> Polynomial R @@ -131117,11 +131831,12 @@ o )show RationalFunctionSum <>= )abbrev package SUMRF RationalFunctionSum -++ Summation of rational functions ++ Author: Manuel Bronstein ++ Date Created: ??? ++ Date Last Updated: 19 April 1991 -++ Description: Computes sums of rational functions; +++ Description: +++ Computes sums of rational functions; + RationalFunctionSum(R): Exports == Impl where R: Join(IntegralDomain, OrderedSet, RetractableTo Integer) @@ -131208,14 +131923,14 @@ RationalFunctionSum(R): Exports == Impl where <>= )abbrev package INTRAT RationalIntegration -++ Rational function integration ++ Author: Manuel Bronstein ++ Date Created: 1987 ++ Date Last Updated: 24 October 1995 ++ Description: -++ This package provides functions for the base -++ case of the Risch algorithm. +++ Rational function integration +++ This package provides functions for the base case of the Risch algorithm. -- Used internally bt the integration packages + RationalIntegration(F, UP): Exports == Implementation where F : Join(Field, CharacteristicZero, RetractableTo Integer) UP: UnivariatePolynomialCategory F @@ -131302,6 +132017,7 @@ where the coefficients of the rational function are in any given field. )abbrev package RINTERP RationalInterpolation ++ Description: ++ This package exports rational interpolation algorithms + RationalInterpolation(xx,F): Exports == Implementation where xx: Symbol F: Field @@ -131426,8 +132142,9 @@ Finally, we generate the rational function: ++ Date Created: 13 March 1991 ++ Date Last Updated: 13 April 1994 ++ Description: -++ \spad{RationalLODE} provides functions for in-field solutions of linear -++ ordinary differential equations, in the rational case. +++ \spad{RationalLODE} provides functions for in-field solutions of linear +++ ordinary differential equations, in the rational case. + RationalLODE(F, UP): Exports == Implementation where F : Join(Field, CharacteristicZero, RetractableTo Integer, RetractableTo Fraction Integer) @@ -131671,9 +132388,11 @@ RationalLODE(F, UP): Exports == Implementation where <>= )abbrev package RATRET RationalRetractions ++ Author: Manuel Bronstein -++ Description: rational number testing and retraction functions. ++ Date Created: March 1990 ++ Date Last Updated: 9 April 1991 +++ Description: +++ Rational number testing and retraction functions. + RationalRetractions(S:RetractableTo(Fraction Integer)): with rational : S -> Fraction Integer ++ rational(x) returns x as a rational number; @@ -131715,7 +132434,9 @@ RationalRetractions(S:RetractableTo(Fraction Integer)): with ++ Author: Manuel Bronstein ++ Date Created: 22 October 1991 ++ Date Last Updated: 11 April 1994 -++ Description: In-field solution of Riccati equations, rational case. +++ Description: +++ In-field solution of Riccati equations, rational case. + RationalRicDE(F, UP): Exports == Implementation where F : Join(Field, CharacteristicZero, RetractableTo Integer, RetractableTo Fraction Integer) @@ -132019,13 +132740,12 @@ RationalRicDE(F, UP): Exports == Implementation where ++ Also See: ++ AMS Classifications: ++ Description: -++ A package for computing the rational univariate representation -++ of a zero-dimensional algebraic variety given by a regular -++ triangular set. This package is essentially an interface for the -++ \spadtype{InternalRationalUnivariateRepresentationPackage} constructor. -++ It is used in the \spadtype{ZeroDimensionalSolvePackage} -++ for solving polynomial systems with finitely many solutions. -++ Version: 1. +++ A package for computing the rational univariate representation +++ of a zero-dimensional algebraic variety given by a regular +++ triangular set. This package is essentially an interface for the +++ \spadtype{InternalRationalUnivariateRepresentationPackage} constructor. +++ It is used in the \spadtype{ZeroDimensionalSolvePackage} +++ for solving polynomial systems with finitely many solutions. RationalUnivariateRepresentationPackage(R,ls): Exports == Implementation where R : Join(EuclideanDomain,CharacteristicZero) @@ -132219,6 +132939,7 @@ depending on several ``real roots''. ++ Description: ++ \axiomType{RealPolynomialUtilitiesPackage} provides common functions used ++ by interval coding. + RealPolynomialUtilitiesPackage(TheField,ThePols) : PUB == PRIV where TheField : Field @@ -132488,8 +133209,10 @@ o )show RealSolvePackage <>= )abbrev package REALSOLV RealSolvePackage -++ Description: This package provides numerical solutions of systems of -++ polynomial equations for use in ACPLOT +++ Description: +++ This package provides numerical solutions of systems of +++ polynomial equations for use in ACPLOT + RealSolvePackage(): Exports == Implementation where I ==> Integer IE ==> IndexedExponents Symbol @@ -132577,11 +133300,11 @@ RealSolvePackage(): Exports == Implementation where ++ Keywords: ++ References: ++ Description: -++ This package provides functions for finding the real zeros +++ This package provides functions for finding the real zeros ++ of univariate polynomials over the integers to arbitrary user-specified ++ precision. The results are returned as a list of -++ isolating intervals which are expressed as records with "left" and "right" rational number -++ components. +++ isolating intervals which are expressed as records with +++ "left" and "right" rational number components. RealZeroPackage(Pol): T == C where Pol: UnivariatePolynomialCategory Integer @@ -132886,10 +133609,10 @@ RealZeroPackage(Pol): T == C where ++ Keywords: ++ References: ++ Description: -++ This package provides functions for finding the real zeros -++ of univariate polynomials over the rational numbers to arbitrary user-specified -++ precision. The results are returned as a list of -++ isolating intervals, expressed as records with "left" and "right" rational number components. +++ This package provides functions for finding the real zeros of univariate +++ polynomials over the rational numbers to arbitrary user-specified +++ precision. The results are returned as a list of isolating intervals, +++ expressed as records with "left" and "right" rational number components. RealZeroPackageQ(Pol): T == C where RN ==> Fraction Integer @@ -132981,7 +133704,8 @@ RealZeroPackageQ(Pol): T == C where ++ References: ++ Description: ++ \spadtype{RectangularMatrixCategoryFunctions2} provides functions between -++ two matrix domains. The functions provided are \spadfun{map} and \spadfun{reduce}. +++ two matrix domains. The functions provided are \spadfun{map} and +++ \spadfun{reduce}. RectangularMatrixCategoryFunctions2(m,n,R1,Row1,Col1,M1,R2,Row2,Col2,M2):_ Exports == Implementation where @@ -133056,6 +133780,7 @@ coefficient of $x^n$ in a function specified by a functional equation. ++ This package provides an operator for the n-th term of a recurrence and an ++ operator for the coefficient of x^n in a function specified by a functional ++ equation. + RecurrenceOperator(R, F): Exports == Implementation where R: Join(OrderedSet, IntegralDomain, ConvertibleTo InputForm) F: Join(FunctionSpace R, AbelianMonoid, RetractableTo Integer, _ @@ -133549,10 +134274,12 @@ solution and determine the valuation. <>= )abbrev package RDIV ReducedDivisor -++ Finds the order of a divisor over a finite field ++ Author: Manuel Bronstein ++ Date Created: 1988 ++ Date Last Updated: 8 November 1994 +++ Description: +++ Finds the order of a divisor over a finite field + ReducedDivisor(F1, UP, UPUP, R, F2): Exports == Implementation where F1 : Field UP : UnivariatePolynomialCategory F1 @@ -133567,7 +134294,7 @@ ReducedDivisor(F1, UP, UPUP, R, F2): Exports == Implementation where Exports ==> with order: (FD, UPUP, F1 -> F2) -> N - ++ order(f,u,g) \undocumented + ++ order(f,u,g) \undocumented Implementation ==> add algOrder : (FD, UPUP, F1 -> F2) -> N @@ -133615,8 +134342,10 @@ ReducedDivisor(F1, UP, UPUP, R, F2): Exports == Implementation where ++ Author: Manuel Bronstein ++ Date Created: 19 August 1991 ++ Date Last Updated: 11 April 1994 -++ Description: Elimination of an algebraic from the coefficentss +++ Description: +++ Elimination of an algebraic from the coefficentss ++ of a linear ordinary differential equation. + ReduceLODE(F, L, UP, A, LO): Exports == Implementation where F : Field L : LinearOrdinaryDifferentialOperatorCategory F @@ -133685,11 +134414,12 @@ ReduceLODE(F, L, UP, A, LO): Exports == Implementation where ++ Author: Manuel Bronstein ++ Date Created: 4 November 1991 ++ Date Last Updated: 3 February 1994 +++ Keywords: differential equation, ODE ++ Description: ++ \spadtype{ReductionOfOrder} provides ++ functions for reducing the order of linear ordinary differential equations ++ once some solutions are known. -++ Keywords: differential equation, ODE + ReductionOfOrder(F, L): Exports == Impl where F: Field L: LinearOrdinaryDifferentialOperatorCategory F @@ -133780,6 +134510,9 @@ ReductionOfOrder(F, L): Exports == Impl where ++ Also See: ++ AMS Classifications: ++ Keywords: +++ References : +++ [1] M. MORENO MAZA "A new algorithm for computing triangular +++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. ++ Description: ++ A package providing a new algorithm for solving polynomial systems ++ by means of regular chains. Two ways of solving are proposed: @@ -133799,11 +134532,7 @@ ReductionOfOrder(F, L): Exports == Impl where ++ gcd need to have invertible initials (normalized or not). ++ WARNING. There is no need for a user to call diectly any operation ++ of this package since they can be accessed by the domain \axiom{TS}. -++ Thus, the operations of this package are not documented.\newline -++ References : -++ [1] M. MORENO MAZA "A new algorithm for computing triangular -++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. -++ Version: 5. Same as 4 but Does NOT use any unproved criteria. +++ Thus, the operations of this package are not documented. RegularSetDecompositionPackage(R,E,V,P,TS): Exports == Implementation where @@ -134083,9 +134812,6 @@ RegularSetDecompositionPackage(R,E,V,P,TS): Exports == Implementation where ++ Also See: ++ AMS Classifications: ++ Keywords: -++ Description: -++ An internal package for computing gcds and resultants of univariate -++ polynomials with coefficients in a tower of simple extensions of a field.\newline ++ References : ++ [1] M. MORENO MAZA and R. RIOBOO "Computations of gcd over ++ algebraic towers of simple extensions" In proceedings of AAECC11 @@ -134095,7 +134821,9 @@ RegularSetDecompositionPackage(R,E,V,P,TS): Exports == Implementation where ++ algebriques" These, Universite P.etM. Curie, Paris, 1997. ++ [3] M. MORENO MAZA "A new algorithm for computing triangular ++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. -++ Version: 4. +++ Description: +++ An internal package for computing gcds and resultants of univariate +++ polynomials with coefficients in a tower of simple extensions of a field. RegularTriangularSetGcdPackage(R,E,V,P,TS): Exports == Implementation where @@ -134153,19 +134881,19 @@ RegularTriangularSetGcdPackage(R,E,V,P,TS): Exports == Implementation where ++ is an internal subroutine, exported only for developement. toseLastSubResultant: (P,P,TS) -> List PWT ++ \axiom{toseLastSubResultant(p1,p2,ts)} has the same specifications - ++ as \axiomOpFrom{lastSubResultant}{RegularTriangularSetCategory}. + ++ as lastSubResultant from RegularTriangularSetCategory. toseInvertible?: (P,TS) -> B ++ \axiom{toseInvertible?(p1,p2,ts)} has the same specifications as - ++ \axiomOpFrom{invertible?}{RegularTriangularSetCategory}. + ++ invertible? from RegularTriangularSetCategory. toseInvertible?: (P,TS) -> List BWT ++ \axiom{toseInvertible?(p1,p2,ts)} has the same specifications as - ++ \axiomOpFrom{invertible?}{RegularTriangularSetCategory}. + ++ invertible? from RegularTriangularSetCategory. toseInvertibleSet: (P,TS) -> Split ++ \axiom{toseInvertibleSet(p1,p2,ts)} has the same specifications as - ++ \axiomOpFrom{invertibleSet}{RegularTriangularSetCategory}. + ++ invertibleSet from RegularTriangularSetCategory. toseSquareFreePart: (P,TS) -> List PWT ++ \axiom{toseSquareFreePart(p,ts)} has the same specifications as - ++ \axiomOpFrom{squareFreePart}{RegularTriangularSetCategory}. + ++ squareFreePart from RegularTriangularSetCategory. Implementation == add @@ -134445,11 +135173,8 @@ RegularTriangularSetGcdPackage(R,E,V,P,TS): Exports == Implementation where <>= )abbrev package REPDB RepeatedDoubling -++ Repeated Doubling -++ Integer multiplication by repeated doubling. ++ Description: ++ Implements multiplication by repeated addition -++ RelatedOperations: * -- the following package is only instantiated over % -- thus shouldn't be cached. We prevent it @@ -134459,8 +135184,8 @@ RegularTriangularSetGcdPackage(R,E,V,P,TS): Exports == Implementation where RepeatedDoubling(S):Exports ==Implementation where S: SetCategory with - "+":(%,%)->% - ++ x+y returns the sum of x and y + "+":(%,%)->% + ++ x+y returns the sum of x and y Exports == with double: (PositiveInteger,S) -> S ++ double(i, r) multiplies r by i using repeated doubling. @@ -134493,10 +135218,9 @@ RepeatedDoubling(S):Exports ==Implementation where <>= )abbrev package REPSQ RepeatedSquaring -++ Repeated Squaring ++ Description: ++ Implements exponentiation by repeated squaring -++ RelatedOperations: expt + -- the following package is only instantiated over % -- thus shouldn't be cached. We prevent it -- from being cached by declaring it to be mutableDomains @@ -134505,8 +135229,8 @@ RepeatedDoubling(S):Exports ==Implementation where RepeatedSquaring(S): Exports == Implementation where S: SetCategory with - "*":(%,%)->% - ++ x*y returns the product of x and y + "*":(%,%)->% + ++ x*y returns the product of x and y Exports == with expt: (S,PositiveInteger) -> S ++ expt(r, i) computes r**i by repeated squaring @@ -134564,14 +135288,14 @@ RepeatedSquaring(S): Exports == Implementation where ++ their Realization in the Computer Algebra System Scratchpad, ++ Bayreuther Mathematische Schriften, Heft 33, 1990, 1-23 ++ Description: -++ RepresentationPackage1 provides functions for representation theory -++ for finite groups and algebras. -++ The package creates permutation representations and uses tensor products -++ and its symmetric and antisymmetric components to create new -++ representations of larger degree from given ones. -++ Note: instead of having parameters from \spadtype{Permutation} -++ this package allows list notation of permutations as well: -++ e.g. \spad{[1,4,3,2]} denotes permutes 2 and 4 and fixes 1 and 3. +++ RepresentationPackage1 provides functions for representation theory +++ for finite groups and algebras. +++ The package creates permutation representations and uses tensor products +++ and its symmetric and antisymmetric components to create new +++ representations of larger degree from given ones. +++ Note that instead of having parameters from \spadtype{Permutation} +++ this package allows list notation of permutations as well: +++ e.g. \spad{[1,4,3,2]} denotes permutes 2 and 4 and fixes 1 and 3. RepresentationPackage1(R): public == private where @@ -134594,95 +135318,98 @@ RepresentationPackage1(R): public == private where if R has commutative("*") then antisymmetricTensors : (M R,PI) -> M R ++ antisymmetricTensors(a,n) applies to the square matrix - ++ {\em a} the irreducible, polynomial representation of the - ++ general linear group {\em GLm}, where m is the number of - ++ rows of {\em a}, which corresponds to the partition - ++ {\em (1,1,...,1,0,0,...,0)} of n. + ++ a the irreducible, polynomial representation of the + ++ general linear group GLm, where m is the number of + ++ rows of a, which corresponds to the partition + ++ (1,1,...,1,0,0,...,0) of n. ++ Error: if n is greater than 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 + ++ Note that this corresponds to the symmetrization of the + ++ representation with the sign representation of the symmetric group + ++ Sn. The carrier spaces of the representation are the antisymmetric ++ tensors of the n-fold tensor product. if R has commutative("*") then antisymmetricTensors : (L M R, PI) -> L M R ++ antisymmetricTensors(la,n) applies to each ++ m-by-m square matrix in - ++ the list {\em la} the irreducible, polynomial representation - ++ of the general linear group {\em GLm} + ++ the list la the irreducible, polynomial representation + ++ of the general linear group GLm ++ which corresponds - ++ to the partition {\em (1,1,...,1,0,0,...,0)} of n. + ++ to the partition (1,1,...,1,0,0,...,0) of n. ++ Error: if n is greater than 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 + ++ Note that this corresponds to the symmetrization of the + ++ representation with the sign representation of the symmetric group + ++ Sn. The carrier spaces of the representation are the antisymmetric ++ tensors of the n-fold tensor product. createGenericMatrix : NNI -> M P R ++ createGenericMatrix(m) creates a square matrix of dimension k ++ whose entry at the i-th row and j-th column is the - ++ indeterminate {\em x[i,j]} (double subscripted). + ++ indeterminate x[i,j] (double subscripted). symmetricTensors : (M R, PI) -> M R ++ symmetricTensors(a,n) applies to the m-by-m - ++ square matrix {\em a} the + ++ square matrix a the ++ irreducible, polynomial representation of the general linear - ++ group {\em GLm} - ++ which corresponds to the partition {\em (n,0,...,0)} of n. - ++ Error: if {\em a} is not a square matrix. - ++ Note: this corresponds to the symmetrization of the representation - ++ with the trivial representation of the symmetric group {\em Sn}. + ++ group GLm + ++ which corresponds to the partition (n,0,...,0) of n. + ++ Error: if a is not a square matrix. + ++ Note that this corresponds to the symmetrization of the + ++ representation with the trivial representation of the symmetric + ++ group Sn. ++ The carrier spaces of the representation are the symmetric ++ tensors of the n-fold tensor product. symmetricTensors : (L M R, PI) -> L M R ++ symmetricTensors(la,n) applies to each m-by-m square matrix in the - ++ list {\em la} the irreducible, polynomial representation - ++ of the general linear group {\em GLm} + ++ list la the irreducible, polynomial representation + ++ of the general linear group GLm ++ which corresponds - ++ to the partition {\em (n,0,...,0)} of n. - ++ Error: if the matrices in {\em la} are not square matrices. - ++ Note: this corresponds to the symmetrization of the representation - ++ with the trivial representation of the symmetric group {\em Sn}. + ++ to the partition (n,0,...,0) of n. + ++ Error: if the matrices in la are not square matrices. + ++ Note that this corresponds to the symmetrization of the + ++ representation with the trivial representation of the symmetric + ++ group Sn. ++ The carrier spaces of the representation are the symmetric ++ tensors of the n-fold tensor product. tensorProduct : (M R, M R) -> M R ++ tensorProduct(a,b) calculates the Kronecker product - ++ of the matrices {\em a} and b. - ++ Note: if each matrix corresponds to a group representation + ++ of the matrices a and b. + ++ Note that if each matrix corresponds to a group representation ++ (repr. of generators) of one group, then these matrices ++ correspond to the tensor product of the two representations. tensorProduct : (L M R, L M R) -> L M R ++ tensorProduct([a1,...,ak],[b1,...,bk]) calculates the list of - ++ Kronecker products of the matrices {\em ai} and {\em bi} + ++ Kronecker products of the matrices ai and bi ++ for {1 <= i <= k}. - ++ Note: If each list of matrices corresponds to a group representation - ++ (repr. of generators) of one group, then these matrices - ++ correspond to the tensor product of the two representations. + ++ Note that if each list of matrices corresponds to a group + ++ representation (repr. of generators) of one group, then these + ++ matrices correspond to the tensor product of the two representations. tensorProduct : M R -> M R ++ tensorProduct(a) calculates the Kronecker product - ++ of the matrix {\em a} with itself. + ++ of the matrix a with itself. tensorProduct : L M R -> L M R ++ tensorProduct([a1,...ak]) calculates the list of - ++ Kronecker products of each matrix {\em ai} with itself + ++ Kronecker products of each matrix ai with itself ++ for {1 <= i <= k}. - ++ Note: If the list of matrices corresponds to a group representation - ++ (repr. of generators) of one group, then these matrices correspond - ++ to the tensor product of the representation with itself. + ++ Note that if the list of matrices corresponds to a group + ++ representation (repr. of generators) of one group, then these + ++ matrices correspond to the tensor product of the representation + ++ with itself. permutationRepresentation : (PERM I, I) -> M I ++ permutationRepresentation(pi,n) returns the matrix - ++ {\em (deltai,pi(i))} (Kronecker delta) for a permutation - ++ {\em pi} of {\em {1,2,...,n}}. + ++ (deltai,pi(i)) (Kronecker delta) for a permutation + ++ pi of {1,2,...,n}. permutationRepresentation : L I -> M I ++ permutationRepresentation(pi,n) returns the matrix - ++ {\em (deltai,pi(i))} (Kronecker delta) if the permutation - ++ {\em pi} is in list notation and permutes {\em {1,2,...,n}}. + ++ (deltai,pi(i)) (Kronecker delta) if the permutation + ++ pi is in list notation and permutes {1,2,...,n}. permutationRepresentation : (L PERM I, I) -> L M I ++ permutationRepresentation([pi1,...,pik],n) returns the list - ++ of matrices {\em [(deltai,pi1(i)),...,(deltai,pik(i))]} - ++ (Kronecker delta) for the permutations {\em pi1,...,pik} - ++ of {\em {1,2,...,n}}. + ++ of matrices [(deltai,pi1(i)),...,(deltai,pik(i))] + ++ (Kronecker delta) for the permutations pi1,...,pik + ++ of {1,2,...,n}. permutationRepresentation : L L I -> L M I ++ permutationRepresentation([pi1,...,pik],n) returns the list - ++ of matrices {\em [(deltai,pi1(i)),...,(deltai,pik(i))]} - ++ if the permutations {\em pi1},...,{\em pik} are in - ++ list notation and are permuting {\em {1,2,...,n}}. + ++ of matrices [(deltai,pi1(i)),...,(deltai,pik(i))] + ++ if the permutations pi1,...,pik are in + ++ list notation and are permuting {1,2,...,n}. private ==> add @@ -134910,15 +135637,16 @@ RepresentationPackage1(R): public == private where ++ their Realization in the Computer Algebra System Scratchpad, ++ Bayreuther Mathematische Schriften, Heft 33, 1990, 1-23. ++ Description: -++ RepresentationPackage2 provides functions for working with -++ modular representations of finite groups and algebra. -++ The routines in this package are created, using ideas of R. Parker, -++ (the meat-Axe) to get smaller representations from bigger ones, -++ i.e. finding sub- and factormodules, or to show, that such the -++ representations are irreducible. -++ Note: most functions are randomized functions of Las Vegas type -++ i.e. every answer is correct, but with small probability -++ the algorithm fails to get an answer. +++ RepresentationPackage2 provides functions for working with +++ modular representations of finite groups and algebra. +++ The routines in this package are created, using ideas of R. Parker, +++ (the meat-Axe) to get smaller representations from bigger ones, +++ i.e. finding sub- and factormodules, or to show, that such the +++ representations are irreducible. +++ Note that most functions are randomized functions of Las Vegas type +++ i.e. every answer is correct, but with small probability +++ the algorithm fails to get an answer. + RepresentationPackage2(R): public == private where R : Ring @@ -134936,15 +135664,16 @@ RepresentationPackage2(R): public == private where public ==> with completeEchelonBasis : V V R -> M R - ++ completeEchelonBasis(lv) completes the basis {\em lv} assumed - ++ to be in echelon form of a subspace of {\em R**n} (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 + ++ completeEchelonBasis(lv) completes the basis lv assumed + ++ to be in echelon form of a subspace of R**n (n the length + ++ of all the vectors in lv with unit vectors to a basis of + ++ 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. + ++ Note that the rows of the result correspond to the vectors + ++ of the basis. createRandomElement : (L M R, M R) -> M R ++ createRandomElement(aG,x) creates a random element of the group - ++ algebra generated by {\em aG}. + ++ algebra generated by aG. -- randomWord : (L L I, L M) -> M R --++ You can create your own 'random' matrix with "randomWord(lli, lm)". --++ Each li in lli determines a product of matrices, the entries in li @@ -134957,24 +135686,23 @@ RepresentationPackage2(R): public == private where ++ It is assumed that the size n of the vector equals the number ++ of rows and columns of the matrices. Then the matrices generate ++ a subalgebra, say \spad{A}, of the algebra of all square matrices of - ++ dimension n. {\em V R} is an \spad{A}-module in the natural way. - ++ cyclicSubmodule(lm,v) generates the R-Basis of {\em Av} as + ++ dimension n. V R is an \spad{A}-module in the natural way. + ++ cyclicSubmodule(lm,v) generates the R-Basis of Av as ++ described in section 6 of R. A. Parker's "The Meat-Axe". - ++ Note: in contrast to the description in "The Meat-Axe" and to - ++ {\em standardBasisOfCyclicSubmodule} the result is in - ++ echelon form. + ++ Note that in contrast to the description in "The Meat-Axe" and to + ++ standardBasisOfCyclicSubmodule the result is in echelon form. standardBasisOfCyclicSubmodule : (L M R, V R) -> M R ++ standardBasisOfCyclicSubmodule(lm,v) returns a matrix as follows. ++ It is assumed that the size n of the vector equals the number ++ of rows and columns of the matrices. Then the matrices generate ++ a subalgebra, say \spad{A}, ++ of the algebra of all square matrices of - ++ dimension n. {\em V R} is an \spad{A}-module in the natural way. + ++ dimension n. V R is an \spad{A}-module in the natural way. ++ standardBasisOfCyclicSubmodule(lm,v) calculates a matrix whose - ++ non-zero column vectors are the R-Basis of {\em Av} achieved + ++ non-zero column vectors are the R-Basis of Av achieved ++ in the way as described in section 6 ++ of R. A. Parker's "The Meat-Axe". - ++ Note: in contrast to {\em cyclicSubmodule}, the result is not + ++ Note that in contrast to cyclicSubmodule, the result is not ++ in echelon form. if R has Field then -- only because of inverse in SM areEquivalent? : (L M R, L M R, B, I) -> M R @@ -134984,7 +135712,7 @@ RepresentationPackage2(R): public == private where ++ matrix. If these matrices represent the same group generators, ++ the representations are equivalent. ++ The algorithm tries - ++ {\em numberOfTries} times to create elements in the + ++ 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 @@ -134992,23 +135720,23 @@ RepresentationPackage2(R): public == private where ++ 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 (e.g. irreducibility !) - ++ we use {\em standardBasisOfCyclicSubmodule} to create the + ++ we use 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}. + ++ matrix conjugates all corresponding matrices from aGi. + ++ The way to choose the singular matrices is as in 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 i. If the representations + ++ returns the transformation matrix TM with + ++ aG0.i * TM = TM * aG1.i for all i. If the representations ++ are not equivalent, a small 0-matrix is returned. - ++ Note: the case + ++ Note that the case ++ with different sets of group generators cannot be handled. areEquivalent? : (L M R, L M R) -> M R - ++ areEquivalent?(aG0,aG1) calls {\em areEquivalent?(aG0,aG1,true,25)}. - ++ Note: the choice of 25 was rather arbitrary. + ++ areEquivalent?(aG0,aG1) calls areEquivalent?(aG0,aG1,true,25). + ++ Note that the choice of 25 was rather arbitrary. areEquivalent? : (L M R, L M R, I) -> M R ++ areEquivalent?(aG0,aG1,numberOfTries) calls - ++ {\em areEquivalent?(aG0,aG1,true,25)}. - ++ Note: the choice of 25 was rather arbitrary. + ++ areEquivalent?(aG0,aG1,true,25). + ++ Note that the choice of 25 was rather arbitrary. isAbsolutelyIrreducible? : (L M R, I) -> B ++ isAbsolutelyIrreducible?(aG, numberOfTries) uses ++ Norton's irreducibility test to check for absolute @@ -135017,29 +135745,29 @@ RepresentationPackage2(R): public == private where ++ in a one-dimensional space, the criterium stays true ++ for every extension. The method looks for one-dimensionals only ++ by creating random elements (no fingerprints) since - ++ a run of {\em meatAxe} would have proved absolute irreducibility + ++ a run of meatAxe would have proved absolute irreducibility ++ anyway. isAbsolutelyIrreducible? : L M R -> B ++ isAbsolutelyIrreducible?(aG) calls - ++ {\em isAbsolutelyIrreducible?(aG,25)}. - ++ Note: the choice of 25 was rather arbitrary. + ++ isAbsolutelyIrreducible?(aG,25). + ++ Note that the choice of 25 was rather arbitrary. split : (L M R, V R) -> L L M R ++ split(aG, vector) returns a subalgebra \spad{A} of all ++ square matrix of dimension n as a list of list of matrices, ++ generated by the list of matrices aG, where n denotes both ++ the size of vector as well as the dimension of each of the ++ square matrices. - ++ {\em V R} is an A-module in the natural way. + ++ V R is an A-module in the natural way. ++ split(aG, vector) then checks whether the cyclic submodule - ++ generated by {\em vector} is a proper submodule of {\em V R}. + ++ generated by vector is a proper submodule of V R. ++ If successful, it returns a two-element list, which contains ++ first the list of the representations of the submodule, ++ then the list of the representations of the factor module. ++ If the vector generates the whole module, a one-element list ++ of the old representation is given. - ++ Note: a later version this should call the other split. + ++ Note that a later version this should call the other split. split: (L M R, V V R) -> L L M R - ++ split(aG,submodule) uses a proper submodule of {\em R**n} + ++ split(aG,submodule) uses a proper submodule of R**n ++ to create the representations of the submodule and of ++ the factor module. if (R has Finite) and (R has Field) then @@ -135049,11 +135777,11 @@ RepresentationPackage2(R): public == private where ++ All matrices of argument aG are assumed to be square ++ and of equal size. ++ Then \spad{aG} generates a subalgebra, say \spad{A}, of the algebra - ++ of all square matrices of dimension n. {\em V R} is an A-module + ++ of all square matrices of dimension n. V R is an A-module ++ in the usual way. ++ meatAxe(aG,numberOfTries, maxTests) creates at most - ++ {\em numberOfTries} random elements of the algebra, tests - ++ them for singularity. If singular, it tries at most {\em maxTests} + ++ numberOfTries random elements of the algebra, tests + ++ them for singularity. If singular, it tries at most maxTests ++ elements of its kernel to generate a proper submodule. ++ If successful, a 2-list is returned: first, a list ++ containing first the list of the @@ -135062,16 +135790,16 @@ RepresentationPackage2(R): public == private where ++ Otherwise, if we know that all the kernel is already ++ scanned, Norton's irreducibility test can be used either ++ to prove irreducibility or to find the splitting. - ++ If {\em randomElements} is {\em false}, the first 6 tries + ++ If randomElements is false, the first 6 tries ++ use Parker's fingerprints. meatAxe : L M R -> L L M R - ++ meatAxe(aG) calls {\em meatAxe(aG,false,25,7)} returns + ++ meatAxe(aG) calls meatAxe(aG,false,25,7) returns ++ a 2-list of representations as follows. ++ All matrices of argument \spad{aG} are assumed to be square ++ and of ++ equal size. Then \spad{aG} generates a subalgebra, ++ say \spad{A}, of the algebra - ++ of all square matrices of dimension n. {\em V R} is an A-module + ++ of all square matrices of dimension n. V R is an A-module ++ in the usual way. ++ meatAxe(aG) creates at most 25 random elements ++ of the algebra, tests @@ -135087,27 +135815,27 @@ RepresentationPackage2(R): public == private where ++ Also, 7 covers the case of three-dimensional kernels over ++ the field with 2 elements. meatAxe: (L M R, B) -> L L M R - ++ meatAxe(aG, randomElements) calls {\em meatAxe(aG,false,6,7)}, - ++ only using Parker's fingerprints, if {\em randomElemnts} is false. - ++ If it is true, it calls {\em meatAxe(aG,true,25,7)}, + ++ meatAxe(aG, randomElements) calls meatAxe(aG,false,6,7), + ++ only using Parker's fingerprints, if randomElemnts is false. + ++ If it is true, it calls meatAxe(aG,true,25,7), ++ only using random elements. - ++ Note: the choice of 25 was rather arbitrary. + ++ Note that the choice of 25 was rather arbitrary. ++ Also, 7 covers the case of three-dimensional kernels over the field ++ with 2 elements. meatAxe : (L M R, PI) -> L L M R ++ meatAxe(aG, numberOfTries) calls - ++ {\em meatAxe(aG,true,numberOfTries,7)}. + ++ meatAxe(aG,true,numberOfTries,7). ++ Notes: 7 covers the case of three-dimensional ++ kernels over the field with 2 elements. scanOneDimSubspaces: (L V R, I) -> V R ++ scanOneDimSubspaces(basis,n) gives a canonical representative - ++ of the {\em n}-th one-dimensional subspace of the vector space - ++ generated by the elements of {\em basis}, all from {\em R**n}. + ++ of the n-th one-dimensional subspace of the vector space + ++ generated by the elements of basis, all from R**n. ++ The coefficients of the representative are of shape - ++ {\em (0,...,0,1,*,...,*)}, {\em *} in R. If the size of R - ++ is q, then there are {\em (q**n-1)/(q-1)} of them. + ++ (0,...,0,1,*,...,*), * in R. If the size of R + ++ is q, then there are (q**n-1)/(q-1) of them. ++ We first reduce n modulo this number, then find the - ++ largest i such that {\em +/[q**i for i in 0..i-1] <= n}. + ++ largest i such that +/[q**i for i in 0..i-1] <= n. ++ Subtracting this sum of powers from n results in an ++ i-digit number to basis q. This fills the positions of the ++ stars. @@ -135690,8 +136418,9 @@ RepresentationPackage2(R): public == private where ++ Examples: ++ References: ++ Description: -++ This package provides coercions for the special types \spadtype{Exit} -++ and \spadtype{Void}. +++ This package provides coercions for the special types \spadtype{Exit} +++ and \spadtype{Void}. + ResolveLatticeCompletion(S: Type): with coerce: S -> Void ++ coerce(s) throws all information about s away. @@ -135807,14 +136536,13 @@ RetractSolvePackage(Q, R): Exports == Implementation where <>= )abbrev package SAERFFC SAERationalFunctionAlgFactor -++ Factorisation in UP SAE FRAC POLY INT ++ Author: Patrizia Gianni ++ Date Created: ??? ++ Date Last Updated: ??? +++ Keywords: factorization, algebraic extension, univariate polynomial ++ Description: ++ Factorization of univariate polynomials with coefficients in an ++ algebraic extension of \spadtype{Fraction Polynomial Integer}. -++ Keywords: factorization, algebraic extension, univariate polynomial SAERationalFunctionAlgFactor(UP, SAE, UPA): Exports == Implementation where UP : UnivariatePolynomialCategory Fraction Polynomial Integer @@ -135861,9 +136589,9 @@ SAERationalFunctionAlgFactor(UP, SAE, UPA): Exports == Implementation where ++ IBM Corporation, Publishing Systems Information Development, ++ Dept. G68, P.O. Box 1900, Boulder, Colorado, USA 80301-9191. ++ Description: -++ \spadtype{ScriptFormulaFormat1} provides a utility coercion for -++ changing to SCRIPT formula format anything that has a coercion to -++ the standard output format. +++ \spadtype{ScriptFormulaFormat1} provides a utility coercion for +++ changing to SCRIPT formula format anything that has a coercion to +++ the standard output format. ScriptFormulaFormat1(S : SetCategory): public == private where public == with @@ -135909,8 +136637,9 @@ ScriptFormulaFormat1(S : SetCategory): public == private where ++ Examples: ++ References: ++ Description: -++ This package provides operations for mapping functions onto -++ \spadtype{SegmentBinding}s. +++ This package provides operations for mapping functions onto +++ \spadtype{SegmentBinding}s. + SegmentBindingFunctions2(R:Type, S:Type): with map: (R -> S, SegmentBinding R) -> SegmentBinding S ++ map(f,v=a..b) returns the value given by \spad{v=f(a)..f(b)}. @@ -135946,7 +136675,7 @@ SegmentBindingFunctions2(R:Type, S:Type): with ++ Examples: ++ References: ++ Description: -++ This package provides operations for mapping functions onto segments. +++ This package provides operations for mapping functions onto segments. SegmentFunctions2(R:Type, S:Type): public == private where public ==> with @@ -135998,14 +136727,13 @@ SegmentFunctions2(R:Type, S:Type): public == private where <>= )abbrev package SAEFACT SimpleAlgebraicExtensionAlgFactor -++ Factorisation in a simple algebraic extension; ++ Author: Patrizia Gianni ++ Date Created: ??? ++ Date Last Updated: ??? +++ Keywords: factorization, algebraic extension, univariate polynomial ++ Description: ++ Factorization of univariate polynomials with coefficients in an ++ algebraic extension of the rational numbers (\spadtype{Fraction Integer}). -++ Keywords: factorization, algebraic extension, univariate polynomial SimpleAlgebraicExtensionAlgFactor(UP,SAE,UPA):Exports==Implementation where UP : UnivariatePolynomialCategory Fraction Integer @@ -136039,11 +136767,13 @@ SimpleAlgebraicExtensionAlgFactor(UP,SAE,UPA):Exports==Implementation where <>= )abbrev package SIMPAN SimplifyAlgebraicNumberConvertPackage +++ Description: ++ Package to allow simplify to be called on AlgebraicNumbers ++ by converting to EXPR(INT) + SimplifyAlgebraicNumberConvertPackage(): with simplify: AlgebraicNumber -> Expression(Integer) - ++ simplify(an) applies simplifications to an + ++ simplify(an) applies simplifications to an == add simplify(a:AlgebraicNumber) == simplify(a::Expression(Integer))$TranscendentalManipulations(Integer, Expression Integer) @@ -136082,8 +136812,8 @@ SimplifyAlgebraicNumberConvertPackage(): with ++ Examples: ++ References: ++ Description: -++ \spadtype{SmithNormalForm} is a package -++ which provides some standard canonical forms for matrices. +++ \spadtype{SmithNormalForm} is a package +++ which provides some standard canonical forms for matrices. SmithNormalForm(R,Row,Col,M) : Exports == Implementation where @@ -136318,15 +137048,16 @@ SmithNormalForm(R,Row,Col,M) : Exports == Implementation where <>= )abbrev package SCACHE SortedCache -++ Cache of elements in a set ++ Author: Manuel Bronstein ++ Date Created: 31 Oct 1988 ++ Date Last Updated: 14 May 1991 -++ A sorted cache of a cachable set S is a dynamic structure that -++ keeps the elements of S sorted and assigns an integer to each -++ element of S once it is in the cache. This way, equality and ordering -++ on S are tested directly on the integers associated with the elements -++ of S, once they have been entered in the cache. +++ Description: +++ A sorted cache of a cachable set S is a dynamic structure that +++ keeps the elements of S sorted and assigns an integer to each +++ element of S once it is in the cache. This way, equality and ordering +++ on S are tested directly on the integers associated with the elements +++ of S, once they have been entered in the cache. + SortedCache(S:CachableSet): Exports == Implementation where N ==> NonNegativeInteger DIFF ==> 1024 @@ -136416,6 +137147,7 @@ SortedCache(S:CachableSet): Exports == Implementation where )abbrev package SORTPAK SortPackage ++ Description: ++ This package exports sorting algorithnms + SortPackage(S,A) : Exports == Implementation where S: Type A: IndexedAggregate(Integer,S) @@ -136423,14 +137155,14 @@ SortPackage(S,A) : Exports == Implementation where Exports == with bubbleSort_!: (A,(S,S) -> Boolean) -> A - ++ bubbleSort!(a,f) \undocumented + ++ bubbleSort!(a,f) \undocumented insertionSort_!: (A, (S,S) -> Boolean) -> A - ++ insertionSort!(a,f) \undocumented + ++ insertionSort!(a,f) \undocumented if S has OrderedSet then bubbleSort_!: A -> A - ++ bubbleSort!(a) \undocumented + ++ bubbleSort!(a) \undocumented insertionSort_!: A -> A - ++ insertionSort! \undocumented + ++ insertionSort! \undocumented Implementation == add bubbleSort_!(m,f) == @@ -136539,8 +137271,9 @@ SparseUnivariatePolynomialFunctions2(R:Ring, S:Ring): with ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: SpecialOutputPackage allows FORTRAN, Tex and -++ Script Formula Formatter output from programs. +++ Description: +++ SpecialOutputPackage allows FORTRAN, Tex and +++ Script Formula Formatter output from programs. SpecialOutputPackage: public == private where public == with @@ -136653,10 +137386,6 @@ SpecialOutputPackage: public == private where ++ Also See: ++ AMS Classifications: ++ Keywords: -++ Description: -++ A internal package for removing redundant quasi-components and redundant -++ branches when decomposing a variety by means of quasi-components -++ of regular triangular sets. \newline ++ References : ++ [1] D. LAZARD "A new method for solving algebraic systems of ++ positive dimension" Discr. App. Math. 33:147-160,1991 @@ -136666,7 +137395,10 @@ SpecialOutputPackage: public == private where ++ algebriques" These, Universite P.etM. Curie, Paris, 1997. ++ [3] M. MORENO MAZA "A new algorithm for computing triangular ++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. -++ Version: 1. +++ Description: +++ A internal package for removing redundant quasi-components and redundant +++ branches when decomposing a variety by means of quasi-components +++ of regular triangular sets. SquareFreeQuasiComponentPackage(R,E,V,P,TS): Exports == Implementation where @@ -136707,7 +137439,7 @@ SquareFreeQuasiComponentPackage(R,E,V,P,TS): Exports == Implementation where ++ has higher rank than \axiom{us} w.r.t. Riit and Wu ordering. algebraicSort: Split -> Split ++ \axiom{algebraicSort(lts)} sorts \axiom{lts} w.r.t - ++ \axiomOpFrom{supDimElseRittWu}{QuasiComponentPackage}. + ++ supDimElseRittWu from QuasiComponentPackage. moreAlgebraic?: (TS,TS) -> Boolean ++ \axiom{moreAlgebraic?(ts,us)} returns false iff \axiom{ts} ++ and \axiom{us} are both empty, or \axiom{ts} @@ -136723,7 +137455,7 @@ SquareFreeQuasiComponentPackage(R,E,V,P,TS): Exports == Implementation where ++ \axiom{internalSubPolSet?(lp1,lp2)} returns true iff \axiom{lp1} is ++ a sub-set of \axiom{lp2} assuming that these lists are sorted ++ increasingly w.r.t. - ++ \axiomOpFrom{infRittWu?}{RecursivePolynomialCategory}. + ++ infRittWu? from RecursivePolynomialCategory. internalInfRittWu?: (LP, LP) -> Boolean ++ \axiom{internalInfRittWu?(lp1,lp2)} ++ is an internal subroutine, exported only for developement. @@ -136737,7 +137469,7 @@ SquareFreeQuasiComponentPackage(R,E,V,P,TS): Exports == Implementation where ++ \axiom{b} gives this inclusion) otherwise returns \axiom{"failed"}. subQuasiComponent?: (TS,TS) -> Boolean ++ \axiom{subQuasiComponent?(ts,us)} returns true iff - ++ \axiomOpFrom{internalSubQuasiComponent?(ts,us)}{QuasiComponentPackage} + ++ internalSubQuasiComponent?(ts,us) from QuasiComponentPackage ++ returns true. subQuasiComponent?: (TS,Split) -> Boolean ++ \axiom{subQuasiComponent?(ts,lus)} returns true iff @@ -137078,6 +137810,9 @@ SquareFreeQuasiComponentPackage(R,E,V,P,TS): Exports == Implementation where ++ Also See: ++ AMS Classifications: ++ Keywords: +++ References : +++ [1] M. MORENO MAZA "A new algorithm for computing triangular +++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. ++ Description: ++ A package providing a new algorithm for solving polynomial systems ++ by means of regular chains. Two ways of solving are provided: @@ -137096,11 +137831,7 @@ SquareFreeQuasiComponentPackage(R,E,V,P,TS): Exports == Implementation where ++ gcds need to have invertible initials (normalized or not). ++ WARNING. There is no need for a user to call diectly any operation ++ of this package since they can be accessed by the domain \axiomType{TS}. -++ Thus, the operations of this package are not documented.\newline -++ References : -++ [1] M. MORENO MAZA "A new algorithm for computing triangular -++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. -++ Version: 2. Does not use any unproved criteria. +++ Thus, the operations of this package are not documented. SquareFreeRegularSetDecompositionPackage(R,E,V,P,TS): Exports == Implementation where @@ -137384,11 +138115,6 @@ SquareFreeRegularSetDecompositionPackage(R,E,V,P,TS): Exports == Implementation ++ Also See: ++ AMS Classifications: ++ Keywords: -++ Description: -++ A internal package for computing gcds and resultants of univariate polynomials -++ with coefficients in a tower of simple extensions of a field. -++ There is no need to use directly this package since its main operations are -++ available from \spad{TS}. \newline ++ References : ++ [1] M. MORENO MAZA and R. RIOBOO "Computations of gcd over ++ algebraic towers of simple extensions" In proceedings of AAECC11 @@ -137398,7 +138124,11 @@ SquareFreeRegularSetDecompositionPackage(R,E,V,P,TS): Exports == Implementation ++ algebriques" These, Universite P.etM. Curie, Paris, 1997. ++ [3] M. MORENO MAZA "A new algorithm for computing triangular ++ decomposition of algebraic varieties" NAG Tech. Rep. 4/98. -++ Version: 1. +++ Description: +++ A internal package for computing gcds and resultants of univariate +++ polynomials with coefficients in a tower of simple extensions of a field. +++ There is no need to use directly this package since its main operations are +++ available from \spad{TS}. SquareFreeRegularTriangularSetGcdPackage(R,E,V,P,TS): Exports == Implementation where @@ -137859,11 +138589,12 @@ SquareFreeRegularTriangularSetGcdPackage(R,E,V,P,TS): Exports == Implementation ++ Examples: ++ References: ++ Description: -++ This package provides standard arithmetic operations on matrices. -++ The functions in this package store the results of computations -++ in existing matrices, rather than creating new matrices. This -++ package works only for matrices of type Matrix and uses the -++ internal representation of this type. +++ This package provides standard arithmetic operations on matrices. +++ The functions in this package store the results of computations +++ in existing matrices, rather than creating new matrices. This +++ package works only for matrices of type Matrix and uses the +++ internal representation of this type. + StorageEfficientMatrixOperations(R): Exports == Implementation where R : Ring M ==> Matrix R @@ -138057,14 +138788,16 @@ StorageEfficientMatrixOperations(R): Exports == Implementation where ++ Date Created: July 1986 ++ Date Last Updated: 29 January 1990 ++ Keywords: stream, infinite list, infinite sequence +++ Description: +++ Functions defined on streams with entries in one set. + StreamFunctions1(S:Type): Exports == Implementation where - ++ Functions defined on streams with entries in one set. ST ==> Stream Exports ==> with concat: ST ST S -> ST S ++ concat(u) returns the left-to-right concatentation of the - ++ streams in u. Note: \spad{concat(u) = reduce(concat,u)}. + ++ streams in u. Note that \spad{concat(u) = reduce(concat,u)}. ++ ++X m:=[i for i in 10..] ++X n:=[j for j in 1.. | prime? j] @@ -138103,15 +138836,17 @@ StreamFunctions1(S:Type): Exports == Implementation where ++ Date Created: July 1986 ++ Date Last Updated: 29 January 1990 ++ Keywords: stream, infinite list, infinite sequence +++ Description: +++ Functions defined on streams with entries in two sets. + StreamFunctions2(A:Type,B:Type): Exports == Implementation where - ++ Functions defined on streams with entries in two sets. ST ==> Stream Exports ==> with map: ((A -> B),ST A) -> ST B ++ map(f,s) returns a stream whose elements are the function f applied ++ to the corresponding elements of s. - ++ Note: \spad{map(f,[x0,x1,x2,...]) = [f(x0),f(x1),f(x2),..]}. + ++ Note that \spad{map(f,[x0,x1,x2,...]) = [f(x0),f(x1),f(x2),..]}. ++ ++X m:=[i for i in 1..] ++X f(i:PositiveInteger):PositiveInteger==i**2 @@ -138190,8 +138925,10 @@ StreamFunctions2(A:Type,B:Type): Exports == Implementation where ++ Date Created: July 1986 ++ Date Last Updated: 29 January 1990 ++ Keywords: stream, infinite list, infinite sequence +++ Description: +++ Functions defined on streams with entries in three sets. + StreamFunctions3(A,B,C): Exports == Implementation where - ++ Functions defined on streams with entries in three sets. A : Type B : Type C : Type @@ -138257,9 +138994,10 @@ StreamFunctions3(A,B,C): Exports == Implementation where ++ Examples: ++ References: ++ Description: -++ This package computes infinite products of Taylor series over an -++ integral domain of characteristic 0. Here Taylor series are -++ represented by streams of Taylor coefficients. +++ This package computes infinite products of Taylor series over an +++ integral domain of characteristic 0. Here Taylor series are +++ represented by streams of Taylor coefficients. + StreamInfiniteProduct(Coef): Exports == Implementation where Coef: Join(IntegralDomain,CharacteristicZero) I ==> Integer @@ -138383,8 +139121,9 @@ just take the definition there. ++ Examples: ++ References: ++ Description: -++ StreamTaylorSeriesOperations implements Taylor series arithmetic, -++ where a Taylor series is represented by a stream of its coefficients. +++ StreamTaylorSeriesOperations implements Taylor series arithmetic, +++ where a Taylor series is represented by a stream of its coefficients. + StreamTaylorSeriesOperations(A): Exports == Implementation where A : Ring RN ==> Fraction Integer @@ -138865,9 +139604,10 @@ StreamTaylorSeriesOperations(A): Exports == Implementation where ++ Examples: ++ References: ++ Description: -++ StreamTranscendentalFunctions implements transcendental functions on -++ Taylor series, where a Taylor series is represented by a stream of -++ its coefficients. +++ StreamTranscendentalFunctions implements transcendental functions on +++ Taylor series, where a Taylor series is represented by a stream of +++ its coefficients. + StreamTranscendentalFunctions(Coef): Exports == Implementation where Coef : Algebra Fraction Integer L ==> List @@ -139343,9 +140083,10 @@ StreamTranscendentalFunctions(Coef): Exports == Implementation where ++ Examples: ++ References: ++ Description: -++ StreamTranscendentalFunctionsNonCommutative implements transcendental -++ functions on Taylor series over a non-commutative ring, where a Taylor -++ series is represented by a stream of its coefficients. +++ StreamTranscendentalFunctionsNonCommutative implements transcendental +++ functions on Taylor series over a non-commutative ring, where a Taylor +++ series is represented by a stream of its coefficients. + StreamTranscendentalFunctionsNonCommutative(Coef): _ Exports == Implementation where Coef : Algebra Fraction Integer @@ -139596,9 +140337,10 @@ StreamTranscendentalFunctionsNonCommutative(Coef): _ ++ Keywords: structural constants ++ Reference: ++ Description: -++ StructuralConstantsPackage provides functions creating -++ structural constants from a multiplication tables or a basis -++ of a matrix algebra and other useful functions in this context. +++ StructuralConstantsPackage provides functions creating +++ structural constants from a multiplication tables or a basis +++ of a matrix algebra and other useful functions in this context. + StructuralConstantsPackage(R:Field): public == private where L ==> List @@ -139755,9 +140497,9 @@ must be linear polynomials in the generators" ++ Keywords: localization ++ References: ++ Description: -++ This package produces functions for counting -++ etc. real roots of univariate polynomials in x over R, which must -++ be an OrderedIntegralDomain +++ This package produces functions for counting etc. real roots of univariate +++ polynomials in x over R, which must be an OrderedIntegralDomain + SturmHabichtPackage(R,x): T == C where R: OrderedIntegralDomain x: Symbol @@ -140128,7 +140870,6 @@ SturmHabichtPackage(R,x): T == C where <>= )abbrev package SUBRESP SubResultantPackage -++ Subresultants ++ Author: Barry Trager, Renaud Rioboo ++ Date Created: 1987 ++ Date Last Updated: August 2000 @@ -140137,7 +140878,7 @@ SturmHabichtPackage(R,x): T == C where ++ for the `Lazard Rioboo' enhancement to Tragers integrations formula ++ For efficiency reasons this has been rewritten to call Lionel Ducos ++ package which is currently the best one. -++ + SubResultantPackage(R, UP): Exports == Implementation where R : IntegralDomain UP: UnivariatePolynomialCategory R @@ -140285,8 +141026,8 @@ SubResultantPackage(R, UP): Exports == Implementation where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: SupFractionFactorize -++ contains the factor function for univariate +++ Description: +++ SupFractionFactorize contains the factor function for univariate ++ polynomials over the quotient field of a ring S such that the package ++ MultivariateFactorize works for S @@ -140363,9 +141104,11 @@ SupFractionFactorizer(E,OV,R,P) : C == T ++ Author: Manuel Bronstein ++ Date Created: 11 June 1991 ++ Date Last Updated: 13 April 1994 -++ Description: SystemODESolver provides tools for triangulating -++ and solving some systems of linear ordinary differential equations. ++ Keywords: differential equation, ODE, system +++ Description: +++ SystemODESolver provides tools for triangulating +++ and solving some systems of linear ordinary differential equations. + SystemODESolver(F, LO): Exports == Implementation where F : Field LO: LinearOrdinaryDifferentialOperatorCategory F @@ -140638,18 +141381,18 @@ SystemODESolver(F, LO): Exports == Implementation where ++ or omit the list of symbols in which case the system tries to ++ solve with respect to all symbols appearing in the input. -NNI ==> NonNegativeInteger -P ==> Polynomial -EQ ==> Equation -L ==> List -V ==> Vector -M ==> Matrix -UP ==> SparseUnivariatePolynomial -SE ==> Symbol -IE ==> IndexedExponents Symbol -SUP ==> SparseUnivariatePolynomial SystemSolvePackage(R): Cat == Cap where + NNI ==> NonNegativeInteger + P ==> Polynomial + EQ ==> Equation + L ==> List + V ==> Vector + M ==> Matrix + UP ==> SparseUnivariatePolynomial + SE ==> Symbol + IE ==> IndexedExponents Symbol + SUP ==> SparseUnivariatePolynomial R : IntegralDomain F ==> Fraction Polynomial R PP2 ==> PolynomialFunctions2(R,F) @@ -140902,10 +141645,10 @@ SystemSolvePackage(R): Cat == Cap where ++ their Realization in the Computer Algebra System Scratchpad, ++ Bayreuther Mathematische Schriften, Heft 33, 1990, 1-23. ++ Description: -++ SymmetricGroupCombinatoricFunctions contains combinatoric -++ functions concerning symmetric groups and representation -++ theory: list young tableaus, improper partitions, subsets -++ bijection of Coleman. +++ SymmetricGroupCombinatoricFunctions contains combinatoric +++ functions concerning symmetric groups and representation +++ theory: list young tableaus, improper partitions, subsets +++ bijection of Coleman. SymmetricGroupCombinatoricFunctions(): public == private where @@ -140927,110 +141670,109 @@ SymmetricGroupCombinatoricFunctions(): public == private where coleman : (L I, L I, L I) -> M I ++ coleman(alpha,beta,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 pi} of such a double coset, + ++ entries and row sums alpha, column sums beta + ++ to the set of Salpha - Sbeta double cosets of the + ++ symmetric group Sn. (Salpha is the Young subgroup + ++ corresponding to the improper partition alpha). + ++ For a representing element pi of such a double coset, ++ coleman(alpha,beta,pi) generates the Coleman-matrix - ++ corresponding to {\em alpha, beta, pi}. - ++ Note: The permutation {\em pi} of {\em {1,2,...,n}} has to be given + ++ corresponding to alpha, beta, pi. + ++ Note that The permutation pi of {1,2,...,n} has to be given ++ in list form. - ++ Note: the inverse of this map is {\em inverseColeman} - ++ (if {\em pi} is the lexicographical smallest permutation + ++ Note that the inverse of this map is inverseColeman + ++ (if pi is the lexicographical smallest permutation ++ in the coset). For details see James/Kerber. inverseColeman : (L I, L I, M I) -> L I ++ inverseColeman(alpha,beta,C): ++ there is a bijection from the set of matrices having nonnegative - ++ entries and row sums {\em alpha}, column sums {\em beta} - ++ to the set of {\em Salpha - Sbeta} double cosets of the - ++ symmetric group {\em Sn}. ({\em Salpha} is the Young subgroup - ++ corresponding to the improper partition {\em alpha}). + ++ entries and row sums alpha, column sums beta + ++ to the set of Salpha - Sbeta double cosets of the + ++ symmetric group Sn. (Salpha is the Young subgroup + ++ corresponding to the improper partition alpha). ++ For such a matrix C, inverseColeman(alpha,beta,C) - ++ calculates the lexicographical smallest {\em pi} in the + ++ calculates the lexicographical smallest pi in the ++ corresponding double coset. - ++ Note: the resulting permutation {\em pi} of {\em {1,2,...,n}} + ++ Note that the resulting permutation pi of {1,2,...,n} ++ is given in list form. - ++ Notes: the inverse of this map is {\em coleman}. + ++ Notes: the inverse of this map is coleman. ++ For details, see James/Kerber. listYoungTableaus : (L I) -> L M I - ++ listYoungTableaus(lambda) where {\em lambda} is a proper partition - ++ generates the list of all standard tableaus of shape {\em lambda} + ++ listYoungTableaus(lambda) where lambda is a proper partition + ++ generates the list of all standard tableaus of shape lambda ++ by means of lattice permutations. The numbers of the lattice ++ permutation are interpreted as column labels. Hence the ++ contents of these lattice permutations are the conjugate of - ++ {\em lambda}. - ++ Notes: the functions {\em nextLatticePermutation} and - ++ {\em makeYoungTableau} are used. - ++ The entries are from {\em 0,...,n-1}. + ++ lambda. + ++ Notes: the functions nextLatticePermutation and + ++ makeYoungTableau are used. + ++ The entries are from 0,...,n-1. makeYoungTableau : (L I,L I) -> M I ++ makeYoungTableau(lambda,gitter) computes for a given lattice - ++ permutation {\em gitter} and for an improper partition {\em lambda} - ++ the corresponding standard tableau of shape {\em lambda}. - ++ Notes: see {\em listYoungTableaus}. - ++ The entries are from {\em 0,...,n-1}. + ++ permutation gitter and for an improper partition lambda + ++ the corresponding standard tableau of shape lambda. + ++ Notes: see listYoungTableaus. + ++ The entries are from 0,...,n-1. nextColeman : (L I, L I, M I) -> M I ++ nextColeman(alpha,beta,C) generates the next Coleman matrix - ++ of column sums {\em alpha} and row sums {\em beta} according + ++ of column sums alpha and row sums beta according ++ to the lexicographical order from bottom-to-top. - ++ The first Coleman matrix is achieved by {\em C=new(1,1,0)}. - ++ Also, {\em new(1,1,0)} indicates that C is the last Coleman matrix. + ++ The first Coleman matrix is achieved by C=new(1,1,0). + ++ Also, new(1,1,0) indicates that C is the last Coleman matrix. nextLatticePermutation : (L I, L I, B) -> L I ++ nextLatticePermutation(lambda,lattP,constructNotFirst) generates ++ the lattice permutation according to the proper partition - ++ {\em lambda} succeeding the lattice permutation {\em lattP} in - ++ lexicographical order as long as {\em constructNotFirst} is true. - ++ If {\em constructNotFirst} is false, the first lattice permutation + ++ lambda succeeding the lattice permutation lattP in + ++ lexicographical order as long as constructNotFirst is true. + ++ If constructNotFirst is false, the first lattice permutation ++ is returned. - ++ The result {\em nil} indicates that {\em lattP} has no successor. + ++ The result nil indicates that lattP has no successor. nextPartition : (V I, V I, I) -> V I ++ nextPartition(gamma,part,number) generates the partition of - ++ {\em number} which follows {\em part} according to the right-to-left + ++ number which follows part according to the right-to-left ++ lexicographical order. The partition has the property that ++ its components do not exceed the corresponding components of - ++ {\em gamma}. The first partition is achieved by {\em part=[]}. - ++ Also, {\em []} indicates that {\em part} is the last partition. + ++ gamma. The first partition is achieved by part=[]. + ++ Also, [] indicates that part is the last partition. nextPartition : (L I, V I, I) -> V I ++ nextPartition(gamma,part,number) generates the partition of - ++ {\em number} which follows {\em part} according to the right-to-left + ++ number which follows part according to the right-to-left ++ lexicographical order. The partition has the property that ++ its components do not exceed the corresponding components of - ++ {\em gamma}. the first partition is achieved by {\em part=[]}. - ++ Also, {\em []} indicates that {\em part} is the last partition. + ++ gamma. the first partition is achieved by part=[]. + ++ Also, [] indicates that part is the last partition. numberOfImproperPartitions: (I,I) -> I ++ numberOfImproperPartitions(n,m) computes the number of partitions ++ of the nonnegative integer n in m nonnegative parts with regarding ++ the order (improper partitions). - ++ Example: {\em numberOfImproperPartitions (3,3)} is 10, - ++ since {\em [0,0,3], [0,1,2], [0,2,1], [0,3,0], [1,0,2], [1,1,1], - ++ [1,2,0], [2,0,1], [2,1,0], [3,0,0]} are the possibilities. - ++ Note: this operation has a recursive implementation. + ++ Example: numberOfImproperPartitions (3,3) is 10, + ++ since [0,0,3], [0,1,2], [0,2,1], [0,3,0], [1,0,2], [1,1,1], + ++ [1,2,0], [2,0,1], [2,1,0], [3,0,0] are the possibilities. + ++ Note that this operation has a recursive implementation. subSet : (I,I,I) -> L I - ++ subSet(n,m,k) calculates the {\em k}-th {\em m}-subset of the set - ++ {\em 0,1,...,(n-1)} in the lexicographic order considered as - ++ a decreasing map from {\em 0,...,(m-1)} into {\em 0,...,(n-1)}. + ++ subSet(n,m,k) calculates the k-th m-subset of the set + ++ 0,1,...,(n-1) in the lexicographic order considered as + ++ a decreasing map from 0,...,(m-1) into 0,...,(n-1). ++ See S.G. Williamson: Theorem 1.60. - ++ Error: if not {\em (0 <= m <= n and 0 < = k < (n choose m))}. + ++ Error: if not (0 <= m <= n and 0 < = k < (n choose m)). unrankImproperPartitions0 : (I,I,I) -> L I - ++ unrankImproperPartitions0(n,m,k) computes the {\em k}-th improper + ++ unrankImproperPartitions0(n,m,k) computes the k-th improper ++ partition of nonnegative n in m nonnegative parts in reverse ++ lexicographical order. - ++ Example: {\em [0,0,3] < [0,1,2] < [0,2,1] < [0,3,0] < - ++ [1,0,2] < [1,1,1] < [1,2,0] < [2,0,1] < [2,1,0] < [3,0,0]}. + ++ Example: [0,0,3] < [0,1,2] < [0,2,1] < [0,3,0] < + ++ [1,0,2] < [1,1,1] < [1,2,0] < [2,0,1] < [2,1,0] < [3,0,0]. ++ Error: if k is negative or too big. - ++ Note: counting of subtrees is done by - ++ \spadfunFrom{numberOfImproperPartitions}{SymmetricGroupCombinatoricFunctions}. - + ++ Note that counting of subtrees is done by + ++ numberOfImproperPartitions unrankImproperPartitions1: (I,I,I) -> L I - ++ unrankImproperPartitions1(n,m,k) computes the {\em k}-th improper + ++ unrankImproperPartitions1(n,m,k) computes the k-th improper ++ partition of nonnegative n in at most m nonnegative parts ++ ordered as follows: first, in reverse ++ lexicographically according to their non-zero parts, then ++ according to their positions (i.e. lexicographical order - ++ using {\em subSet}: {\em [3,0,0] < [0,3,0] < [0,0,3] < [2,1,0] < - ++ [2,0,1] < [0,2,1] < [1,2,0] < [1,0,2] < [0,1,2] < [1,1,1]}). - ++ Note: counting of subtrees is done by - ++ {\em numberOfImproperPartitionsInternal}. + ++ using subSet: [3,0,0] < [0,3,0] < [0,0,3] < [2,1,0] < + ++ [2,0,1] < [0,2,1] < [1,2,0] < [1,0,2] < [0,1,2] < [1,1,1]. + ++ Note that counting of subtrees is done by + ++ numberOfImproperPartitionsInternal. private == add @@ -141365,11 +142107,12 @@ SymmetricGroupCombinatoricFunctions(): public == private where <>= )abbrev package SYMFUNC SymmetricFunctions -++ The elementary symmetric functions ++ Author: Manuel Bronstein ++ Date Created: 13 Feb 1989 ++ Date Last Updated: 28 Jun 1990 -++ Description: Computes all the symmetric functions in n variables. +++ Description: +++ Computes all the symmetric functions in n variables. + SymmetricFunctions(R:Ring): Exports == Implementation where UP ==> SparseUnivariatePolynomial R @@ -141443,6 +142186,7 @@ SymmetricFunctions(R:Ring): Exports == Implementation where ++ correspondence between sequences and pairs of Young tableaux. ++ The 2 Young tableaux are represented as a single tableau with ++ pairs as components. + TableauxBumpers(S:OrderedSet):T==C where L==>List ST==>Stream @@ -141475,13 +142219,12 @@ TableauxBumpers(S:OrderedSet):T==C where ++ tab1(lp) creates a tableau from a list of pairs lp tab:L S->Tableau(L S) ++ tab(ls) creates a tableau from ls by first creating - ++ a list of pairs using \spadfunFrom{slex}{TableauBumpers}, - ++ then creating a tableau using \spadfunFrom{tab1}{TableauBumpers}. + ++ a list of pairs using slex, + ++ then creating a tableau using tab1. lex:L PAIR->L PAIR ++ lex(ls) sorts a list of pairs to lexicographic order slex:L S->L PAIR - ++ slex(ls) sorts the argument sequence ls, then - ++ zips (see \spadfunFrom{map}{ListFunctions3}) the + ++ slex(ls) sorts the argument sequence ls, then zips (see map) the ++ original argument sequence with the sorted result to ++ a list of pairs inverse:L S->L S @@ -141593,12 +142336,11 @@ TableauxBumpers(S:OrderedSet):T==C where ++ References: ++ Description: ++ \axiom{TabulatedComputationPackage(Key ,Entry)} provides some modest support -++ for dealing with operations with type \axiom{Key -> Entry}. The result of -++ such operations can be stored and retrieved with this package by using -++ a hash-table. The user does not need to worry about the management of -++ this hash-table. However, onnly one hash-table is built by calling -++ \axiom{TabulatedComputationPackage(Key ,Entry)}. -++ Version: 2. +++ for dealing with operations with type \axiom{Key -> Entry}. The result of +++ such operations can be stored and retrieved with this package by using +++ a hash-table. The user does not need to worry about the management of +++ this hash-table. However, onnly one hash-table is built by calling +++ \axiom{TabulatedComputationPackage(Key ,Entry)}. TabulatedComputationPackage(Key ,Entry): Exports == Implementation where Key: SetCategory @@ -141725,11 +142467,12 @@ TabulatedComputationPackage(Key ,Entry): Exports == Implementation where <>= )abbrev package TANEXP TangentExpansions -++ Expansions of tangents of sums and quotients ++ Author: Manuel Bronstein ++ Date Created: 13 Feb 1989 ++ Date Last Updated: 20 Apr 1990 -++ Description: Expands tangents of sums and scalar products. +++ Description: +++ Expands tangents of sums and scalar products. + TangentExpansions(R:Field): Exports == Implementation where PI ==> PositiveInteger Z ==> Integer @@ -141819,6 +142562,9 @@ It uses the method of undetermined coefficients. <>= )abbrev package UTSSOL TaylorSolve +++ Description: +++ This package has no description + TaylorSolve(F, UTSF, UTSSUPF): Exports == Implementation where F: Field SUP ==> SparseUnivariatePolynomialExpressions @@ -141966,7 +142712,9 @@ should be unique. ++ Keywords: ++ Examples: ++ References: -++ Description: This package provides functions for template manipulation +++ Description: +++ This package provides functions for template manipulation + TemplateUtilities(): Exports == Implementation where Exports == with @@ -142020,12 +142768,9 @@ TemplateUtilities(): Exports == Implementation where ++ Also See: ScriptFormulaFormat, ScriptFormulaFormat1 ++ AMS Classifications: ++ Keywords: TeX, output, format -++ References: \TeX{} is a trademark of the American Mathematical -++ Society. ++ Description: -++ \spadtype{TexFormat1} provides a utility coercion for changing -++ to TeX format anything that has a coercion to the standard output -++ format. +++ \spadtype{TexFormat1} provides a utility coercion for changing +++ to TeX format anything that has a coercion to the standard output format. TexFormat1(S : SetCategory): public == private where public == with @@ -142064,18 +142809,19 @@ TexFormat1(S : SetCategory): public == private where <>= )abbrev package TOOLSIGN ToolsForSign -++ Tools for the sign finding utilities ++ Author: Manuel Bronstein ++ Date Created: 25 August 1989 ++ Date Last Updated: 26 November 1991 -++ Description: Tools for the sign finding utilities. +++ Description: +++ Tools for the sign finding utilities. + ToolsForSign(R:Ring): with sign : R -> Union(Integer, "failed") - ++ sign(r) \undocumented + ++ sign(r) \undocumented nonQsign : R -> Union(Integer, "failed") - ++ nonQsign(r) \undocumented + ++ nonQsign(r) \undocumented direction: String -> Integer - ++ direction(s) \undocumented + ++ direction(s) \undocumented == add if R is AlgebraicNumber then @@ -142140,8 +142886,10 @@ ToolsForSign(R:Ring): with ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: TopLevelDrawFunctions provides top level functions for +++ Description: +++ TopLevelDrawFunctions provides top level functions for ++ drawing graphics of expressions. + TopLevelDrawFunctions(Ex:Join(ConvertibleTo InputForm,SetCategory)): Exports == Implementation where B ==> Boolean @@ -142480,7 +143228,8 @@ TopLevelDrawFunctions(Ex:Join(ConvertibleTo InputForm,SetCategory)): ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: TopLevelDrawFunctionsForAlgebraicCurves provides top level +++ Description: +++ TopLevelDrawFunctionsForAlgebraicCurves provides top level ++ functions for drawing non-singular algebraic curves. TopLevelDrawFunctionsForAlgebraicCurves(R,Ex): Exports == Implementation where @@ -142620,8 +143369,10 @@ TopLevelDrawFunctionsForAlgebraicCurves(R,Ex): Exports == Implementation where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: TopLevelDrawFunctionsForCompiledFunctions provides top level +++ Description: +++ TopLevelDrawFunctionsForCompiledFunctions provides top level ++ functions for drawing graphics of expressions. + TopLevelDrawFunctionsForCompiledFunctions(): Exports == Implementation where ANY1 ==> AnyFunctions1 @@ -143272,7 +144023,8 @@ SingleFloat value. ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: TopLevelDrawFunctionsForPoints provides top level functions +++ Description: +++ TopLevelDrawFunctionsForPoints provides top level functions ++ for drawing curves and surfaces described by sets of points. TopLevelDrawFunctionsForPoints(): Exports == Implementation where @@ -143365,6 +144117,7 @@ TopLevelDrawFunctionsForPoints(): Exports == Implementation where )abbrev package TOPSP TopLevelThreeSpace ++ Description: ++ This package exports a function for making a \spadtype{ThreeSpace} + TopLevelThreeSpace(): with createThreeSpace: () -> ThreeSpace DoubleFloat ++ createThreeSpace() creates a \spadtype{ThreeSpace(DoubleFloat)} object @@ -143391,11 +144144,12 @@ TopLevelThreeSpace(): with <>= )abbrev package INTHERTR TranscendentalHermiteIntegration -++ Hermite integration, transcendental case ++ Author: Manuel Bronstein ++ Date Created: 1987 ++ Date Last Updated: 12 August 1992 -++ Description: Hermite integration, transcendental case. +++ Description: +++ Hermite integration, transcendental case. + TranscendentalHermiteIntegration(F, UP): Exports == Implementation where F : Field UP : UnivariatePolynomialCategory F @@ -143481,14 +144235,14 @@ TranscendentalHermiteIntegration(F, UP): Exports == Implementation where <>= )abbrev package INTTR TranscendentalIntegration -++ Risch algorithm, transcendental case ++ Author: Manuel Bronstein ++ Date Created: 1987 ++ Date Last Updated: 24 October 1995 ++ Description: -++ This package provides functions for the transcendental -++ case of the Risch algorithm. +++ This package provides functions for the transcendental +++ case of the Risch algorithm. -- Internally used by the integrator + TranscendentalIntegration(F, UP): Exports == Implementation where F : Field UP : UnivariatePolynomialCategory F @@ -143975,14 +144729,14 @@ TranscendentalIntegration(F, UP): Exports == Implementation where <>= )abbrev package TRMANIP TranscendentalManipulations -++ Transformations on transcendental objects ++ Author: Bob Sutor, Manuel Bronstein ++ Date Created: Way back ++ Date Last Updated: 22 January 1996, added simplifyLog MCD. -++ Description: -++ TranscendentalManipulations provides functions to simplify and -++ expand expressions involving transcendental operators. ++ Keywords: transcendental, manipulation. +++ Description: +++ TranscendentalManipulations provides functions to simplify and +++ expand expressions involving transcendental operators. + TranscendentalManipulations(R, F): Exports == Implementation where R : Join(OrderedSet, GcdDomain) F : Join(FunctionSpace R, TranscendentalFunctionCategory) @@ -144414,10 +145168,12 @@ TranscendentalManipulations(R, F): Exports == Implementation where <>= )abbrev package RDETR TranscendentalRischDE -++ Risch differential equation, transcendental case. ++ Author: Manuel Bronstein ++ Date Created: Jan 1988 ++ Date Last Updated: 2 November 1995 +++ Description: +++ Risch differential equation, transcendental case. + TranscendentalRischDE(F, UP): Exports == Implementation where F : Join(Field, CharacteristicZero, RetractableTo Integer) UP : UnivariatePolynomialCategory F @@ -144597,10 +145353,12 @@ TranscendentalRischDE(F, UP): Exports == Implementation where <>= )abbrev package RDETRS TranscendentalRischDESystem -++ Risch differential equation system, transcendental case. ++ Author: Manuel Bronstein ++ Date Created: 17 August 1992 ++ Date Last Updated: 3 February 1994 +++ Description: +++ Risch differential equation system, transcendental case. + TranscendentalRischDESystem(F, UP): Exports == Implementation where F : Join(Field, CharacteristicZero, RetractableTo Integer) UP : UnivariatePolynomialCategory F @@ -145097,21 +145855,20 @@ o )show TransSolvePackage ++ Related Constructors: RadicalSolvePackage, FloatingRealPackage ++ Keywords: ++ Description: -++ This package tries to find solutions of equations of type Expression(R). -++ This means expressions involving transcendental, exponential, logarithmic -++ and nthRoot functions. -++ After trying to transform different kernels to one kernel by applying -++ several rules, it calls zerosOf for the SparseUnivariatePolynomial in -++ the remaining kernel. -++ For example the expression \spad{sin(x)*cos(x)-2} will be transformed to -++ \spad{-2 tan(x/2)**4 -2 tan(x/2)**3 -4 tan(x/2)**2 +2 tan(x/2) -2} -++ by using the function normalize and then to -++ \spad{-2 tan(x)**2 + tan(x) -2} -++ with help of subsTan. This function tries to express the given function -++ in terms of \spad{tan(x/2)} to express in terms of \spad{tan(x)} . -++ Other examples are the expressions \spad{sqrt(x+1)+sqrt(x+7)+1} or -++ \spad{sqrt(sin(x))+1} . - +++ This package tries to find solutions of equations of type Expression(R). +++ This means expressions involving transcendental, exponential, logarithmic +++ and nthRoot functions. +++ After trying to transform different kernels to one kernel by applying +++ several rules, it calls zerosOf for the SparseUnivariatePolynomial in +++ the remaining kernel. +++ For example the expression \spad{sin(x)*cos(x)-2} will be transformed to +++ \spad{-2 tan(x/2)**4 -2 tan(x/2)**3 -4 tan(x/2)**2 +2 tan(x/2) -2} +++ by using the function normalize and then to +++ \spad{-2 tan(x)**2 + tan(x) -2} +++ with help of subsTan. This function tries to express the given function +++ in terms of \spad{tan(x/2)} to express in terms of \spad{tan(x)} . +++ Other examples are the expressions \spad{sqrt(x+1)+sqrt(x+7)+1} or +++ \spad{sqrt(sin(x))+1} . TransSolvePackage(R) : Exports == Implementation where R : Join(OrderedSet, EuclideanDomain, RetractableTo Integer, @@ -145650,13 +146407,15 @@ generates the error (reported as bug \# 102): ++ Basic Operations: decomposeFunc, unvectorise ++ Related Constructors: ++ Keywords: -++ Description: This package finds the function func3 where func1 and func2 -++ are given and func1 = func3(func2) . If there is no solution then -++ function func1 will be returned. -++ An example would be \spad{func1:= 8*X**3+32*X**2-14*X ::EXPR INT} and -++ \spad{func2:=2*X ::EXPR INT} convert them via univariate -++ to FRAC SUP EXPR INT and then the solution is \spad{func3:=X**3+X**2-X} -++ of type FRAC SUP EXPR INT +++ Description: +++ This package finds the function func3 where func1 and func2 +++ are given and func1 = func3(func2) . If there is no solution then +++ function func1 will be returned. +++ An example would be \spad{func1:= 8*X**3+32*X**2-14*X ::EXPR INT} and +++ \spad{func2:=2*X ::EXPR INT} convert them via univariate +++ to FRAC SUP EXPR INT and then the solution is \spad{func3:=X**3+X**2-X} +++ of type FRAC SUP EXPR INT + TransSolvePackageService(R) : Exports == Implementation where R : Join(IntegralDomain, OrderedSet) @@ -145766,7 +146525,6 @@ TransSolvePackageService(R) : Exports == Implementation where <>= )abbrev package TRIMAT TriangularMatrixOperations -++ Fraction free inverses of triangular matrices ++ Author: Victor Miller ++ Date Created: ++ Date Last Updated: 24 Jul 1990 @@ -145782,7 +146540,6 @@ TransSolvePackageService(R) : Exports == Implementation where ++ it is not necessary to pass to the quotient field in any of our ++ computations. - TriangularMatrixOperations(R,Row,Col,M): Exports == Implementation where R : IntegralDomain Row : FiniteLinearAggregate R @@ -145857,14 +146614,14 @@ TriangularMatrixOperations(R,Row,Col,M): Exports == Implementation where <>= )abbrev package TRIGMNIP TrigonometricManipulations -++ Trigs to/from exps and logs ++ Author: Manuel Bronstein ++ Date Created: 4 April 1988 ++ Date Last Updated: 14 February 1994 -++ Description: -++ \spadtype{TrigonometricManipulations} provides transformations from -++ trigonometric functions to complex exponentials and logarithms, and back. ++ Keywords: trigonometric, function, manipulation. +++ Description: +++ \spadtype{TrigonometricManipulations} provides transformations from +++ trigonometric functions to complex exponentials and logarithms, and back. + TrigonometricManipulations(R, F): Exports == Implementation where R : Join(GcdDomain, OrderedSet, RetractableTo Integer, LinearlyExplicitRingOver Integer) @@ -146032,7 +146789,8 @@ TrigonometricManipulations(R, F): Exports == Implementation where ++ Keywords: ++ Examples: ++ Description: -++ Tools for constructing tubes around 3-dimensional parametric curves. +++ Tools for constructing tubes around 3-dimensional parametric curves. + TubePlotTools(): Exports == Implementation where I ==> Integer SF ==> DoubleFloat @@ -146069,11 +146827,11 @@ TubePlotTools(): Exports == Implementation where ++ the color of the first point p. The result is returned as a point. unitVector: Pt -> Pt ++ unitVector(p) creates the unit vector of the point p and returns - ++ the result as a point. Note: \spad{unitVector(p) = p/|p|}. + ++ the result as a point. Note that \spad{unitVector(p) = p/|p|}. cosSinInfo: I -> L L SF - ++ cosSinInfo(n) returns the list of lists of values for n, in the - ++ form: \spad{[[cos(n - 1) a,sin(n - 1) a],...,[cos 2 a,sin 2 a],[cos a,sin a]]} - ++ where \spad{a = 2 pi/n}. Note: n should be greater than 2. + ++ cosSinInfo(n) returns the list of lists of values for n, in the form + ++ \spad{[[cos(n-1) a,sin(n-1) a],...,[cos 2 a,sin 2 a],[cos a,sin a]]} + ++ where \spad{a = 2 pi/n}. Note that n should be greater than 2. loopPoints: (Pt,Pt,Pt,SF,L L SF) -> L Pt ++ loopPoints(p,n,b,r,lls) creates and returns a list of points ++ which form the loop with radius r, around the center point @@ -146162,17 +146920,18 @@ TubePlotTools(): Exports == Implementation where <>= )abbrev package CLIP TwoDimensionalPlotClipping -++ Automatic clipping for 2-dimensional plots ++ Author: Clifton J. Williamson ++ Date Created: 22 December 1989 ++ Date Last Updated: 10 July 1990 ++ Keywords: plot, singularity ++ Examples: ++ References: +++ Description: +++ Automatic clipping for 2-dimensional plots +++ The purpose of this package is to provide reasonable plots of +++ functions with singularities. TwoDimensionalPlotClipping(): Exports == Implementation where - ++ The purpose of this package is to provide reasonable plots of - ++ functions with singularities. B ==> Boolean L ==> List SEG ==> Segment @@ -146342,17 +147101,17 @@ TwoDimensionalPlotClipping(): Exports == Implementation where pred(pt) => if (empty? list) and lastPt? then bdryPt := intersectWithBdry(xMin,xMax,yMin,yMax,pt,lastPt) - -- print bracket [ coerce bdryPt ,coerce pt ] + -- print bracket [ coerce bdryPt ,coerce pt ] --list := cons(bdryPt,list) list := cons(pt,list) if not empty? list then bdryPt := intersectWithBdry(xMin,xMax,yMin,yMax,first list,pt) - -- print bracket [ coerce bdryPt,coerce first list] + -- print bracket [ coerce bdryPt,coerce first list] --list := cons(bdryPt,list) ans := cons( list,ans) lastPt := pt - lastPt? := true - list := nil() + lastPt? := true + list := nil() empty? list => ans reverse_! cons(reverse_! list,ans) @@ -146414,7 +147173,7 @@ TwoDimensionalPlotClipping(): Exports == Implementation where findPt lists == for list in lists repeat not empty? list => - for p in list repeat + for p in list repeat not Pnan? p => return p "failed" @@ -146711,7 +147470,6 @@ TwoFactorize(F) : C == T <>= )abbrev package UNIFACT UnivariateFactorize -++ Factorisation of univariate polynomials with integer coefficients ++ Author: Patrizia Gianni ++ Date Created: ??? ++ Date Last Updated: December 1993 @@ -146719,6 +147477,7 @@ TwoFactorize(F) : C == T ++ Package for the factorization of univariate polynomials with integer ++ coefficients. The factorization is done by "lifting" (HENSEL) the ++ factorization over a finite field. + UnivariateFactorize(ZP) : public == private where Z ==> Integer PI ==> PositiveInteger @@ -147038,6 +147797,9 @@ UnivariateFactorize(ZP) : public == private where <>= )abbrev package UFPS1 UnivariateFormalPowerSeriesFunctions +++ Description: +++ This package has no description + UnivariateFormalPowerSeriesFunctions(Coef: Ring): Exports == Implementation where @@ -147081,9 +147843,11 @@ UnivariateFormalPowerSeriesFunctions(Coef: Ring): Exports == Implementation ++ Keywords: Laurent series, map ++ Examples: ++ References: -++ Description: Mapping package for univariate Laurent series -++ This package allows one to apply a function to the coefficients of -++ a univariate Laurent series. +++ Description: +++ Mapping package for univariate Laurent series +++ This package allows one to apply a function to the coefficients of +++ a univariate Laurent series. + UnivariateLaurentSeriesFunctions2(Coef1,Coef2,var1,var2,cen1,cen2):_ Exports == Implementation where Coef1 : Ring @@ -147149,8 +147913,8 @@ UnivariatePolynomialCategoryFunctions2(R,PR,S,PS): Exports == Impl where ++ map(f, p) takes a function f from R to S, ++ and applies it to each (non-zero) coefficient of a polynomial p ++ over R, getting a new polynomial over S. - ++ Note: since the map is not applied to zero elements, it may map zero - ++ to zero. + ++ Note that since the map is not applied to zero elements, it may map + ++ zero to zero. Impl ==> add map(f, p) == @@ -147181,14 +147945,14 @@ UnivariatePolynomialCategoryFunctions2(R,PR,S,PS): Exports == Impl where <>= )abbrev package UPCDEN UnivariatePolynomialCommonDenominator ---% UnivariatePolynomialCommonDenominator ++ Author: Manuel Bronstein ++ Date Created: 2 May 1988 ++ Date Last Updated: 22 Feb 1990 -++ Description: UnivariatePolynomialCommonDenominator provides +++ Keywords: gcd, quotient, common, denominator, polynomial. +++ Description: +++ UnivariatePolynomialCommonDenominator provides ++ functions to compute the common denominator of the coefficients of ++ univariate polynomials over the quotient field of a gcd domain. -++ Keywords: gcd, quotient, common, denominator, polynomial. UnivariatePolynomialCommonDenominator(R, Q, UP): Exports == Impl where R : IntegralDomain @@ -147268,9 +148032,11 @@ UnivariatePolynomialCommonDenominator(R, Q, UP): Exports == Impl where ++ Complexity of Elementary Function Evaluation, Analytic ++ Computational Complexity, J. F. Traub, Ed., Academic Press, ++ New York 1975, 151-176 -++ Description: UnivariatePolynomialDecompositionPackage implements +++ Description: +++ UnivariatePolynomialDecompositionPackage implements ++ functional decomposition of univariate polynomial with coefficients ++ in an \spad{IntegralDomain} of \spad{CharacteristicZero}. + UnivariatePolynomialDecompositionPackage(R,UP): Exports == Implementation where R : Join(IntegralDomain,CharacteristicZero) UP : UnivariatePolynomialCategory(R) @@ -147389,9 +148155,11 @@ UnivariatePolynomialDecompositionPackage(R,UP): Exports == Implementation where ++ Keyword: ++ Exemples: ++ References: -++ Description: UnivariatePolynomialDivisionPackage provides a +++ Description: +++ UnivariatePolynomialDivisionPackage provides a ++ division for non monic univarite polynomials with coefficients in ++ an \spad{IntegralDomain}. + UnivariatePolynomialDivisionPackage(R,UP): Exports == Implementation where R : IntegralDomain UP : UnivariatePolynomialCategory(R) @@ -147725,7 +148493,6 @@ UnivariatePolynomialSquareFree(RC:IntegralDomain,P):C == T <>= )abbrev package UPXS2 UnivariatePuiseuxSeriesFunctions2 -++ Mapping package for univariate Puiseux series ++ Author: Scott C. Morrison ++ Date Created: 5 April 1991 ++ Date Last Updated: 5 April 1991 @@ -147733,9 +148500,10 @@ UnivariatePolynomialSquareFree(RC:IntegralDomain,P):C == T ++ Examples: ++ References: ++ Description: -++ Mapping package for univariate Puiseux series. -++ This package allows one to apply a function to the coefficients of -++ a univariate Puiseux series. +++ Mapping package for univariate Puiseux series. +++ This package allows one to apply a function to the coefficients of +++ a univariate Puiseux series. + UnivariatePuiseuxSeriesFunctions2(Coef1,Coef2,var1,var2,cen1,cen2):_ Exports == Implementation where Coef1 : Ring @@ -147787,11 +148555,12 @@ UnivariatePuiseuxSeriesFunctions2(Coef1,Coef2,var1,var2,cen1,cen2):_ ++ Date Created: 1 February 1994 ++ Date Last Updated: 1 February 1994 ++ Description: -++ \spad{UnivariateSkewPolynomialCategoryOps} provides products and -++ divisions of univariate skew polynomials. +++ \spad{UnivariateSkewPolynomialCategoryOps} provides products and +++ divisions of univariate skew polynomials. -- Putting those operations here rather than defaults in OREPCAT allows -- OREPCAT to be defined independently of sigma and delta. -- MB 2/94 + UnivariateSkewPolynomialCategoryOps(R, C): Exports == Implementation where R: Ring C: UnivariateSkewPolynomialCategory R @@ -147937,9 +148706,11 @@ UnivariateSkewPolynomialCategoryOps(R, C): Exports == Implementation where ++ Keywords: Taylor series, map ++ Examples: ++ References: -++ Description: Mapping package for univariate Taylor series. -++ This package allows one to apply a function to the coefficients of -++ a univariate Taylor series. +++ Description: +++ Mapping package for univariate Taylor series. +++ This package allows one to apply a function to the coefficients of +++ a univariate Taylor series. + UnivariateTaylorSeriesFunctions2(Coef1,Coef2,UTS1,UTS2):_ Exports == Implementation where Coef1 : Ring @@ -147983,18 +148754,20 @@ UnivariateTaylorSeriesFunctions2(Coef1,Coef2,UTS1,UTS2):_ <>= )abbrev package UTSODE UnivariateTaylorSeriesODESolver -++ Taylor series solutions of explicit ODE's. ++ Author: Stephen Watt (revised by Clifton J. Williamson) ++ Date Created: February 1988 ++ Date Last Updated: 30 September 1993 ++ Keywords: differential equation, ODE, Taylor series ++ Examples: ++ References: +++ Description: +++ Taylor series solutions of explicit ODE's. +++ This package provides Taylor series solutions to regular +++ linear or non-linear ordinary differential equations of +++ arbitrary order. + UnivariateTaylorSeriesODESolver(Coef,UTS):_ Exports == Implementation where - ++ This package provides Taylor series solutions to regular - ++ linear or non-linear ordinary differential equations of - ++ arbitrary order. Coef : Algebra Fraction Integer UTS : UnivariateTaylorSeriesCategory Coef L ==> List @@ -148134,7 +148907,7 @@ UnivariateTaylorSeriesODESolver(Coef,UTS):_ ++ Examples: ++ References: ++ Description: -++ This package provides operations for mapping functions onto segments. +++ This package provides operations for mapping functions onto segments. UniversalSegmentFunctions2(R:Type, S:Type): with map: (R -> S, UniversalSegment R) -> UniversalSegment S @@ -148184,7 +148957,8 @@ UniversalSegmentFunctions2(R:Type, S:Type): with ++ Date Created: March 1990 ++ Date Last Updated: 9 April 1991 ++ Description: -++ Provides functions to force a partial ordering on any set. +++ Provides functions to force a partial ordering on any set. + UserDefinedPartialOrdering(S:SetCategory): with setOrder : List S -> Void ++ setOrder([a1,...,an]) defines a partial ordering on S given by: @@ -148214,15 +148988,15 @@ UserDefinedPartialOrdering(S:SetCategory): with ++ ordering induced by setOrder is completed into a total one by fn. userOrdered?: () -> Boolean ++ userOrdered?() tests if the partial ordering induced by - ++ \spadfunFrom{setOrder}{UserDefinedPartialOrdering} is not empty. + ++ setOrder is not empty. if S has OrderedSet then largest: List S -> S ++ largest l returns the largest element of l where the partial ++ ordering induced by setOrder is completed into a total one by ++ the ordering on S. more? : (S, S) -> Boolean - ++ more?(a, b) compares \spad{a} and b in the partial ordering induced - ++ by setOrder, and uses the ordering on S if \spad{a} and b are not + ++ more?(a, b) compares a and b in the partial ordering induced + ++ by setOrder, and uses the ordering on S if a and b are not ++ comparable in the partial ordering. == add @@ -148294,10 +149068,11 @@ UserDefinedPartialOrdering(S:SetCategory): with ++ Date Created: March 1990 ++ Date Last Updated: 9 April 1991 ++ Description: -++ This packages provides functions to allow the user to select the ordering -++ on the variables and operators for displaying polynomials, -++ fractions and expressions. The ordering affects the display -++ only and not the computations. +++ This packages provides functions to allow the user to select the ordering +++ on the variables and operators for displaying polynomials, +++ fractions and expressions. The ordering affects the display +++ only and not the computations. + UserDefinedVariableOrdering(): with setVariableOrder : List Symbol -> Void ++ setVariableOrder([a1,...,an]) defines an ordering on the @@ -148351,8 +149126,9 @@ UserDefinedVariableOrdering(): with ++ Date Created: 31 January 1994 ++ Date Last Updated: 3 February 1994 ++ Description: -++ \spad{RUTSodetools} provides tools to interface with the series -++ ODE solver when presented with linear ODEs. +++ \spad{RUTSodetools} provides tools to interface with the series +++ ODE solver when presented with linear ODEs. + UTSodetools(F, UP, L, UTS): Exports == Implementation where F : Ring UP : UnivariatePolynomialCategory F @@ -148436,7 +149212,7 @@ UTSodetools(F, UP, L, UTS): Exports == Implementation where ++ Keywords: ++ References: ++ Description: -++ This package provides operations which all take as arguments +++ This package provides operations which all take as arguments ++ vectors of elements of some type \spad{A} and functions from \spad{A} to ++ another of type B. The operations all iterate over their vector argument ++ and either return a value of type B or a vector over B. @@ -148523,7 +149299,8 @@ VectorFunctions2(A, B): Exports == Implementation where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: ViewportDefaultsPackage describes default and user definable +++ Description: +++ ViewportDefaultsPackage describes default and user definable ++ values for graphics ViewDefaultsPackage():Exports == Implementation where @@ -148747,7 +149524,8 @@ ViewDefaultsPackage():Exports == Implementation where ++ AMS Classifications: ++ Keywords: ++ References: -++ Description: ViewportPackage provides functions for creating GraphImages +++ Description: +++ ViewportPackage provides functions for creating GraphImages ++ and TwoDimensionalViewports from lists of lists of points. ViewportPackage():Exports == Implementation where @@ -148876,15 +149654,16 @@ ViewportPackage():Exports == Implementation where ++ Keywords: ++ Examples: ++ References: -++ Description: This package implements the Weierstrass preparation +++ Description: +++ This package implements the Weierstrass preparation ++ theorem f or multivariate power series. ++ weierstrass(v,p) where v is a variable, and p is a ++ TaylorSeries(R) in which the terms ++ of lowest degree s must include c*v**s where c is a constant,s>0, -++ is a list of TaylorSeries coefficients A[i] of the -++ equivalent polynomial +++ is a list of TaylorSeries coefficients A[i] of the equivalent polynomial ++ A = A[0] + A[1]*v + A[2]*v**2 + ... + A[s-1]*v**(s-1) + v**s ++ such that p=A*B , B being a TaylorSeries of minimum degree 0 + WeierstrassPreparation(R): Defn == Impl where R : Field VarSet==>Symbol @@ -149263,8 +150042,7 @@ WildFunctionFieldIntegralBasis(K,R,UP,F): Exports == Implementation where ++ References: ++ Description: ++ This package provides computations of logarithms and exponentials -++ for polynomials in non-commutative -++ variables. \newline Author: Michel Petitot (petitot@lifl.fr). +++ for polynomials in non-commutative variables. XExponentialPackage(R, VarSet, XPOLY): Public == Private where RN ==> Fraction Integer @@ -152479,27 +153257,24 @@ o )show ZeroDimensionalSolvePackage ++ Keywords: ++ References: ++ Description: -++ A package for computing symbolically the complex and real roots of -++ zero-dimensional algebraic systems over the integer or rational -++ numbers. Complex roots are given by means of univariate representations -++ of irreducible regular chains. Real roots are given by means of tuples -++ of coordinates lying in the \spadtype{RealClosure} of the coefficient ring. -++ This constructor takes three arguments. The first one \spad{R} is the -++ coefficient ring. The second one \spad{ls} is the list of variables involved -++ in the systems to solve. The third one must be \spad{concat(ls,s)} where -++ \spad{s} is an additional symbol used for the univariate representations. -++ WARNING: The third argument is not checked. -++ All operations are based on triangular decompositions. -++ The default is to compute these decompositions directly from the input -++ system by using the \spadtype{RegularChain} domain constructor. -++ The lexTriangular algorithm can also be used for computing these decompositions -++ (see the \spadtype{LexTriangularPackage} package constructor). -++ For that purpose, the operations \axiomOpFrom{univariateSolve}{ZeroDimensionalSolvePackage}, -++ \axiomOpFrom{realSolve}{ZeroDimensionalSolvePackage} and -++ \axiomOpFrom{positiveSolve}{ZeroDimensionalSolvePackage} admit an optional -++ argument. \newline Author: Marc Moreno Maza. - -++ Version: 1. +++ A package for computing symbolically the complex and real roots of +++ zero-dimensional algebraic systems over the integer or rational +++ numbers. Complex roots are given by means of univariate representations +++ of irreducible regular chains. Real roots are given by means of tuples +++ of coordinates lying in the \spadtype{RealClosure} of the coefficient ring. +++ This constructor takes three arguments. The first one \spad{R} is the +++ coefficient ring. The second one \spad{ls} is the list of variables +++ involved in the systems to solve. The third one must be \spad{concat(ls,s)} +++ where \spad{s} is an additional symbol used for the univariate +++ representations. +++ WARNING. The third argument is not checked. +++ All operations are based on triangular decompositions. +++ The default is to compute these decompositions directly from the input +++ system by using the \spadtype{RegularChain} domain constructor. +++ The lexTriangular algorithm can also be used for computing these +++ decompositions (see \spadtype{LexTriangularPackage} package constructor). +++ For that purpose, the operations univariateSolve, realSolve and +++ positiveSolve admit an optional argument. ZeroDimensionalSolvePackage(R,ls,ls2): Exports == Implementation where R : Join(OrderedRing,EuclideanDomain,CharacteristicZero,RealConstant) @@ -152546,32 +153321,39 @@ ZeroDimensionalSolvePackage(R,ls,ls2): Exports == Implementation where ++ (w.r.t. Zarisky topology). ++ Moreover, if \spad{info?} is \spad{true} then some information is ++ displayed during the computations. - ++ See \axiomOpFrom{zeroSetSplit}{RegularTriangularSetCategory}(lp,true,info?). - ++ If \spad{lextri?} is \spad{true} then the lexTriangular algorithm is called + ++ See zeroSetSplit from RegularTriangularSetCategory(lp,true,info?). + ++ If \spad{lextri?} is \spad{true} then the lexTriangular algorithm + ++ is called ++ from the \spadtype{LexTriangularPackage} constructor - ++ (see \axiomOpFrom{zeroSetSplit}{LexTriangularPackage}(lp,false)). - ++ Otherwise, the triangular decomposition is computed directly from the input - ++ system by using the \axiomOpFrom{zeroSetSplit}{RegularChain} from \spadtype{RegularChain}. + ++ (see zeroSetSplit from LexTriangularPackage(lp,false)). + ++ Otherwise, the triangular decomposition is computed directly from + ++ the input + ++ system by using the zeroSetSplit from RegularChain triangSolve: (LP,B) -> List RegularChain(R,ls) - ++ \spad{triangSolve(lp,info?)} returns the same as \spad{triangSolve(lp,false)} + ++ \spad{triangSolve(lp,info?)} returns the same as + ++ \spad{triangSolve(lp,false)} triangSolve: LP -> List RegularChain(R,ls) - ++ \spad{triangSolve(lp)} returns the same as \spad{triangSolve(lp,false,false)} - univariateSolve: RegularChain(R,ls) -> List Record(complexRoots: U, coordinates: LP) + ++ \spad{triangSolve(lp)} returns the same as + ++ \spad{triangSolve(lp,false,false)} + univariateSolve: RegularChain(R,ls) -> _ + List Record(complexRoots: U, coordinates: LP) ++ \spad{univariateSolve(ts)} returns a univariate representation ++ of \spad{ts}. - ++ See \axiomOpFrom{rur}{RationalUnivariateRepresentationPackage}(lp,true). + ++ See rur from RationalUnivariateRepresentationPackage(lp,true). univariateSolve: (LP,B,B,B) -> List RUR ++ \spad{univariateSolve(lp,info?,check?,lextri?)} returns a univariate ++ representation of the variety associated with \spad{lp}. ++ Moreover, if \spad{info?} is \spad{true} then some information is ++ displayed during the decomposition into regular chains. ++ If \spad{check?} is \spad{true} then the result is checked. - ++ See \axiomOpFrom{rur}{RationalUnivariateRepresentationPackage}(lp,true). - ++ If \spad{lextri?} is \spad{true} then the lexTriangular algorithm is called + ++ See rur from RationalUnivariateRepresentationPackage(lp,true). + ++ If \spad{lextri?} is \spad{true} then the lexTriangular + ++ algorithm is called ++ from the \spadtype{LexTriangularPackage} constructor - ++ (see \axiomOpFrom{zeroSetSplit}{LexTriangularPackage}(lp,false)). - ++ Otherwise, the triangular decomposition is computed directly from the input - ++ system by using the \axiomOpFrom{zeroSetSplit}{RegularChain} from \spadtype{RegularChain}. + ++ (see zeroSetSplit from LexTriangularPackage(lp,false)). + ++ Otherwise, the triangular decomposition is computed directly + ++ from the input + ++ system by using the zeroSetSplit from RegularChain univariateSolve: (LP,B,B) -> List RUR ++ \spad{univariateSolve(lp,info?,check?)} returns the same as ++ \spad{univariateSolve(lp,info?,check?,false)}. @@ -152584,52 +153366,66 @@ ZeroDimensionalSolvePackage(R,ls,ls2): Exports == Implementation where realSolve: RegularChain(R,ls) -> List REALSOL ++ \spad{realSolve(ts)} returns the set of the points in the regular ++ zero set of \spad{ts} whose coordinates are all real. - ++ WARNING: For each set of coordinates given by \spad{realSolve(ts)} + ++ WARNING. For each set of coordinates given by \spad{realSolve(ts)} ++ the ordering of the indeterminates is reversed w.r.t. \spad{ls}. realSolve: (LP,B,B,B) -> List REALSOL - ++ \spad{realSolve(ts,info?,check?,lextri?)} returns the set of the points - ++ in the variety associated with \spad{lp} whose coordinates are all real. + ++ \spad{realSolve(ts,info?,check?,lextri?)} returns the set of the + ++ points in the variety associated with \spad{lp} whose coordinates + ++ are all real. ++ Moreover, if \spad{info?} is \spad{true} then some information is ++ displayed during decomposition into regular chains. ++ If \spad{check?} is \spad{true} then the result is checked. - ++ If \spad{lextri?} is \spad{true} then the lexTriangular algorithm is called + ++ If \spad{lextri?} is \spad{true} then the lexTriangular algorithm + ++ is called ++ from the \spadtype{LexTriangularPackage} constructor - ++ (see \axiomOpFrom{zeroSetSplit}{LexTriangularPackage}(lp,false)). - ++ Otherwise, the triangular decomposition is computed directly from the input - ++ system by using the \axiomOpFrom{zeroSetSplit}{RegularChain} from \spadtype{RegularChain}. - ++ WARNING: For each set of coordinates given by \spad{realSolve(ts,info?,check?,lextri?)} + ++ (see zeroSetSplit from LexTriangularPackage(lp,false)). + ++ Otherwise, the triangular decomposition is computed directly from + ++ the input + ++ system by using the zeroSetSplit from \spadtype{RegularChain}. + ++ WARNING. For each set of coordinates given by + ++ \spad{realSolve(ts,info?,check?,lextri?)} ++ the ordering of the indeterminates is reversed w.r.t. \spad{ls}. realSolve: (LP,B,B) -> List REALSOL - ++ \spad{realSolve(ts,info?,check?)} returns the same as \spad{realSolve(ts,info?,check?,false)}. + ++ \spad{realSolve(ts,info?,check?)} returns the same as + ++ \spad{realSolve(ts,info?,check?,false)}. realSolve: (LP,B) -> List REALSOL - ++ \spad{realSolve(ts,info?)} returns the same as \spad{realSolve(ts,info?,false,false)}. + ++ \spad{realSolve(ts,info?)} returns the same as + ++ \spad{realSolve(ts,info?,false,false)}. realSolve: LP -> List REALSOL - ++ \spad{realSolve(lp)} returns the same as \spad{realSolve(ts,false,false,false)} + ++ \spad{realSolve(lp)} returns the same as + ++ \spad{realSolve(ts,false,false,false)} positiveSolve: RegularChain(R,ls) -> List REALSOL ++ \spad{positiveSolve(ts)} returns the points of the regular ++ set of \spad{ts} with (real) strictly positive coordinates. positiveSolve: (LP,B,B) -> List REALSOL ++ \spad{positiveSolve(lp,info?,lextri?)} returns the set of the points - ++ in the variety associated with \spad{lp} whose coordinates are (real) strictly positive. + ++ in the variety associated with \spad{lp} whose coordinates are + ++ (real) strictly positive. ++ Moreover, if \spad{info?} is \spad{true} then some information is ++ displayed during decomposition into regular chains. - ++ If \spad{lextri?} is \spad{true} then the lexTriangular algorithm is called + ++ If \spad{lextri?} is \spad{true} then the lexTriangular + ++ algorithm is called ++ from the \spadtype{LexTriangularPackage} constructor - ++ (see \axiomOpFrom{zeroSetSplit}{LexTriangularPackage}(lp,false)). - ++ Otherwise, the triangular decomposition is computed directly from the input - ++ system by using the \axiomOpFrom{zeroSetSplit}{RegularChain} from \spadtype{RegularChain}. - ++ WARNING: For each set of coordinates given by \spad{positiveSolve(lp,info?,lextri?)} + ++ (see zeroSetSplit from LexTriangularPackage(lp,false)). + ++ Otherwise, the triangular decomposition is computed directly + ++ from the input + ++ system by using the zeroSetSplit from \spadtype{RegularChain}. + ++ WARNING. For each set of coordinates given by + ++ \spad{positiveSolve(lp,info?,lextri?)} ++ the ordering of the indeterminates is reversed w.r.t. \spad{ls}. positiveSolve: (LP,B) -> List REALSOL - ++ \spad{positiveSolve(lp)} returns the same as \spad{positiveSolve(lp,info?,false)}. + ++ \spad{positiveSolve(lp)} returns the same as + ++ \spad{positiveSolve(lp,info?,false)}. positiveSolve: LP -> List REALSOL - ++ \spad{positiveSolve(lp)} returns the same as \spad{positiveSolve(lp,false,false)}. + ++ \spad{positiveSolve(lp)} returns the same as + ++ \spad{positiveSolve(lp,false,false)}. squareFree: (TS) -> List ST - ++ \spad{squareFree(ts)} returns the square-free factorization of \spad{ts}. - ++ Moreover, each factor is a Lazard triangular set and the decomposition + ++ \spad{squareFree(ts)} returns the square-free factorization + ++ of \spad{ts}. Moreover, each factor is a Lazard triangular set + ++ and the decomposition ++ is a Kalkbrener split of \spad{ts}, which is enough here for ++ the matter of solving zero-dimensional algebraic systems. - ++ WARNING: \spad{ts} is not checked to be zero-dimensional. + ++ WARNING. \spad{ts} is not checked to be zero-dimensional. convert: Q -> Q2 ++ \spad{convert(q)} converts \spad{q}. convert: P -> PRC @@ -152639,7 +153435,7 @@ ZeroDimensionalSolvePackage(R,ls,ls2): Exports == Implementation where convert: U -> URC ++ \spad{convert(u)} converts \spad{u}. convert: ST -> List Q2 - ++ \spad{convert(st)} returns the members of \spad{st}. + ++ \spad{convert(st)} returns the members of \spad{st}. Implementation == add news: Symbol := last(ls2)$(List Symbol) diff --git a/books/bookvol2.pamphlet b/books/bookvol2.pamphlet index d48a597..6e4a8a1 100644 --- a/books/bookvol2.pamphlet +++ b/books/bookvol2.pamphlet @@ -303,6 +303,124 @@ This book is actually a literate program\cite{2} and can contain executable source code. In particular, the Makefile for this book is part of the source of the book and is included below. Axiom uses the ``noweb'' literate programming system by Norman Ramsey\cite{6}. +\chapter{Writing Spad Code} +\section{The Description: label and the )describe command} +The describe command will print out the comments associated with Axiom +source code elements. For the category, domain, and package sections +the text is taken from the Description: keyword. + +This information is stored in a database and can be queried with +\begin{verbatim} + )lisp (getdatabase '|Integer| 'documentation) +\end{verbatim} +for the Integer domain. However, this information has other uses in +the system so it contains tags and control information. Most tags are +removed by the describe function since the output is intended to be +displayed in ASCII on the terminal. + +The Description: keyword is in the comment block just after the +abbreviation command. It is freeform and the paragraph will be reflowed +automatically to allow for about 60 characters per line, adjusted for +spaces. The Description: section should be written after the keyword in +the ``++'' comments as in: +\begin{verbatim} +)abbrev package D03AGNT d03AgentsPackage +++ Description: +++ This package does some interesting stuff. We can write multiple +++ lines but they should all line up with the first character of +++ the Description keyword. Special \spad{terms} will be removed. +++ +++ The above line will force a newline. So will ending a line with \br +++ \tab{5}This will allow primitive formatting\br +++ \tab{5}So you can align text\br +++ \tab{10}Start in column 11\tab{5}and skip 5 spaces\br +++ \tab{10}End in column 11\tab{7}and count out the needed spaces\br +++ \tab{5} note that the last line will not need the br command +\end{verbatim} +As the comment says, the Description should all be aligned under the +``D'' in Description. You can indent using \verb|\tab{n}| which will insert +$n$ spaces. You can force a newline in two ways. Either include a +blank line (with the ``++'' comments) or use the \verb|\br| keyword. + +Due to lousy parsing algorithms for comments there are various ways this +can all go wrong. + +There should not be any macros between the Description: section and +the beginning of the definition. This is wrong. It will cause the +\begin{verbatim} + )describe package d03AgentsPackage +\end{verbatim} +to give the wrong output because it does not find the end of the +description section properly. +\begin{verbatim} +)abbrev package D03AGNT d03AgentsPackage +++ Description: +++ This description does not work + +LEDF ==> List Expression DoubleFloat + +d03AgentsPackage(): E == I where +\end{verbatim} + +In the Description: section the \verb|\tab{nn}| function will be transformed +into nn spaces. If you end each line with a \verb|\br| you can control +alignment. +\begin{verbatim} +++ Description: +++ This is an example of a table alignment\br +++ \tab{5}First Item\tab{5} This will line up with the following line\br +++ \tab{5}Second Item\tab{4} This will line up with the following line\br +++ \tab{5}Third Item\tab{5} This will line up with the following line +\end{verbatim} + +If the main body of the category, domain, or package begins with +properties rather than functions the Description will be incorrectly +recorded. This is a known bug finding the end of the Description section. +For instance, this +\begin{verbatim} +++ Description: +++ The category of Lie Algebras. +++ It is used by the domains of non-commutative algebra, +++ LiePolynomial and XPBWPolynomial. + +LieAlgebra(R: CommutativeRing): Category == Module(R) with + NullSquare + ++ \axiom{NullSquare} means that \axiom{[x,x] = 0} holds. + JacobiIdentity + ++ \axiom{JacobiIdentity} means that + ++ \axiom{[x,[y,z]]+[y,[z,x]]+[z,[x,y]] = 0} holds. + construct: ($,$) -> $ + ++ \axiom{construct(x,y)} returns the Lie bracket of \axiom{x} + ++ and \axiom{y}. +\end{verbatim} +will give the output +\begin{verbatim} +{JacobiIdentity} means that} [x,[y,z]]+[y,[z,x]]+[z,[x,y]] = 0 holds. +\end{verbatim} +but reordering it to read: +\begin{verbatim} +++ Description: +++ The category of Lie Algebras. +++ It is used by the domains of non-commutative algebra, +++ LiePolynomial and XPBWPolynomial. + +LieAlgebra(R: CommutativeRing): Category == Module(R) with + construct: ($,$) -> $ + ++ \axiom{construct(x,y)} returns the Lie bracket of \axiom{x} + ++ and \axiom{y}. + NullSquare + ++ \axiom{NullSquare} means that \axiom{[x,x] = 0} holds. + JacobiIdentity + ++ \axiom{JacobiIdentity} means that + ++ \axiom{[x,[y,z]]+[y,[z,x]]+[z,[x,y]] = 0} holds. +\end{verbatim} +will give the output +\begin{verbatim} +The category of Lie Algebras. It is used by the domains of +non-commutative algebra, LiePolynomial and XPBWPolynomial. +\end{verbatim} +which is correct. + <<*>>= PROJECT=bookvol2 TANGLE=/usr/local/bin/NOTANGLE diff --git a/books/bookvol5.pamphlet b/books/bookvol5.pamphlet index a2fe0cf..cde2496 100644 --- a/books/bookvol5.pamphlet +++ b/books/bookvol5.pamphlet @@ -7307,6 +7307,7 @@ See:\\ (|compiler| . |compiler| ) (|copyright| . |interpreter|) (|credits| . |interpreter|) + (|describe| . |interpreter|) (|display| . |interpreter|) (|edit| . |interpreter|) (|fin| . |development|) @@ -7460,6 +7461,7 @@ tokenized and validated the input before calling the history function. |compiler| |depends| |display| + |describe| |edit| |frame| |frame| @@ -9315,6 +9317,226 @@ verbatim. This will eventually result in a call to the function \verb|handleNoParseCommands| \ref{handleNoParseCommands} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\cmdhead{describe} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +<>= +==================================================================== + )describe +==================================================================== + +User Level Required: interpreter + +Command Syntax: + + - )describe operations opName + - )describe category catName + - )describe domain domName + - )describe package packName + +Command Description: + +This command is used to display the comments for the operation, category, +domain or package. The comments are part of the algebra source code. + +The command + +)describe operations opName + +shows comments from each instance of an operation name. For instance, + +)describe op sqrt + +will show + +Description of sqrt from FortranExpression + +sqrt(x) represents the Fortran intrinsic function SQRT + +Description of sqrt from PAdicIntegerCategory + +sqrt(b,a) returns a square root of b. Argument a is a square root of b (mod p). + +Description of sqrt from RadicalCategory + +sqrt(x) returns the square root of x. + +Description of sqrt from RealClosedField + +sqrt(x) is x ** (1/2) + + +The commands + +)describe category catName +)describe domain domName internal +)describe package packName internal + +will show a properly formatted version of the "Description:" keyword +from the comments in the algebra source for the category, domain, +or package requested. + +If 'internal' is requested, then the internal format of the domain or +package is described. Categories do not have an internal representation. + +@ + +\defdollar{describeOptions} +The current value of \$describeOptions is +<>= +(defvar $describeOptions '(|category| |domain| |package|)) + +@ + +\section{Functions} +\defun{describe}{Print comment strings from algebra libraries} +This trivial function satisfies the standard pattern of making a +user command match the name of the function which implements the +command. That command immediatly invokes a ``Spad2Cmd'' version. +\calls{describe}{describespad2cmd} +<>= +(defun |describe| (l) + (describeSpad2Cmd l)) + +@ + +\defun{describeSpad2Cmd}{describeSpad2Cmd} +The describe command prints cleaned-up comment strings from the algebra +libraries. It can print strings associated with a category, domain, package, +or by operation. + +This implements command line options of the form: +\begin{verbatim} + )describe category + )describe domain [internal] + )describe package [internal] +\end{verbatim} +The describeInternal function will either call the ``dc'' function +to describe the internal representation of the argument or it will +print a cleaned up version of the text for the "Description" keyword +in the Category, Domain, or Package source code. +\calls{describeSpad2Cmd}{selectOptionLC} +\calls{describeSpad2Cmd}{flatten} +\calls{describeSpad2Cmd}{cleanline} +\calls{describeSpad2Cmd}{getdatabase} +\calls{describeSpad2Cmd}{sayMessage} +\usesdollar{describeSpad2Cmd}{e} +\usesdollar{describeSpad2Cmd}{EmptyEnvironment} +\usesdollar{describeSpad2Cmd}{describeOptions} +<>= +(defun describeSpad2Cmd (l) + (labels ( + (describeInternal (cdp internal?) + (if internal? + (|dc| cdp) + (mapcar #'(lambda (x) (if (stringp x) (cleanline x))) + (flatten (car (getdatabase cdp 'documentation))))))) + (let ((|$e| |$EmptyEnvironment|) (opt (second l))) + (declare (special |$e| |$EmptyEnvironment| $describeOptions)) + (if (and (pairp l) (not (eq opt '?))) + (case (|selectOptionLC| (first l) $describeOptions '|optionError|) + (|category| (describeInternal opt nil)) + (|domain| (describeInternal opt (third l))) + (|package| (describeInternal opt (third l)))) + (|sayMessage| + (append + '(" )describe keyword arguments are") + (mapcar #'(lambda (x) (format nil "~% ~a" x)) $describeOptions) + (format nil "~% or abbreviations thereof"))))))) + +@ + +\defun{cleanline}{cleanline} +<>= +(defun cleanline (line) + (labels ( + (replaceInLine (thing other line) + (do ((mark (search thing line) (search thing line))) + ((null mark) line) + (setq line + (concatenate 'string (subseq line 0 mark) other + (subseq line (+ mark (length thing))))))) + + (removeFromLine (thing line) (replaceInLine thing "" line)) + + (removeKeyword (str line) + (do ((mark (search str line) (search str line))) + ((null mark) line) + (let (left point mid right) + (setq left (subseq line 0 mark)) + (setq point (search "}" line :start2 mark)) + (setq mid (subseq line (+ mark (length str)) point)) + (setq right (subseq line (+ point 1))) + (setq line (concatenate 'string left mid right))))) + + (addSpaces (str line) + (do ((mark (search str line) (search str line)) (cnt)) + ((null mark) line) + (let (left point mid right) + (setq left (subseq line 0 mark)) + (setq point (search "}" line :start2 mark)) + (setq mid (subseq line (+ mark (length str)) point)) + (if (setq cnt (parse-integer mid :junk-allowed t)) + (setq mid (make-string cnt :initial-element #\ )) + (setq mid "")) + (setq right (subseq line (+ point 1))) + (setq line (concatenate 'string left mid right))))) + + (splitAtNewline (line) + (do ((mark (search "~%" line) (search "~%" line)) (lines)) + ((null mark) + (push " " lines) + (push line lines) + (nreverse lines)) + (push (subseq line 0 mark) lines) + (setq line (subseq line (+ mark 2))))) + + (wrapOneLine (line margin result) + (if (null line) + (nreverse result) + (if (< (length line) margin) + (wrapOneLine nil margin (append (list line) result)) + (let (oneline spill aspace) + (setq aspace (position #\space (subseq line 0 margin) :from-end t)) + (setq oneline (string-trim '(#\space) (subseq line 0 aspace))) + (setq spill (string-trim '(#\space) (subseq line aspace))) + (wrapOneLine spill margin (append (list oneline) result)))))) + + (reflowParagraph (line) + (let (lst1 lst2) + (setq lst1 (splitAtNewLine line)) + (dolist (x lst1) + (mapcar #'(lambda(y) (format t "~a~%" y)) + (wrapOneLine x 70 nil)))))) + + (setq line (removeFromLine "{}" line)) + (setq line (replaceInLine "\\blankline" "~%~%" line)) + (setq line (replaceInLine "\\br" "~%" line)) + (setq line (removeFromLine "\\" line)) + (dolist (str '("spad{" "spadtype{" "spadop{" "spadfun{" "spadatt{" + "axiom{" "axiomType{" "spadignore{" "axiomFun{" + "centerline{" "inputbitmap{" "axiomOp{" "spadgloss{")) + (setq line (removeKeyword str line))) + (setq line (replaceInLine "{e.g.}" "e.g." line)) + (dolist (str '("tab{" "indented{" )) + (setq line (addSpaces str line))) + (reflowParagraph line))) + +@ + +\defun{flatten}{flatten} +<>= +(defun flatten (x) + (labels ( + (rec (x acc) + (cond + ((null x) acc) + ((atom x) (cons x acc)) + (t (rec (car x) (rec (cdr x) acc)))))) + (rec x nil))) + +@ + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \cmdhead{display} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% <>= @@ -10736,12 +10958,13 @@ Other help topics Available help topics are: abbreviations assignment blocks browse boot cd -clear clef close collection compile display -edit fin for frame help history -if iterate leave library lisp load -ltrace parallel pquit quit read repeat -savesystem set show spool suchthat synonym -system syntax trace undo what while +clear clef close collection compile describe +display edit fin for frame help +history if iterate leave library lisp +load ltrace parallel pquit quit read +repeat savesystem set show spool suchthat +synonym system syntax trace undo what +while Available algebra help topics are: @@ -24314,6 +24537,7 @@ maxindex <> <> <> +<> <> <> <> @@ -24344,6 +24568,7 @@ maxindex <> <> <> +<> <> <> <> @@ -24362,6 +24587,7 @@ maxindex <> <> <> +<> <> <> <> @@ -24409,6 +24635,7 @@ maxindex <> <> <> +<> <> <> <> diff --git a/changelog b/changelog index a5dcef6..8a55e6c 100644 --- a/changelog +++ b/changelog @@ -1,3 +1,13 @@ +20091124 tpd src/axiom-website/patches.html 20091124.01.tpd.patch +20091124 tpd books/bookvol10.4 clean up Description: +20091124 tpd books/bookvol10.3 clean up Description: +20091124 tpd books/bookvol10.2 clean up Description: +20091124 tpd books/bookvol5 add describe command line function +20091124 tpd books/bookvol2 document describe +20091124 tpd src/input/unittest2.input fix describe breakage +20091124 tpd src/input/unit-macro.input fix latex breakage +20091124 tpd src/algebra/Makefile add describe help file +20091124 tpd src/interp/Makefile remove obey 20091118 tpd src/axiom-website/patches.html 20091118.01.tpd.patch 20091118 tpd src/input/testprob.input test bad result from solve 20091115 tpd src/axiom-website/patches.html 20091115.01.tpd.patch diff --git a/src/algebra/Makefile.pamphlet b/src/algebra/Makefile.pamphlet index 7cd5a81..300408b 100644 --- a/src/algebra/Makefile.pamphlet +++ b/src/algebra/Makefile.pamphlet @@ -16327,15 +16327,15 @@ SYNTAXHELP=\ abbreviations.help assignment.help blocks.help boot.help \ browse.help cd.help clear.help clef.help \ close.help collection.help compiler.help copyright.help \ -display.help edit.help fin.help for.help \ -frame.help help.help history.help if.help \ -include.help iterate.help leave.help library.help \ -lisp.help load.help ltrace.help parallel.help \ -pquit.help quit.help read.help repeat.help \ -savesystem.help set.help show.help spool.help \ -suchthat.help summary.help synonym.help syntax.help \ -system.help trace.help undo.help what.help \ -while.help with.help +display.help describe.help edit.help fin.help \ +for.help frame.help help.help history.help \ +if.help include.help iterate.help leave.help \ +library.help lisp.help load.help ltrace.help \ +parallel.help pquit.help quit.help read.help \ +repeat.help savesystem.help set.help show.help \ +spool.help suchthat.help summary.help synonym.help \ +syntax.help system.help trace.help undo.help \ +what.help while.help with.help @ \subsection{help documentation for algebra} diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html index 651713e..9961f0f 100644 --- a/src/axiom-website/patches.html +++ b/src/axiom-website/patches.html @@ -2263,5 +2263,7 @@ src/input/unit-macro unit test macro commands
books/bookvol5 \calls, \uses, and code ports
20091118.01.tpd.patch src/input/testprob.input test bad result from solve
+20091124.01.tpd.patch +books/bookvol2, 5, 10.2, 10.3, 10.4 add describe command
diff --git a/src/input/unit-macro.input.pamphlet b/src/input/unit-macro.input.pamphlet index e898b79..b42ce45 100644 --- a/src/input/unit-macro.input.pamphlet +++ b/src/input/unit-macro.input.pamphlet @@ -5,7 +5,7 @@ \author{Timothy Daly} \maketitle \begin{abstract} -Test modifications to the $pfMacros internal state variable +Test modifications to the \$pfMacros internal state variable \end{abstract} \eject \tableofcontents diff --git a/src/input/unittest2.input.pamphlet b/src/input/unittest2.input.pamphlet index b9b389c..00fb812 100644 --- a/src/input/unittest2.input.pamphlet +++ b/src/input/unittest2.input.pamphlet @@ -362,7 +362,7 @@ Unit test the user level commands --S 57 of 237 )lisp (identity |$noParseCommands| ) --R ---RValue = (|boot| |copyright| |credits| |fin| |lisp| |pquit| |quit| |synonym| |system|) +--RValue = (|boot| |copyright| |credits| |fin| |lisp| |pquit| |quit| |synonym| |system| |trademark|) --E 57 --S 58 of 237 @@ -617,13 +617,13 @@ This generates non-printing characters --S 99 of 237 )lisp (identity $syscommands) --R ---RValue = (|abbreviations| |boot| |browse| |cd| |clear| |close| |compiler| |copyright| |credits| |display| |edit| |fin| |frame| |help| |history| |lisp| |library| |load| |ltrace| |pquit| |quit| |read| |savesystem| |set| |show| |spool| |summary| |synonym| |system| |trace| |undo| |what| |with| |workfiles| |zsystemdevelopment|) +--RValue = (|abbreviations| |boot| |browse| |cd| |clear| |close| |compiler| |copyright| |credits| |describe| |display| |edit| |fin| |frame| |help| |history| |lisp| |library| |load| |ltrace| |pquit| |quit| |read| |savesystem| |set| |show| |spool| |summary| |synonym| |system| |trace| |trademark| |undo| |what| |with| |workfiles| |zsystemdevelopment|) --E 99 --S 100 of 237 )lisp (identity |$systemCommands|) --R ---RValue = ((|abbreviations| . |compiler|) (|boot| . |development|) (|browse| . |development|) (|cd| . |interpreter|) (|clear| . |interpreter|) (|close| . |interpreter|) (|compiler| . |compiler|) (|copyright| . |interpreter|) (|credits| . |interpreter|) (|display| . |interpreter|) (|edit| . |interpreter|) (|fin| . |development|) (|frame| . |interpreter|) (|help| . |interpreter|) (|history| . |interpreter|) (|lisp| . |development|) (|library| . |interpreter|) (|load| . |interpreter|) (|ltrace| . |interpreter|) (|pquit| . |interpreter|) (|quit| . |interpreter|) (|read| . |interpreter|) (|savesystem| . |interpreter|) (|set| . |interpreter|) (|show| . |interpreter|) (|spool| . |interpreter|) (|summary| . |interpreter|) (|synonym| . |interpreter|) (|system| . |interpreter|) (|trace| . |interpreter|) (|undo| . |interpreter|) (|what| . |interpreter|) (|with| . |interpreter|) (|workfiles| . |development|) (|zsystemdevelopment| . |interpreter|)) +--RValue = ((|abbreviations| . |compiler|) (|boot| . |development|) (|browse| . |development|) (|cd| . |interpreter|) (|clear| . |interpreter|) (|close| . |interpreter|) (|compiler| . |compiler|) (|copyright| . |interpreter|) (|credits| . |interpreter|) (|describe| . |interpreter|) (|display| . |interpreter|) (|edit| . |interpreter|) (|fin| . |development|) (|frame| . |interpreter|) (|help| . |interpreter|) (|history| . |interpreter|) (|lisp| . |development|) (|library| . |interpreter|) (|load| . |interpreter|) (|ltrace| . |interpreter|) (|pquit| . |interpreter|) (|quit| . |interpreter|) (|read| . |interpreter|) (|savesystem| . |interpreter|) (|set| . |interpreter|) (|show| . |interpreter|) (|spool| . |interpreter|) (|summary| . |interpreter|) (|synonym| . |interpreter|) (|system| . |interpreter|) (|trace| . |interpreter|) (|trademark| . |interpreter|) (|undo| . |interpreter|) (|what| . |interpreter|) (|with| . |interpreter|) (|workfiles| . |development|) (|zsystemdevelopment| . |interpreter|)) --E 100 --S 101 of 237 @@ -653,7 +653,7 @@ This generates non-printing characters --S 105 of 237 )lisp (identity |$tokenCommands|) --R ---RValue = (|abbreviations| |cd| |clear| |close| |compiler| |depends| |display| |edit| |frame| |frame| |help| |history| |input| |library| |load| |ltrace| |read| |savesystem| |set| |spool| |undo| |what| |with| |workfiles| |zsystemdevelopment|) +--RValue = (|abbreviations| |cd| |clear| |close| |compiler| |depends| |display| |describe| |edit| |frame| |frame| |help| |history| |input| |library| |load| |ltrace| |read| |savesystem| |set| |spool| |undo| |what| |with| |workfiles| |zsystemdevelopment|) --E 105 --S 106 of 237 diff --git a/src/interp/Makefile.pamphlet b/src/interp/Makefile.pamphlet index f9401b3..ae5c90f 100644 --- a/src/interp/Makefile.pamphlet +++ b/src/interp/Makefile.pamphlet @@ -673,7 +673,7 @@ compiler::*suppress-compiler-notes* to true in order to reduce the noise. <>= ${SAVESYS}: ${DEPSYS} ${OBJS} ${OUT}/bookvol5.${O} ${OUT}/util.${O} \ ${OUT}/nocompil.${LISP} ${OUT}/sys-pkg.${LISP} \ - ${OUTINTERP} ${BROBJS} ${OUT}/obey.${O} \ + ${OUTINTERP} ${BROBJS} \ ${OUT}/database.date ${INOBJS} ${ASCOMP} ${ASAUTO} \ ${NAGBROBJS} ${TRANOBJS} \ ${LOADSYS} \ @@ -721,7 +721,6 @@ ${SAVESYS}: ${DEPSYS} ${OBJS} ${OUT}/bookvol5.${O} ${OUT}/util.${O} \ @ echo '(in-package "BOOT")' >> ${OUT}/makeint.lisp @ echo '(load "${INT}/algebra/warm.data")' >> ${OUT}/makeint.lisp @ echo '(|clearClams|)' >> ${OUT}/makeint.lisp - @ echo '(load "${OUT}/obey")' >> ${OUT}/makeint.lisp # @ echo '#+:akcl (si::multiply-bignum-stack 10)' >> ${OUT}/makeint.lisp @ echo '#+:akcl (setq compiler::*suppress-compiler-notes* t)' \ >> ${OUT}/makeint.lisp @@ -2900,29 +2899,6 @@ ${MID}/nrunopt.lisp: ${IN}/nrunopt.lisp.pamphlet @ -\subsection{obey.lisp} -<>= -${OUT}/obey.${O}: ${MID}/obey.${LISP} - @ echo 367 making ${OUT}/obey.${O} from ${MID}/obey.${LISP} - @ ( cd ${MID} ; \ - if [ -z "${NOISE}" ] ; then \ - echo '(progn (compile-file "${MID}/obey.${LISP}"' \ - ':output-file "${OUT}/obey.${O}") (${BYE}))' | ${DEPSYS} ; \ - else \ - echo '(progn (compile-file "${MID}/obey.${LISP}"' \ - ':output-file "${OUT}/obey.${O}") (${BYE}))' | ${DEPSYS} \ - >${TMP}/trace ; \ - fi ) - -@ -<>= -${MID}/obey.${LISP}: ${IN}/obey.lisp.pamphlet - @ echo 368 making ${MID}/obey.${LISP} from ${IN}/obey.lisp.pamphlet - @(cd ${MID} ; \ - ${TANGLE} ${IN}/obey.lisp.pamphlet >obey.${LISP} ) - -@ - \subsection{package.lisp} <>= ${OUT}/package.${O}: ${MID}/package.lisp @@ -4285,9 +4261,6 @@ clean: <> <> -<> -<> - <> <>