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 +++ d02bb