diff options
| author | dos-reis <gdr@axiomatics.org> | 2009-06-11 21:51:23 +0000 |
|---|---|---|
| committer | dos-reis <gdr@axiomatics.org> | 2009-06-11 21:51:23 +0000 |
| commit | 7bd82b57975bbc1ff5b87fed0739815c620ecdcc (patch) | |
| tree | 4cf4d2b4af144e87a86cc1ac2f85a5f4148cb8fb /src/algebra | |
| parent | fb75980589a0611aee3b8e5e25408725a5c5a531 (diff) | |
| download | open-axiom-7bd82b57975bbc1ff5b87fed0739815c620ecdcc.tar.gz | |
* algebra/: Remove quotes from operator namaes in signatures.
Diffstat (limited to 'src/algebra')
60 files changed, 295 insertions, 295 deletions
diff --git a/src/algebra/aggcat.spad.pamphlet b/src/algebra/aggcat.spad.pamphlet index 8e941ff8..9f802495 100644 --- a/src/algebra/aggcat.spad.pamphlet +++ b/src/algebra/aggcat.spad.pamphlet @@ -58,7 +58,7 @@ Aggregate: Category == Type with ++ size?(u,n) tests if u has exactly n elements. sample: constant -> % ++ sample yields a value of type % if % has finiteAggregate then - "#": % -> NonNegativeInteger ++ # u returns the number of items in u. + #: % -> NonNegativeInteger ++ # u returns the number of items in u. add eq?(a,b) == EQ(a,b)$Lisp sample() == empty() @@ -141,15 +141,15 @@ HomogeneousAggregate(S:Type): Category == Aggregate with eval(u:%,l:List Equation S):% == map(eval(#1,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] - 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] + count(f:S -> Boolean, c:%) == +/[1 for x in parts c | f x] members x == parts x if S has SetCategory then count(s:S, x:%) == count(s = #1, x) member?(e, c) == any?(e = #1,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]) if S has CoercibleTo(OutputForm) then coerce(x:%):OutputForm == bracket @@ -227,9 +227,9 @@ Collection(S:Type): Category == HomogeneousAggregate(S) with add if % has finiteAggregate then #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] + 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] 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) @@ -544,7 +544,7 @@ Dictionary(S:SetCategory): Category == s = t == eq?(s,t) => true #s ~= #t => false - _and/[member?(x, t) for x in parts s] + and/[member?(x, t) for x in parts s] remove_!(f:S->Boolean, t:%) == for m in parts t repeat if f m then remove_!(m, t) @@ -718,7 +718,7 @@ FiniteSetAggregate(S:SetCategory): Category == cardinality 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] + subset?(s, t) == #s < #t and (and/[member?(x, t) for x in parts s]) coerce(s:%):OutputForm == brace [x::OutputForm for x in parts s]$List(OutputForm) @@ -2175,7 +2175,7 @@ OneDimensionalArrayAggregate(S:Type): Category == concat l == empty? l => empty() - n := _+/[#a for a in l] + n := +/[#a for a in l] i := minIndex(r := new(n, stupidget l)) for a in l repeat copyInto_!(r, a, i) @@ -2683,7 +2683,7 @@ import OneDimensionalArrayAggregate Boolean ++ quantities of Boolean data. BitAggregate(): Category == Join(OrderedSet, Logic, OneDimensionalArrayAggregate Boolean) with - "not": % -> % + not: % -> % ++ not(b) returns the logical {\em not} of bit aggregate ++ \axiom{b}. nand : (%, %) -> % @@ -2692,10 +2692,10 @@ BitAggregate(): Category == nor : (%, %) -> % ++ nor(a,b) returns the logical {\em nor} of bit aggregates \axiom{a} and ++ \axiom{b}. - _and : (%, %) -> % + and : (%, %) -> % ++ a and b returns the logical {\em and} of bit aggregates \axiom{a} and ++ \axiom{b}. - _or : (%, %) -> % + or : (%, %) -> % ++ a or b returns the logical {\em or} of bit aggregates \axiom{a} and ++ \axiom{b}. xor : (%, %) -> % @@ -2704,9 +2704,9 @@ BitAggregate(): Category == add not v == map(_not, v) - _~(v) == map(_~, v) - _/_\(v, u) == map(_/_\, v, u) - _\_/(v, u) == map(_\_/, v, u) + ~ v == map(_~, v) + v /\ u == map(_/_\, v, u) + v \/ u == map(_\_/, v, u) nand(v, u) == map(nand, v, u) nor(v, u) == map(nor, v, u) diff --git a/src/algebra/algcat.spad.pamphlet b/src/algebra/algcat.spad.pamphlet index 94fde902..a9ff5e97 100644 --- a/src/algebra/algcat.spad.pamphlet +++ b/src/algebra/algcat.spad.pamphlet @@ -83,7 +83,7 @@ FiniteRankAlgebra(R:CommutativeRing, UP:UnivariatePolynomialCategory R): represents(v, b) == m := minIndex v - 1 - _+/[v(i+m) * b(i+m) for i in 1..rank()] + +/[v(i+m) * b(i+m) for i in 1..rank()] traceMatrix v == matrix [[trace(v.i*v.j) for j in minIndex v..maxIndex v]$List(R) diff --git a/src/algebra/algfunc.spad.pamphlet b/src/algebra/algfunc.spad.pamphlet index abe4bd82..755339b4 100644 --- a/src/algebra/algfunc.spad.pamphlet +++ b/src/algebra/algfunc.spad.pamphlet @@ -327,7 +327,7 @@ AlgebraicFunction(R, F): Exports == Implementation where ++ droot(l) should be a non-exported function. -- un-export when the compiler accepts conditional local functions! if R has RetractableTo Integer then - "**" : (F, Q) -> F + ** : (F, Q) -> F ++ x ** q is \spad{x} raised to the rational power \spad{q}. minPoly: K -> UP ++ minPoly(k) returns the defining polynomial of \spad{k}. diff --git a/src/algebra/alql.spad.pamphlet b/src/algebra/alql.spad.pamphlet index edcae0c5..861ceefe 100644 --- a/src/algebra/alql.spad.pamphlet +++ b/src/algebra/alql.spad.pamphlet @@ -119,9 +119,9 @@ Database(S): Exports == Implementation where ++ elt(db,q) returns all elements of \axiom{db} which satisfy \axiom{q}. elt: (%,Symbol) -> DataList String ++ elt(db,s) returns the \axiom{s} field of each element of \axiom{db}. - _+: (%,%) -> % + +: (%,%) -> % ++ db1+db2 returns the merge of databases db1 and db2 - _-: (%,%) -> % + -: (%,%) -> % ++ db1-db2 returns the difference of databases db1 and db2 i.e. consisting ++ of elements in db1 but not in db2 display: % -> Void diff --git a/src/algebra/any.spad.pamphlet b/src/algebra/any.spad.pamphlet index 82771f68..0b7cd216 100644 --- a/src/algebra/any.spad.pamphlet +++ b/src/algebra/any.spad.pamphlet @@ -73,10 +73,10 @@ Maybe(T: CoercibleTo OutputForm): Public == Private where Public == Join(UnionType,RetractableTo T, CoercibleTo OutputForm) with just: T -> % ++ \spad{just x} injects the value `x' into %. - _case: (%,[| T |]) -> Boolean + case: (%,[| T |]) -> Boolean ++ \spad{x case T} returns true if \spad{x} is actually a data of ++ type \spad{T}. - _case: (%,[| nothing |]) -> Boolean + case: (%,[| nothing |]) -> Boolean ++ \spad{x case nothing} holds if the value for \spad{x} is missing. autoCoerce: % -> T ++ \spad{autoCoerce} is a courtesy coercion function used by the diff --git a/src/algebra/card.spad.pamphlet b/src/algebra/card.spad.pamphlet index e6ffb393..4ab212af 100644 --- a/src/algebra/card.spad.pamphlet +++ b/src/algebra/card.spad.pamphlet @@ -60,10 +60,10 @@ CardinalNumber: Join(OrderedSet, AbelianMonoid, Monoid, commutative "*" ++ a domain D has \spad{commutative("*")} if it has an operation ++ \spad{"*": (D,D) -> D} which is commutative. - "-": (%,%) -> Union(%,"failed") + -: (%,%) -> Union(%,"failed") ++ \spad{x - y} returns an element z such that \spad{z+y=x} or "failed" ++ if no such element exists. - "**": (%, %) -> % + **: (%, %) -> % ++ \spad{x**y} returns \spad{#(X**Y)} where \spad{X**Y} is defined ++ as \spad{\{g| g:Y->X\}}. diff --git a/src/algebra/carten.spad.pamphlet b/src/algebra/carten.spad.pamphlet index 064b0865..8b00959a 100644 --- a/src/algebra/carten.spad.pamphlet +++ b/src/algebra/carten.spad.pamphlet @@ -40,19 +40,19 @@ GradedModule(R: CommutativeRing, E: AbelianMonoid): Category == ++ of a given degree form an R-module. 0: constant -> % ++ 0 denotes the zero of degree 0. - _*: (R, %) -> % + *: (R, %) -> % ++ r*g is left module multiplication. - _*: (%, R) -> % + *: (%, R) -> % ++ g*r is right module multiplication. - _-: % -> % + -: % -> % ++ -g is the additive inverse of g in the module of elements ++ of the same grade as g. - _+: (%, %) -> % + +: (%, %) -> % ++ g+h is the sum of g and h in the module of elements of ++ the same degree as g and h. Error: if g and h ++ have different degrees. - _-: (%, %) -> % + -: (%, %) -> % ++ g-h is the difference of g and h in the module of elements of ++ the same degree as g and h. Error: if g and h ++ have different degrees. @@ -171,7 +171,7 @@ CartesianTensor(minix, dim, R): Exports == Implementation where ++ then \spad{r} is a rank 4 tensor given by ++ \spad{r(i,j,k,l) = s(i,j)*t(k,l)}. - "*": (%, %) -> % + *: (%, %) -> % ++ s*t is the inner product of the tensors s and t which contracts ++ the last index of s with the first index of t, i.e. ++ \spad{t*s = contract(t,rank t, s, 1)} diff --git a/src/algebra/catdef.spad.pamphlet b/src/algebra/catdef.spad.pamphlet index c7263464..602e3eb6 100644 --- a/src/algebra/catdef.spad.pamphlet +++ b/src/algebra/catdef.spad.pamphlet @@ -138,7 +138,7 @@ AbelianMonoid(): Category == AbelianSemiGroup with ++ sample yields a value of type % zero?: % -> Boolean ++ zero?(x) tests if x is equal to 0. - "*": (NonNegativeInteger,%) -> % + *: (NonNegativeInteger,%) -> % ++ n * x is left-multiplication by a non negative integer add import RepeatedDoubling(%) @@ -176,8 +176,8 @@ import PositiveInteger ++ \spad{commutative("+":(%,%)->%)}\tab{30}\spad{ x+y = y+x } AbelianSemiGroup(): Category == SetCategory with --operations - "+": (%,%) -> % ++ x+y computes the sum of x and y. - "*": (PositiveInteger,%) -> % + +: (%,%) -> % ++ x+y computes the sum of x and y. + *: (PositiveInteger,%) -> % ++ n*x computes the left-multiplication of x by the positive integer n. ++ This is equivalent to adding x to itself n times. add @@ -234,10 +234,10 @@ import Boolean ++ \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. + =: (%,%) -> Boolean ++ x=y tests if x and y are equal. + ~=: (%,%) -> Boolean ++ x~=y tests if x and y are not equal. add - _~_=(x:%,y:%) : Boolean == not(x=y) + x:% ~= y:% == not(x=y) @ @@ -463,7 +463,7 @@ DifferentialExtension(R:Ring): Category == Ring with DivisionRing(): Category == Join(EntireRing, Algebra Fraction Integer) with - "**": (%,Integer) -> % + **: (%,Integer) -> % ++ x**n returns x raised to the integer power n. inv : % -> % ++ inv x returns the multiplicative inverse of x. @@ -548,10 +548,10 @@ EuclideanDomain(): Category == PrincipalIdealDomain with ++ \spad{quotient} and \spad{remainder}, ++ where the remainder is smaller (see \spadfunFrom{sizeLess?}{EuclideanDomain}) ++ than the divisor y. - "quo" : (%,%) -> % + quo : (%,%) -> % ++ x quo y is the same as \spad{divide(x,y).quotient}. ++ See \spadfunFrom{divide}{EuclideanDomain}. - "rem": (%,%) -> % + rem: (%,%) -> % ++ x rem y is the same as \spad{divide(x,y).remainder}. ++ See \spadfunFrom{divide}{EuclideanDomain}. extendedEuclidean: (%,%) -> Record(coef1:%,coef2:%,generator:%) @@ -692,7 +692,7 @@ EuclideanDomain(): Category == PrincipalIdealDomain with Field(): Category == Join(EuclideanDomain,UniqueFactorizationDomain, DivisionRing) with --operations - "/": (%,%) -> % + /: (%,%) -> % ++ x/y divides the element x by the element y. ++ Error: if y is 0. canonicalUnitNormal ++ either 0 or 1. @@ -875,9 +875,9 @@ GcdDomain(): Category == IntegralDomain with ++ \spad{rightInverse("*":(%,%)->%,inv)}\tab{30}\spad{ x*inv(x) = 1 } Group(): Category == Monoid with --operations - inv: % -> % ++ inv(x) returns the inverse of x. - "/": (%,%) -> % ++ x/y is the same as x times the inverse of y. - "**": (%,Integer) -> % ++ x**n returns x raised to the integer power n. + inv: % -> % ++ inv(x) returns the inverse of x. + /: (%,%) -> % ++ x/y is the same as x times the inverse of y. + **: (%,Integer) -> % ++ x**n returns x raised to the integer power n. unitsKnown ++ unitsKnown asserts that recip only returns ++ "failed" for non-units. conjugate: (%,%) -> % @@ -921,7 +921,7 @@ IntegralDomain(): Category == -- Join(CommutativeRing, Algebra(%:CommutativeRing), EntireRing) with Join(CommutativeRing, Algebra(%), EntireRing) with --operations - "exquo": (%,%) -> Union(%,"failed") + exquo: (%,%) -> Union(%,"failed") ++ exquo(a,b) either returns an element c such that ++ \spad{c*b=a} or "failed" if no such element can be found. unitNormal: % -> Record(unit:%,canonical:%,associate:%) @@ -946,7 +946,7 @@ IntegralDomain(): Category == if not (% has Field) then unitNormal(x) == [1$%,x,1$%]$UCA -- the non-canonical definition unitCanonical(x) == unitNormal(x).canonical -- always true - recip(x) == if zero? x then "failed" else _exquo(1$%,x) + recip(x) == if zero? x then "failed" else 1$% exquo x unit?(x) == (recip x case "failed" => false; true) if % has canonicalUnitNormal then associates?(x,y) == @@ -1062,7 +1062,7 @@ Monoid(): Category == SemiGroup with 1: constant -> % ++ 1 is the multiplicative identity. sample: constant -> % ++ sample yields a value of type % one?: % -> Boolean ++ one?(x) tests if x is equal to 1. - "**": (%,NonNegativeInteger) -> % ++ x**n returns the repeated product + **: (%,NonNegativeInteger) -> % ++ x**n returns the repeated product ++ of x n times, i.e. exponentiation. recip: % -> Union(%,"failed") ++ recip(x) tries to compute the multiplicative inverse for x @@ -1330,13 +1330,13 @@ import Boolean OrderedSet(): Category == SetCategory with --operations - "<": (%,%) -> Boolean + <: (%,%) -> Boolean ++ x < y is a strict total ordering on the elements of the set. - ">": (%, %) -> Boolean + >: (%, %) -> Boolean ++ x > y is a greater than test. - ">=": (%, %) -> Boolean + >=: (%, %) -> Boolean ++ x >= y is a greater than or equal test. - "<=": (%, %) -> Boolean + <=: (%, %) -> Boolean ++ x <= y is a less than or equal test. max: (%,%) -> % @@ -1651,9 +1651,9 @@ import PositiveInteger ++ \spad{commutative("*":(%,%)->%)}\tab{30}\spad{ x*y = y*x } SemiGroup(): Category == SetCategory with --operations - "*": (%,%) -> % ++ x*y returns the product of x and y. - "**": (%,PositiveInteger) -> % ++ x**n returns the repeated product - ++ of x n times, i.e. exponentiation. + *: (%,%) -> % ++ x*y returns the product of x and y. + **: (%,PositiveInteger) -> % ++ x**n returns the repeated product + ++ of x n times, i.e. exponentiation. add import RepeatedSquaring(%) x:% ** n:PositiveInteger == expt(x,n) @@ -1782,7 +1782,7 @@ UniqueFactorizationDomain(): Category == GcdDomain with ++ Vector Spaces (not necessarily finite dimensional) over a field. VectorSpace(S:Field): Category == Module(S) with - "/" : (%, S) -> % + / : (%, S) -> % ++ x/y divides the vector x by the scalar y. dimension: () -> CardinalNumber ++ dimension() returns the dimensionality of the vector space. diff --git a/src/algebra/color.spad.pamphlet b/src/algebra/color.spad.pamphlet index 74025c2d..b1a4963f 100644 --- a/src/algebra/color.spad.pamphlet +++ b/src/algebra/color.spad.pamphlet @@ -72,11 +72,11 @@ Color(): Exports == Implementation where SF ==> DoubleFloat Exports ==> AbelianSemiGroup with - "*" : (PI, %) -> % + * : (PI, %) -> % ++ s * c, returns the color c, whose weighted shade has been scaled by s. - "*" : (SF, %) -> % + * : (SF, %) -> % ++ s * c, returns the color c, whose weighted shade has been scaled by s. - "+" : (%, %) -> % + + : (%, %) -> % ++ c1 + c2 additively mixes the two colors c1 and c2. red : () -> % ++ red() returns the position of the red hue from total hues. diff --git a/src/algebra/combfunc.spad.pamphlet b/src/algebra/combfunc.spad.pamphlet index 25e7d3e4..a6c357a0 100644 --- a/src/algebra/combfunc.spad.pamphlet +++ b/src/algebra/combfunc.spad.pamphlet @@ -83,7 +83,7 @@ CombinatorialFunction(R, F): Exports == Implementation where ++ operator(op) returns a copy of op with the domain-dependent ++ properties appropriate for F; ++ error if op is not a combinatorial operator; - "**" : (F, F) -> F + ** : (F, F) -> F ++ a ** b is the formal exponential a**b; binomial : (F, F) -> F ++ binomial(n, r) returns the number of subsets of r objects diff --git a/src/algebra/cycles.spad.pamphlet b/src/algebra/cycles.spad.pamphlet index d5747f52..25b44b96 100644 --- a/src/algebra/cycles.spad.pamphlet +++ b/src/algebra/cycles.spad.pamphlet @@ -130,7 +130,7 @@ CycleIndicators: Exports == Implementation where else if i<0 then 0 else - _+/[(spol := trm(partition pt); even? pt => spol; -spol) + +/[(spol := trm(partition pt); even? pt => spol; -spol) for pt in list(partitions i)] divisors: I -> L I @@ -149,7 +149,7 @@ CycleIndicators: Exports == Implementation where cyc n == n = 1 => s 1 - _+/[(eulerPhi(i) / n) * ss(i,numer(n/i)) for i in divisors n] + +/[(eulerPhi(i) / n) * ss(i,numer(n/i)) for i in divisors n] dih n == k := n quo 2 @@ -175,7 +175,7 @@ CycleIndicators: Exports == Implementation where prod := c * prod2 * prod xx * prod - graphs n == _+/[trm2 li for li in list(partitions n)] + graphs n == +/[trm2 li for li in list(partitions n)] cupp: (PTN,SPOL RN) -> SPOL RN cupp(pt,spol) == @@ -206,7 +206,7 @@ CycleIndicators: Exports == Implementation where evspol(fn2,spol) == zero? spol => 0 lc := leadingCoefficient spol - prod := _*/[fn2 i for i in (degree spol)::L(I)] + prod := */[fn2 i for i in (degree spol)::L(I)] lc * prod + evspol(fn2,reductum spol) wreath(spol1,spol2) == evspol(mtpol(#1,spol2),spol1) @@ -269,7 +269,7 @@ EvaluateCycleIndicators(F):T==C where pt:PTN spol:SPOL RN i:I - evp(fn, pt)== _*/[fn i for i in pt::(L I)] + evp(fn, pt)== */[fn i for i in pt::(L I)] eval(fn,spol)== if spol=0 diff --git a/src/algebra/derham.spad.pamphlet b/src/algebra/derham.spad.pamphlet index 404df940..7ddca825 100644 --- a/src/algebra/derham.spad.pamphlet +++ b/src/algebra/derham.spad.pamphlet @@ -207,14 +207,14 @@ AntiSymm(R:Ring, lVar:List Symbol): Export == Implement where homogeneous? a == null a => true - siz := _+/exponents(a.first.base) + siz := +/exponents(a.first.base) for ta in reductum a repeat - _+/exponents(ta.base) ~= siz => return false + +/exponents(ta.base) ~= siz => return false true degree a == null a => 0$NNI - homogeneous? a => (_+/exponents(a.first.base)) :: NNI + homogeneous? a => (+/exponents(a.first.base)) :: NNI error "not a homogeneous element" zo : (I,I) -> L I @@ -230,7 +230,7 @@ AntiSymm(R:Ring, lVar:List Symbol): Export == Implement where yy:L I := exponents y for i in 1 .. (dim-1) repeat xx := rest xx - sgn := sgn + (_+/xx)*yy.i + sgn := sgn + (+/xx)*yy.i sgn rem 2 = 0 => 1 -1 diff --git a/src/algebra/dhmatrix.spad.pamphlet b/src/algebra/dhmatrix.spad.pamphlet index c6a968a3..9e847c42 100644 --- a/src/algebra/dhmatrix.spad.pamphlet +++ b/src/algebra/dhmatrix.spad.pamphlet @@ -1648,7 +1648,7 @@ DenavitHartenbergMatrix(R): Exports == Implementation where radians ==> pi()/180 Exports ==> MatrixCategory(R,row,col) with - "*": (%, Point R) -> Point R + *: (%, Point R) -> Point R ++ t*p applies the dhmatrix t to point p identity: () -> % ++ identity() create the identity dhmatrix diff --git a/src/algebra/domain.spad.pamphlet b/src/algebra/domain.spad.pamphlet index acaed108..32fb782d 100644 --- a/src/algebra/domain.spad.pamphlet +++ b/src/algebra/domain.spad.pamphlet @@ -354,8 +354,8 @@ SystemPredicate(): Public == Private where Private == add x = y == EQUAL(x,y)$Lisp coerce(x: %): OutputForm == - NOT(x)$Lisp => '_false::OutputForm - EQ(x,'T)$Lisp => '_true::OutputForm + NOT(x)$Lisp => 'false::OutputForm + EQ(x,'T)$Lisp => 'true::OutputForm EQCAR(x,'NOT)$Lisp => not(CADR(x)$Lisp : % :: OutputForm) @ diff --git a/src/algebra/efuls.spad.pamphlet b/src/algebra/efuls.spad.pamphlet index 41b26583..7db8e269 100644 --- a/src/algebra/efuls.spad.pamphlet +++ b/src/algebra/efuls.spad.pamphlet @@ -40,7 +40,7 @@ ElementaryFunctionsUnivariateLaurentSeries(Coef,UTS,ULS):_ Exports ==> PartialTranscendentalFunctions(ULS) with if Coef has Field then - "**": (ULS,RN) -> ULS + **: (ULS,RN) -> ULS ++ s ** r raises a Laurent series s to a rational power r --% Exponentials and Logarithms diff --git a/src/algebra/efupxs.spad.pamphlet b/src/algebra/efupxs.spad.pamphlet index cbf67b4a..21be2b9f 100644 --- a/src/algebra/efupxs.spad.pamphlet +++ b/src/algebra/efupxs.spad.pamphlet @@ -39,7 +39,7 @@ ElementaryFunctionsUnivariatePuiseuxSeries(Coef,ULS,UPXS,EFULS):_ Exports ==> PartialTranscendentalFunctions(UPXS) with if Coef has Field then - "**": (UPXS,RN) -> UPXS + **: (UPXS,RN) -> UPXS ++ z ** r raises a Puiseaux series z to a rational power r --% Exponentials and Logarithms diff --git a/src/algebra/equation2.spad.pamphlet b/src/algebra/equation2.spad.pamphlet index a621d9f9..9faf2bbc 100644 --- a/src/algebra/equation2.spad.pamphlet +++ b/src/algebra/equation2.spad.pamphlet @@ -51,7 +51,7 @@ import List Equation(S: Type): public == private where Ex ==> OutputForm public ==> Type with - "=": (S, S) -> $ + =: (S, S) -> $ ++ a=b creates an equation. equation: (S, S) -> $ ++ equation(a,b) creates an equation. @@ -76,10 +76,10 @@ Equation(S: Type): public == private where ++ eval(eqn, [x1=v1, ... xn=vn]) replaces xi by vi in equation eqn. if S has AbelianSemiGroup then AbelianSemiGroup - "+": (S, $) -> $ + +: (S, $) -> $ ++ x+eqn produces a new equation by adding x to both sides of ++ equation eqn. - "+": ($, S) -> $ + +: ($, S) -> $ ++ eqn+x produces a new equation by adding x to both sides of ++ equation eqn. if S has AbelianGroup then @@ -88,18 +88,18 @@ Equation(S: Type): public == private where ++ leftZero(eq) subtracts the left hand side. rightZero : $ -> $ ++ rightZero(eq) subtracts the right hand side. - "-": (S, $) -> $ + -: (S, $) -> $ ++ x-eqn produces a new equation by subtracting both sides of ++ equation eqn from x. - "-": ($, S) -> $ + -: ($, S) -> $ ++ eqn-x produces a new equation by subtracting x from both sides of ++ equation eqn. if S has SemiGroup then SemiGroup - "*": (S, $) -> $ + *: (S, $) -> $ ++ x*eqn produces a new equation by multiplying both sides of ++ equation eqn by x. - "*": ($, S) -> $ + *: ($, S) -> $ ++ eqn*x produces a new equation by multiplying both sides of ++ equation eqn by x. if S has Monoid then @@ -129,7 +129,7 @@ Equation(S: Type): public == private where PartialDifferentialRing(Symbol) if S has Field then VectorSpace(S) - "/": ($, $) -> $ + /: ($, $) -> $ ++ e1/e2 produces a new equation by dividing the left and right ++ hand sides of equations e1 and e2. inv: $ -> $ diff --git a/src/algebra/ffcat.spad.pamphlet b/src/algebra/ffcat.spad.pamphlet index e7ae41ae..9669856f 100644 --- a/src/algebra/ffcat.spad.pamphlet +++ b/src/algebra/ffcat.spad.pamphlet @@ -423,7 +423,7 @@ FiniteAlgebraicExtensionField(F : Field) : Category == _ DiscreteLogarithmPackage(M): public == private where M : Join(Monoid,Finite) with - "**": (M,Integer) -> M + **: (M,Integer) -> M ++ x ** n returns x raised to the integer power n public ==> with shanksDiscLogAlgorithm:(M,M,NonNegativeInteger)-> _ diff --git a/src/algebra/ffnb.spad.pamphlet b/src/algebra/ffnb.spad.pamphlet index 8b9c7fbd..d37fe749 100644 --- a/src/algebra/ffnb.spad.pamphlet +++ b/src/algebra/ffnb.spad.pamphlet @@ -111,13 +111,13 @@ InnerNormalBasisFieldFunctions(GF): Exports == Implementation where -- the semantic of the following functions is obvious from the finite field -- context, for description see category FAXF - "**" :(VGF,I) -> VGF + ** :(VGF,I) -> VGF ++ x**n \undocumented{} ++ See \axiomFunFrom{**}{DivisionRing} - "*" :(VGF,VGF) -> VGF + * :(VGF,VGF) -> VGF ++ x*y \undocumented{} ++ See \axiomFunFrom{*}{SemiGroup} - "/" :(VGF,VGF) -> VGF + / :(VGF,VGF) -> VGF ++ x/y \undocumented{} ++ See \axiomFunFrom{/}{Field} norm :(VGF,PI) -> VGF diff --git a/src/algebra/float.spad.pamphlet b/src/algebra/float.spad.pamphlet index 52eba7cc..2f666a93 100644 --- a/src/algebra/float.spad.pamphlet +++ b/src/algebra/float.spad.pamphlet @@ -122,9 +122,9 @@ Float(): Join(FloatingPointSystem, DifferentialRing, ConvertibleTo String, OpenMath,_ CoercibleTo DoubleFloat, TranscendentalFunctionCategory, _ ConvertibleTo InputForm,ConvertibleFrom SF) with - _/ : (%, I) -> % + / : (%, I) -> % ++ x / i computes the division from x by an integer i. - _*_*: (%, %) -> % + **: (%, %) -> % ++ x ** y computes \spad{exp(y log x)} where \spad{x >= 0}. normalize: % -> % ++ normalize(x) normalizes x at current precision. diff --git a/src/algebra/forttyp.spad.pamphlet b/src/algebra/forttyp.spad.pamphlet index a3806331..99d1a1c6 100644 --- a/src/algebra/forttyp.spad.pamphlet +++ b/src/algebra/forttyp.spad.pamphlet @@ -59,7 +59,7 @@ FortranScalarType() : exports == implementation where ++ CHARACTER. logical? : $ -> Boolean ++ logical?(t) tests whether t is equivalent to the FORTRAN type LOGICAL. - "=" : ($,$) -> Boolean + = : ($,$) -> Boolean ++ x=y tests for equality implementation == add diff --git a/src/algebra/fparfrac.spad.pamphlet b/src/algebra/fparfrac.spad.pamphlet index 7d7c48a1..dee5330b 100644 --- a/src/algebra/fparfrac.spad.pamphlet +++ b/src/algebra/fparfrac.spad.pamphlet @@ -35,7 +35,7 @@ FullPartialFractionExpansion(F, UP): Exports == Implementation where FPF ==> Record(polyPart: UP, fracPart: List REC) Exports ==> Join(SetCategory, ConvertibleTo RF) with - "+": (UP, $) -> $ + +: (UP, $) -> $ ++ p + x returns the sum of p and x fullPartialFraction: RF -> $ ++ fullPartialFraction(f) returns \spad{[p, [[j, Dj, Hj]...]]} such that diff --git a/src/algebra/fraction.spad.pamphlet b/src/algebra/fraction.spad.pamphlet index 8e0ff164..64f656e6 100644 --- a/src/algebra/fraction.spad.pamphlet +++ b/src/algebra/fraction.spad.pamphlet @@ -28,9 +28,9 @@ Localize(M:Module R, R:CommutativeRing, S:SubsetCategory(Monoid, R)): Module R with if M has OrderedAbelianGroup then OrderedAbelianGroup - _/ :(%,S) -> % + / :(%,S) -> % ++ x / d divides the element x by d. - _/ :(M,S) -> % + / :(M,S) -> % ++ m / d divides the element m by d. numer: % -> M ++ numer x returns the numerator of x. @@ -94,9 +94,9 @@ LocalAlgebra(A: Algebra R, R: CommutativeRing, S: SubsetCategory(Monoid, R)): Algebra R with if A has OrderedRing then OrderedRing - _/ : (%,S) -> % + / : (%,S) -> % ++ x / d divides the element x by d. - _/ : (A,S) -> % + / : (A,S) -> % ++ a / d divides the element \spad{a} by d. numer: % -> A ++ numer x returns the numerator of x. @@ -126,7 +126,7 @@ QuotientFieldCategory(S: IntegralDomain): Category == Join(Field, Algebra S, RetractableTo S, FullyEvalableOver S, DifferentialExtension S, FullyLinearlyExplicitRingOver S, Patternable S, FullyPatternMatchable S) with - _/ : (S, S) -> % + / : (S, S) -> % ++ d1 / d2 returns the fraction d1 divided by d2. numer : % -> S ++ numer(x) returns the numerator of the fraction x. diff --git a/src/algebra/free.spad.pamphlet b/src/algebra/free.spad.pamphlet index c57b4c64..25f04f87 100644 --- a/src/algebra/free.spad.pamphlet +++ b/src/algebra/free.spad.pamphlet @@ -181,11 +181,11 @@ FreeMonoid(S: SetCategory): FMcategory == FMdefinition where Ex ==> OutputForm FMcategory ==> Join(Monoid, RetractableTo S) with - "*": (S, $) -> $ + *: (S, $) -> $ ++ s * x returns the product of x by s on the left. - "*": ($, S) -> $ + *: ($, S) -> $ ++ x * s returns the product of x by s on the right. - "**": (S, NonNegativeInteger) -> $ + **: (S, NonNegativeInteger) -> $ ++ s ** n returns the product of s by itself n times. hclf: ($, $) -> $ ++ hclf(x, y) returns the highest common left factor of x and y, @@ -355,11 +355,11 @@ FreeMonoid(S: SetCategory): FMcategory == FMdefinition where ++ the form \spad{reduce(*,[si ** ni])} where the si's are in S, and the ni's ++ are integers. The multiplication is not commutative. FreeGroup(S: SetCategory): Join(Group, RetractableTo S) with - "*": (S, $) -> $ + *: (S, $) -> $ ++ s * x returns the product of x by s on the left. - "*": ($, S) -> $ + *: ($, S) -> $ ++ x * s returns the product of x by s on the right. - "**" : (S, Integer) -> $ + ** : (S, Integer) -> $ ++ s ** n returns the product of s by itself n times. size : $ -> NonNegativeInteger ++ size(x) returns the number of monomials in x. @@ -418,9 +418,9 @@ FreeGroup(S: SetCategory): Join(Group, RetractableTo S) with ++ are in a given abelian monoid. The operation is commutative. FreeAbelianMonoidCategory(S: SetCategory, E:CancellationAbelianMonoid): Category == Join(CancellationAbelianMonoid, RetractableTo S) with - "+" : (S, $) -> $ + + : (S, $) -> $ ++ s + x returns the sum of s and x. - "*" : (E, S) -> $ + * : (E, S) -> $ ++ e * s returns e times s. size : $ -> NonNegativeInteger ++ size(x) returns the number of terms in x. diff --git a/src/algebra/fspace.spad.pamphlet b/src/algebra/fspace.spad.pamphlet index 1768016e..7d2a4eee 100644 --- a/src/algebra/fspace.spad.pamphlet +++ b/src/algebra/fspace.spad.pamphlet @@ -430,7 +430,7 @@ FunctionSpace(R: SetCategory): Category == Definition where if R has SemiGroup then Monoid -- the following line is necessary because of a compiler bug - "**" : (%, N) -> % + ** : (%, N) -> % ++ x**n returns x * x * x * ... * x (n times). isTimes: % -> Union(List %, "failed") ++ isTimes(p) returns \spad{[a1,...,an]} @@ -501,7 +501,7 @@ FunctionSpace(R: SetCategory): Category == Definition where ++ polynomial in the kernels over R. denominator : % -> % ++ denominator(f) returns the denominator of \spad{f} converted to %. - "/" : (MP, MP) -> % + / : (MP, MP) -> % ++ p1/p2 returns the quotient of p1 and p2 as an element of %. coerce : Q -> % ++ coerce(q) returns q as an element of %. diff --git a/src/algebra/gaussian.spad.pamphlet b/src/algebra/gaussian.spad.pamphlet index 2e7bd479..721e3b31 100644 --- a/src/algebra/gaussian.spad.pamphlet +++ b/src/algebra/gaussian.spad.pamphlet @@ -37,7 +37,7 @@ ComplexCategory(R:CommutativeRing): Category == norm : % -> R ++ norm(x) returns x * conjugate(x) if R has IntegralDomain then IntegralDomain - _exquo : (%,R) -> Union(%,"failed") + exquo : (%,R) -> Union(%,"failed") ++ exquo(x, r) returns the exact quotient of x by r, or ++ "failed" if r does not divide x exactly. if R has EuclideanDomain then EuclideanDomain @@ -251,13 +251,13 @@ ComplexCategory(R:CommutativeRing): Category == complex(real(x) / r, - imag(x) / r) if R has IntegralDomain then - _exquo(x:%, r:R) == + x:% exquo r:R == one? r => x (r1 := real(x) exquo r) case "failed" => "failed" (r2 := imag(x) exquo r) case "failed" => "failed" complex(r1, r2) - _exquo(x:%, y:%) == + x:% exquo y:% == zero? imag y => x exquo real y x * conjugate(y) exquo norm(y) @@ -612,7 +612,7 @@ Complex(R:CommutativeRing): ComplexCategory(R) with if R has IntegralDomain then - _exquo(x:%, y:%) == -- to correct bad defaulting problem + x:% exquo y:% == -- to correct bad defaulting problem zero? y.imag => x exquo y.real x * conjugate(y) exquo norm(y) @@ -763,7 +763,7 @@ ComplexIntegerSolveLinearPolynomialEquation(R,CR): C == T solveLinearPolynomialEquation(lp,p) == if (oldlp ~= lp) then -- we have to generate a new table - deg:= _+/[degree u for u in lp] + deg:= +/[degree u for u in lp] ans:Union(Vector List CP,"failed"):="failed" slpePrime:=67108859::R -- 2**26 -5 : a prime -- a good test case for this package is diff --git a/src/algebra/ideal.spad.pamphlet b/src/algebra/ideal.spad.pamphlet index fe5fb90a..565beacc 100644 --- a/src/algebra/ideal.spad.pamphlet +++ b/src/algebra/ideal.spad.pamphlet @@ -50,11 +50,11 @@ PolynomialIdeals(F,Expon,VarSet,DPoly) : C == T C == SetCategory with - "*" : (Ideal,Ideal) -> Ideal + * : (Ideal,Ideal) -> Ideal ++ I*J computes the product of the ideal I and J. - "**" : (Ideal,NNI) -> Ideal + ** : (Ideal,NNI) -> Ideal ++ I**n computes the nth power of the ideal I. - "+" : (Ideal,Ideal) -> Ideal + + : (Ideal,Ideal) -> Ideal ++ I+J computes the ideal generated by the union of I and J. one? : Ideal -> Boolean ++ one?(I) tests whether the ideal I is the unit ideal, diff --git a/src/algebra/idecomp.spad.pamphlet b/src/algebra/idecomp.spad.pamphlet index fe8b86f6..acc47a5f 100644 --- a/src/algebra/idecomp.spad.pamphlet +++ b/src/algebra/idecomp.spad.pamphlet @@ -317,7 +317,7 @@ IdealDecompositionPackage(vl,nv) : C == T -- take away nv, now doesn't genPosLastVar(J:FIdeal,truelist:List OV):GenPos == x := last truelist ;lv1:List OV :=remove(x,truelist) ranvals:List(Z):=[(random()$Z rem 23) for vv in lv1] - val:=_+/[rv*(vv::DPoly) for vv in lv1 for rv in ranvals] + val:=+/[rv*(vv::DPoly) for vv in lv1 for rv in ranvals] val:=val+(x::DPoly) [ranvals,groebnerIdeal(groebner([(univariate(p,x)).val for p in generators J]))]$GenPos @@ -327,7 +327,7 @@ IdealDecompositionPackage(vl,nv) : C == T -- take away nv, now doesn't backGenPos(I:FIdeal,lval:List Z,truelist:List OV) : FIdeal == lval=[] => I x := last truelist ;lv1:List OV:=remove(x,truelist) - val:=-(_+/[rv*(vv::DPoly) for vv in lv1 for rv in lval]) + val:=-(+/[rv*(vv::DPoly) for vv in lv1 for rv in lval]) val:=val+(x::DPoly) groebnerIdeal (groebner([(univariate(p,x)).val for p in generators I ])) diff --git a/src/algebra/intaux.spad.pamphlet b/src/algebra/intaux.spad.pamphlet index 8f103651..ada00a28 100644 --- a/src/algebra/intaux.spad.pamphlet +++ b/src/algebra/intaux.spad.pamphlet @@ -88,7 +88,7 @@ IntegrationResult(F:Field): Exports == Implementation where timene(r, ne) == [Q2F(r) * ne.integrand, ne.intvar] n:Z * u:% == (n::Q) * u Q2F r == numer(r)::F / denom(r)::F - neselect(l, x) == _+/[ne.integrand for ne in l | ne.intvar = x] + neselect(l, x) == +/[ne.integrand for ne in l | ne.intvar = x] if F has RetractableTo Symbol then integral(f:F, x:Symbol):% == integral(f, x::F) @@ -116,7 +116,7 @@ IntegrationResult(F:Field): Exports == Implementation where retractIfCan u == empty? logpart u => ratpart u + - _+/[integral(ne.integrand, retract(ne.intvar)@Symbol)$F + +/[integral(ne.integrand, retract(ne.intvar)@Symbol)$F for ne in notelem u] "failed" @@ -140,8 +140,8 @@ IntegrationResult(F:Field): Exports == Implementation where differentiate(u:%, derivation:F -> F):F == derivation ratpart u + - _+/[pLogDeriv(log, derivation) for log in logpart u] - + _+/[pNeDeriv(ne, derivation) for ne in notelem u] + +/[pLogDeriv(log, derivation) for log in logpart u] + + (+/[pNeDeriv(ne, derivation) for ne in notelem u]) pNeDeriv(ne, derivation) == one? derivation(ne.intvar) => ne.integrand diff --git a/src/algebra/integer.spad.pamphlet b/src/algebra/integer.spad.pamphlet index 6965144e..d8180ed4 100644 --- a/src/algebra/integer.spad.pamphlet +++ b/src/algebra/integer.spad.pamphlet @@ -43,7 +43,7 @@ IntegerSolveLinearPolynomialEquation(): C ==T solveLinearPolynomialEquation(lp,p) == if (oldlp ~= lp) then -- we have to generate a new table - deg:= _+/[degree u for u in lp] + deg:= +/[degree u for u in lp] ans:Union(Vector List ZP,"failed"):="failed" slpePrime:=2147483647::Integer -- 2**31 -1 : a prime -- a good test case for this package is @@ -250,10 +250,10 @@ Integer: Join(IntegerNumberSystem, ConvertibleTo String, OpenMath) with ++ Description: \spadtype{NonNegativeInteger} provides functions for non ++ negative integers. NonNegativeInteger: Join(OrderedAbelianMonoidSup,Monoid) with - _quo : (%,%) -> % + quo : (%,%) -> % ++ a quo b returns the quotient of \spad{a} and b, forgetting ++ the remainder. - _rem : (%,%) -> % + rem : (%,%) -> % ++ a rem b returns the remainder of \spad{a} and b. gcd : (%,%) -> % ++ gcd(a,b) computes the greatest common divisor of two @@ -261,7 +261,7 @@ NonNegativeInteger: Join(OrderedAbelianMonoidSup,Monoid) with divide: (%,%) -> Record(quotient:%,remainder:%) ++ divide(a,b) returns a record containing both ++ remainder and quotient. - _exquo: (%,%) -> Union(%,"failed") + exquo: (%,%) -> Union(%,"failed") ++ exquo(a,b) returns the quotient of \spad{a} and b, or "failed" ++ if b is zero or \spad{a} rem b is zero. shift: (%, Integer) -> % diff --git a/src/algebra/interval.spad.pamphlet b/src/algebra/interval.spad.pamphlet index a15715c9..db070f59 100644 --- a/src/algebra/interval.spad.pamphlet +++ b/src/algebra/interval.spad.pamphlet @@ -131,7 +131,7 @@ Interval(R:Join(FloatingPointSystem,TranscendentalFunctionCategory)): IntervalCa positive?(u:%):Boolean == inf(u) > 0 negative?(u:%):Boolean == sup(u) < 0 - _< (a:%,b:%):Boolean == + a:% < b:% == if inf(a) < inf(b) then true else if inf(a) > inf(b) then @@ -139,19 +139,19 @@ Interval(R:Join(FloatingPointSystem,TranscendentalFunctionCategory)): IntervalCa else sup(a) < sup(b) - _+ (a:%,b:%):% == + a:% + b:% == -- A couple of blatent hacks to preserve the Ring Axioms! if zero?(a) then return(b) else if zero?(b) then return(a) if a = b then return qinterval(2*inf(a),2*sup(a)) qinterval(inf(a) + inf(b), sup(a) + sup(b)) - _- (a:%,b:%):% == + a:% - b:% == if zero?(a) then return(-b) else if zero?(b) then return(a) if a = b then 0 else qinterval(inf(a) - sup(b), sup(a) - inf(b)) - _* (a:%,b:%):% == + a:% * b:% == -- A couple of blatent hacks to preserve the Ring Axioms! if one?(a) then return(b) else if one?(b) then return(a) if zero?(a) then return(0) else if zero?(b) then return(0) @@ -160,7 +160,7 @@ Interval(R:Join(FloatingPointSystem,TranscendentalFunctionCategory)): IntervalCa qinterval(first prods, last prods) - _* (a:Integer,b:%):% == + a:Integer * b:% == if (a > 0) then qinterval(a*inf(b),a*sup(b)) else if (a < 0) then @@ -168,18 +168,18 @@ Interval(R:Join(FloatingPointSystem,TranscendentalFunctionCategory)): IntervalCa else 0 - _* (a:PositiveInteger,b:%):% == qinterval(a*inf(b),a*sup(b)) + a:PositiveInteger * b:% == qinterval(a*inf(b),a*sup(b)) - _*_* (a:%,n:PositiveInteger):% == + a:% ** n:PositiveInteger == contains?(a,0) and zero?((n pretend Integer) rem 2) => interval(0,max(inf(a)**n,sup(a)**n)) interval(inf(a)**n,sup(a)**n) - _- (a:%):% == exactInterval(-sup(a),-inf(a)) + -(a:%) == exactInterval(-sup(a),-inf(a)) - _= (a:%,b:%):Boolean == (inf(a)=inf(b)) and (sup(a)=sup(b)) - _~_= (a:%,b:%):Boolean == (inf(a)~=inf(b)) or (sup(a)~=sup(b)) + a:% = b:% == (inf(a)=inf(b)) and (sup(a)=sup(b)) + a:% ~= b:% == (inf(a)~=inf(b)) or (sup(a)~=sup(b)) 1 == one : R := normaliseFloat 1 @@ -195,7 +195,7 @@ Interval(R:Join(FloatingPointSystem,TranscendentalFunctionCategory)): IntervalCa unit?(u:%):Boolean == contains?(u,0) - _exquo(u:%,v:%):Union(%,"failed") == + (u:% exquo v:%): Union(%,"failed") == contains?(v,0) => "failed" one?(v) => u u=v => 1 @@ -256,7 +256,7 @@ Interval(R:Join(FloatingPointSystem,TranscendentalFunctionCategory)): IntervalCa exp(u:%):% == qinterval(exp inf u, exp sup u) - _*_* (u:%,v:%):% == + u:% ** v:% == zero?(v) => if zero?(u) then error "0**0 is undefined" else 1 one?(u) => 1 expts : List R := sort [inf(u)**inf(v),sup(u)**sup(v), @@ -490,7 +490,7 @@ Interval(R:Join(FloatingPointSystem,TranscendentalFunctionCategory)): IntervalCa -- From RadicalCategory - _*_* (u:%,n:Fraction Integer):% == interval(inf(u)**n,sup(u)**n) + u:% ** n:Fraction Integer == interval(inf(u)**n,sup(u)**n) @ \section{License} diff --git a/src/algebra/mappkg.spad.pamphlet b/src/algebra/mappkg.spad.pamphlet index 133f28fe..17f1dab3 100644 --- a/src/algebra/mappkg.spad.pamphlet +++ b/src/algebra/mappkg.spad.pamphlet @@ -112,7 +112,7 @@ MappingPackage1(A:SetCategory): MPcat == MPdef where id: A -> A ++\spad{id x} is \spad{x}. - "**": (A->A, NNI) -> (A->A) + **: (A->A, NNI) -> (A->A) ++\spad{f**n} is the function which is the n-fold application ++ of \spad{f}. @@ -220,7 +220,7 @@ MappingPackage3(A:SetCategory, B:SetCategory, C:SetCategory):_ ++\spad{twist(f)} is the function \spad{g} ++ such that \spad{g (a,b)= f(b,a)}. - "*": (B->C, A->B) -> (A->C) + *: (B->C, A->B) -> (A->C) ++\spad{f*g} is the function \spad{h} ++ such that \spad{h x= f(g x)}. diff --git a/src/algebra/matcat.spad.pamphlet b/src/algebra/matcat.spad.pamphlet index 97af1385..0be83d9a 100644 --- a/src/algebra/matcat.spad.pamphlet +++ b/src/algebra/matcat.spad.pamphlet @@ -143,40 +143,40 @@ MatrixCategory(R,Row,Col): Category == Definition where --% Arithmetic - "+": (%,%) -> % + +: (%,%) -> % ++ \spad{x + y} is the sum of the matrices x and y. ++ Error: if the dimensions are incompatible. - "-": (%,%) -> % + -: (%,%) -> % ++ \spad{x - y} is the difference of the matrices x and y. ++ Error: if the dimensions are incompatible. - "-": % -> % + -: % -> % ++ \spad{-x} returns the negative of the matrix x. - "*": (%,%) -> % + *: (%,%) -> % ++ \spad{x * y} is the product of the matrices x and y. ++ Error: if the dimensions are incompatible. - "*": (R,%) -> % + *: (R,%) -> % ++ \spad{r*x} is the left scalar multiple of the scalar r and the ++ matrix x. - "*": (%,R) -> % + *: (%,R) -> % ++ \spad{x * r} is the right scalar multiple of the scalar r and the ++ matrix x. - "*": (Integer,%) -> % + *: (Integer,%) -> % ++ \spad{n * x} is an integer multiple. - "*": (%,Col) -> Col + *: (%,Col) -> Col ++ \spad{x * c} is the product of the matrix x and the column vector c. ++ Error: if the dimensions are incompatible. - "*": (Row,%) -> Row + *: (Row,%) -> Row ++ \spad{r * x} is the product of the row vector r and the matrix x. ++ Error: if the dimensions are incompatible. - "**": (%,NonNegativeInteger) -> % + **: (%,NonNegativeInteger) -> % ++ \spad{x ** n} computes a non-negative integral power of the matrix x. ++ Error: if the matrix is not square. if R has IntegralDomain then - "exquo": (%,R) -> Union(%,"failed") + exquo: (%,R) -> Union(%,"failed") ++ \spad{exquo(m,r)} computes the exact quotient of the elements ++ of m by r, returning \axiom{"failed"} if this is not possible. if R has Field then - "/": (%,R) -> % + /: (%,R) -> % ++ \spad{m/r} divides the elements of m by r. Error: if \spad{r = 0}. --% Linear algebra @@ -205,7 +205,7 @@ MatrixCategory(R,Row,Col): Category == Definition where ++ \spad{inverse(m)} returns the inverse of the matrix m. ++ If the matrix is not invertible, "failed" is returned. ++ Error: if the matrix is not square. - "**": (%,Integer) -> % + **: (%,Integer) -> % ++ \spad{m**n} computes an integral power of the matrix m. ++ Error: if matrix is not square or if the matrix ++ is square but not invertible. @@ -651,11 +651,11 @@ RectangularMatrixCategory(m,n,R,Row,Col): Category == Definition where --% Arithmetic if R has IntegralDomain then - "exquo": (%,R) -> Union(%,"failed") + exquo: (%,R) -> Union(%,"failed") ++ \spad{exquo(m,r)} computes the exact quotient of the elements ++ of m by r, returning \axiom{"failed"} if this is not possible. if R has Field then - "/": (%,R) -> % + /: (%,R) -> % ++ \spad{m/r} divides the elements of m by r. Error: if \spad{r = 0}. --% Linear algebra @@ -748,10 +748,10 @@ SquareMatrixCategory(ndim,R,Row,Col): Category == Definition where diagonalProduct: % -> R ++ \spad{diagonalProduct(m)} returns the product of the elements on the ++ diagonal of the matrix m. - "*": (%,Col) -> Col + *: (%,Col) -> Col ++ \spad{x * c} is the product of the matrix x and the column vector c. ++ Error: if the dimensions are incompatible. - "*": (Row,%) -> Row + *: (Row,%) -> Row ++ \spad{r * x} is the product of the row vector r and the matrix x. ++ Error: if the dimensions are incompatible. @@ -768,7 +768,7 @@ SquareMatrixCategory(ndim,R,Row,Col): Category == Definition where inverse: % -> Union(%,"failed") ++ \spad{inverse(m)} returns the inverse of the matrix m, if that ++ matrix is invertible and returns "failed" otherwise. - "**": (%,Integer) -> % + **: (%,Integer) -> % ++ \spad{m**n} computes an integral power of the matrix m. ++ Error: if the matrix is not invertible. diff --git a/src/algebra/matstor.spad.pamphlet b/src/algebra/matstor.spad.pamphlet index d0a1841f..5a77c5be 100644 --- a/src/algebra/matstor.spad.pamphlet +++ b/src/algebra/matstor.spad.pamphlet @@ -70,7 +70,7 @@ StorageEfficientMatrixOperations(R): Exports == Implementation where ++ \spad{a}. The matrices b and c are used to store intermediate results. ++ Error: if \spad{a}, b, c, and m are not square ++ and of the same dimensions. - "**" : (M,NNI) -> M + ** : (M,NNI) -> M ++ \spad{x ** n} computes the n-th power ++ of a square matrix. The power n is assumed greater than 1. diff --git a/src/algebra/mkfunc.spad.pamphlet b/src/algebra/mkfunc.spad.pamphlet index 1770e7c8..f53272e1 100644 --- a/src/algebra/mkfunc.spad.pamphlet +++ b/src/algebra/mkfunc.spad.pamphlet @@ -43,15 +43,15 @@ InputForm(): ++ \spad{lambda(code, [x1,...,xn])} returns the input form ++ corresponding to \spad{(x1,...,xn) +-> code} if \spad{n > 1}, ++ or to \spad{x1 +-> code} if \spad{n = 1}. - "+" : (%, %) -> % + + : (%, %) -> % ++ \spad{a + b} returns the input form corresponding to \spad{a + b}. - "*" : (%, %) -> % + * : (%, %) -> % ++ \spad{a * b} returns the input form corresponding to \spad{a * b}. - "/" : (%, %) -> % + / : (%, %) -> % ++ \spad{a / b} returns the input form corresponding to \spad{a / b}. - "**" : (%, NonNegativeInteger) -> % + ** : (%, NonNegativeInteger) -> % ++ \spad{a ** b} returns the input form corresponding to \spad{a ** b}. - "**" : (%, Integer) -> % + ** : (%, Integer) -> % ++ \spad{a ** b} returns the input form corresponding to \spad{a ** b}. 0 : constant -> % ++ \spad{0} returns the input form corresponding to 0. diff --git a/src/algebra/modmonom.spad.pamphlet b/src/algebra/modmonom.spad.pamphlet index b91555eb..43117395 100644 --- a/src/algebra/modmonom.spad.pamphlet +++ b/src/algebra/modmonom.spad.pamphlet @@ -74,7 +74,7 @@ GeneralModulePolynomial(vl, R, IS, E, ff, P): public == private where ++ build(r,i,e) \undocumented multMonom: (R, E, $) -> $ ++ multMonom(r,e,x) \undocumented - "*": (P,$) -> $ + *: (P,$) -> $ ++ p*x \undocumented diff --git a/src/algebra/mts.spad.pamphlet b/src/algebra/mts.spad.pamphlet index 35399ac6..517d0d74 100644 --- a/src/algebra/mts.spad.pamphlet +++ b/src/algebra/mts.spad.pamphlet @@ -60,7 +60,7 @@ SparseMultivariateTaylorSeries(Coef,Var,SMP):_ coerce: SMP -> % ++ \spad{coerce(poly)} regroups the terms by total degree and forms ++ a series. - "*":(SMP,%)->% + *:(SMP,%)->% ++\spad{smp*ts} multiplies a TaylorSeries by a monomial SMP. csubst:(L Var,L StS) -> (SMP -> StS) ++\spad{csubst(a,b)} is for internal use only diff --git a/src/algebra/naalgc.spad.pamphlet b/src/algebra/naalgc.spad.pamphlet index cae5d5ea..9593ca63 100644 --- a/src/algebra/naalgc.spad.pamphlet +++ b/src/algebra/naalgc.spad.pamphlet @@ -28,7 +28,7 @@ ++ with a binary operation. Monad(): Category == SetCategory with --operations - "*": (%,%) -> % + *: (%,%) -> % ++ a*b is the product of \spad{a} and b in a set with ++ a binary operation. rightPower: (%,PositiveInteger) -> % @@ -39,7 +39,7 @@ Monad(): Category == SetCategory with ++ leftPower(a,n) returns the \spad{n}-th left power of \spad{a}, ++ i.e. \spad{leftPower(a,n) := a * leftPower(a,n-1)} and ++ \spad{leftPower(a,1) := a}. - "**": (%,PositiveInteger) -> % + **: (%,PositiveInteger) -> % ++ a**n returns the \spad{n}-th power of \spad{a}, ++ defined by repeated squaring. add diff --git a/src/algebra/opalg.spad.pamphlet b/src/algebra/opalg.spad.pamphlet index 19a4a9dc..cad0a61c 100644 --- a/src/algebra/opalg.spad.pamphlet +++ b/src/algebra/opalg.spad.pamphlet @@ -50,9 +50,9 @@ ModuleOperator(R: Ring, M:LeftModule(R)): Exports == Implementation where ++ any \spad{a} in M and integer \spad{n > 0}. evaluateInverse: ($, M -> M) -> $ ++ evaluateInverse(x,f) \undocumented - "**": (OP, Integer) -> $ + **: (OP, Integer) -> $ ++ op**n \undocumented - "**": ($, Integer) -> $ + **: ($, Integer) -> $ ++ op**n \undocumented opeval : (OP, M) -> M ++ opeval should be local but conditional diff --git a/src/algebra/ore.spad.pamphlet b/src/algebra/ore.spad.pamphlet index 87268627..e026440c 100644 --- a/src/algebra/ore.spad.pamphlet +++ b/src/algebra/ore.spad.pamphlet @@ -52,7 +52,7 @@ UnivariateSkewPolynomialCategory(R:Ring): ++ given by \spad{x m = c sigma(m) + delta(m)}. if R has CommutativeRing then Algebra R if R has IntegralDomain then - "exquo": (%, R) -> Union(%, "failed") + exquo: (%, R) -> Union(%, "failed") ++ exquo(l, a) returns the exact quotient of l by a, ++ returning \axiom{"failed"} if this is not possible. monicLeftDivide: (%, %) -> Record(quotient: %, remainder: %) diff --git a/src/algebra/outform.spad.pamphlet b/src/algebra/outform.spad.pamphlet index fff28e68..a1993fcb 100644 --- a/src/algebra/outform.spad.pamphlet +++ b/src/algebra/outform.spad.pamphlet @@ -431,43 +431,43 @@ OutputForm(): SetCategory with ++ blankSeparate(l) creates the form separating the elements of l ++ by blanks. --% Specific applications - "=": (%, %) -> % + =: (%, %) -> % ++ f = g creates the equivalent infix form. - "~=": (%, %) -> % + ~=: (%, %) -> % ++ f ~= g creates the equivalent infix form. - "<": (%, %) -> % + <: (%, %) -> % ++ f < g creates the equivalent infix form. - ">": (%, %) -> % + >: (%, %) -> % ++ f > g creates the equivalent infix form. - "<=": (%, %) -> % + <=: (%, %) -> % ++ f <= g creates the equivalent infix form. - ">=": (%, %) -> % + >=: (%, %) -> % ++ f >= g creates the equivalent infix form. - "+": (%, %) -> % + +: (%, %) -> % ++ f + g creates the equivalent infix form. - "-": (%, %) -> % + -: (%, %) -> % ++ f - g creates the equivalent infix form. - "-": (%) -> % + -: (%) -> % ++ - f creates the equivalent prefix form. - "*": (%, %) -> % + *: (%, %) -> % ++ f * g creates the equivalent infix form. - "/": (%, %) -> % + /: (%, %) -> % ++ f / g creates the equivalent infix form. - "**": (%, %) -> % + **: (%, %) -> % ++ f ** g creates the equivalent infix form. - "div": (%, %) -> % + div: (%, %) -> % ++ f div g creates the equivalent infix form. - "rem": (%, %) -> % + rem: (%, %) -> % ++ f rem g creates the equivalent infix form. - "quo": (%, %) -> % + quo: (%, %) -> % ++ f quo g creates the equivalent infix form. - "exquo": (%, %) -> % + exquo: (%, %) -> % ++ exquo(f,g) creates the equivalent infix form. - "and": (%, %) -> % + and: (%, %) -> % ++ f and g creates the equivalent infix form. - "or": (%, %) -> % + or: (%, %) -> % ++ f or g creates the equivalent infix form. - "not": (%) -> % + not: (%) -> % ++ not f creates the equivalent prefix form. SEGMENT: (%,%) -> % ++ SEGMENT(x,y) creates the infix form: \spad{x..y}. diff --git a/src/algebra/pattern.spad.pamphlet b/src/algebra/pattern.spad.pamphlet index 031c6167..a0e4c3a0 100644 --- a/src/algebra/pattern.spad.pamphlet +++ b/src/algebra/pattern.spad.pamphlet @@ -80,15 +80,15 @@ Pattern(R:SetCategory): Exports == Implementation where ++ "failed" otherwise. elt : (BOP, List %) -> % ++ \spad{elt(op, [a1,...,an])} returns \spad{op(a1,...,an)}. - "+" : (%, %) -> % + + : (%, %) -> % ++ \spad{a + b} returns the pattern \spad{a + b}. - "*" : (%, %) -> % + * : (%, %) -> % ++ \spad{a * b} returns the pattern \spad{a * b}. - "**" : (%, NonNegativeInteger) -> % + ** : (%, NonNegativeInteger) -> % ++ \spad{a ** n} returns the pattern \spad{a ** n}. - "**" : (%, %) -> % + ** : (%, %) -> % ++ \spad{a ** b} returns the pattern \spad{a ** b}. - "/" : (%, %) -> % + / : (%, %) -> % ++ \spad{a / b} returns the pattern \spad{a / b}. depth : % -> NonNegativeInteger ++ depth(p) returns the nesting level of p. diff --git a/src/algebra/perm.spad.pamphlet b/src/algebra/perm.spad.pamphlet index e0f014d1..5679493f 100644 --- a/src/algebra/perm.spad.pamphlet +++ b/src/algebra/perm.spad.pamphlet @@ -47,7 +47,7 @@ PermutationCategory(S:SetCategory): Category == Group with ++ orbit(p, el) returns the orbit of {\em el} under the ++ permutation p, i.e. the set which is given by applications of ++ the powers of p to {\em el}. - "<" : (%,%) -> Boolean + < : (%,%) -> Boolean ++ p < q is an order relation on permutations. ++ Note: this order is only total if and only if S is totally ordered ++ or S is finite. diff --git a/src/algebra/permgrps.spad.pamphlet b/src/algebra/permgrps.spad.pamphlet index 69c4be03..e987cc77 100644 --- a/src/algebra/permgrps.spad.pamphlet +++ b/src/algebra/permgrps.spad.pamphlet @@ -118,10 +118,10 @@ PermutationGroup(S:SetCategory): public == private where ++ represented by the indices of the list, given by {\em generators}. movedPoints : % -> FSET S ++ movedPoints(gp) returns the points moved by the group {\em gp}. - "<" : (%,%) -> B + < : (%,%) -> B ++ gp1 < gp2 returns true if and only if {\em gp1} ++ is a proper subgroup of {\em gp2}. - "<=" : (%,%) -> B + <= : (%,%) -> B ++ gp1 <= gp2 returns true if and only if {\em gp1} ++ is a subgroup of {\em gp2}. ++ Note: because of a bug in the parser you have to call this diff --git a/src/algebra/polycat.spad.pamphlet b/src/algebra/polycat.spad.pamphlet index 30d77de8..e4a5dce3 100644 --- a/src/algebra/polycat.spad.pamphlet +++ b/src/algebra/polycat.spad.pamphlet @@ -123,7 +123,7 @@ FiniteAbelianMonoidRing(R:Ring, E:OrderedAbelianMonoid): Category == ++ \spad{binomThmExpt(p,q,n)} returns \spad{(x+y)^n} ++ by means of the binomial theorem trick. if R has IntegralDomain then - "exquo": (%,R) -> Union(%,"failed") + exquo: (%,R) -> Union(%,"failed") ++ exquo(p,r) returns the exact quotient of polynomial p by r, or "failed" ++ if none exists. if R has GcdDomain then @@ -634,9 +634,9 @@ PolynomialCategoryLifting(E,Vars,R,P,S): Exports == Implementation where R : Ring P : PolynomialCategory(R, E, Vars) S : SetCategory with - "+" : (%, %) -> % - "*" : (%, %) -> % - "**": (%, NonNegativeInteger) -> % + + : (%, %) -> % + * : (%, %) -> % + **: (%, NonNegativeInteger) -> % Exports ==> with map: (Vars -> S, R -> S, P) -> S diff --git a/src/algebra/prs.spad.pamphlet b/src/algebra/prs.spad.pamphlet index e117eb99..38e3fc4c 100644 --- a/src/algebra/prs.spad.pamphlet +++ b/src/algebra/prs.spad.pamphlet @@ -191,10 +191,10 @@ PseudoRemainderSequence(R, polR) : Specification == Implementation where -- sub-routines exported for convenience ---------------------------- - "*" : (R, Vector(polR)) -> Vector(polR) + * : (R, Vector(polR)) -> Vector(polR) ++ \axiom{r * v} computes the product of \axiom{r} and \axiom{v} - "exquo" : (Vector(polR), R) -> Vector(polR) + exquo : (Vector(polR), R) -> Vector(polR) ++ \axiom{v exquo r} computes ++ the exact quotient of \axiom{v} by \axiom{r} diff --git a/src/algebra/pscat.spad.pamphlet b/src/algebra/pscat.spad.pamphlet index f09df15a..0930aa2b 100644 --- a/src/algebra/pscat.spad.pamphlet +++ b/src/algebra/pscat.spad.pamphlet @@ -227,7 +227,7 @@ UnivariateTaylorSeriesCategory(Coef): Category == Definition where ++ sum of all terms of f of degree d with \spad{k1 <= d <= k2}. if Coef has Field then - "**": (%,Coef) -> % + **: (%,Coef) -> % ++ \spad{f(x) ** a} computes a power of a power series. ++ When the coefficient ring is a field, we may raise a series ++ to an exponent from the coefficient ring provided that the diff --git a/src/algebra/sex.spad.pamphlet b/src/algebra/sex.spad.pamphlet index f5776682..42dfb0c9 100644 --- a/src/algebra/sex.spad.pamphlet +++ b/src/algebra/sex.spad.pamphlet @@ -70,7 +70,7 @@ SExpressionCategory(Str, Sym, Int, Flt, Expr): Category == Decl where ++ car((a1,...,an)) returns a1. cdr: % -> % ++ cdr((a1,...,an)) returns \spad{(a2,...,an)}. - "#": % -> Integer + #: % -> Integer ++ #((a1,...,an)) returns n. elt: (%, Integer) -> % ++ elt((a1,...,an), i) returns \spad{ai}. diff --git a/src/algebra/sf.spad.pamphlet b/src/algebra/sf.spad.pamphlet index 507957ad..93abae0d 100644 --- a/src/algebra/sf.spad.pamphlet +++ b/src/algebra/sf.spad.pamphlet @@ -42,7 +42,7 @@ RadicalCategory(): Category == with ++ sqrt(x) returns the square root of x. nthRoot: (%, Integer) -> % ++ nthRoot(x,n) returns the nth root of x. - _*_* : (%, Fraction Integer) -> % + ** : (%, Fraction Integer) -> % ++ x ** y is the rational exponentiation of x by the power y. add sqrt x == x ** inv(2::Fraction(Integer)) @@ -253,9 +253,9 @@ FloatingPointSystem(): Category == RealNumberSystem() with -- domain about the difference in speed between the two domains. DoubleFloat(): Join(FloatingPointSystem, DifferentialRing, OpenMath, TranscendentalFunctionCategory, ConvertibleTo InputForm) with - _/ : (%, Integer) -> % + / : (%, Integer) -> % ++ x / i computes the division from x by an integer i. - _*_* : (%,%) -> % + ** : (%,%) -> % ++ x ** y returns the yth power of x (equal to \spad{exp(y log x)}). exp1 : () -> % ++ exp1() returns the natural log base \spad{2.718281828...}. diff --git a/src/algebra/si.spad.pamphlet b/src/algebra/si.spad.pamphlet index 63e6c1db..1d18f7cd 100644 --- a/src/algebra/si.spad.pamphlet +++ b/src/algebra/si.spad.pamphlet @@ -201,9 +201,9 @@ SingleInteger(): Join(IntegerNumberSystem,OrderedFinite,Logic,OpenMath) with ++ \spad{noetherian} all ideals are finitely generated (in fact principal). -- bit operations - "not": % -> % + not: % -> % ++ not(n) returns the bit-by-bit logical {\em not} of the single integer n. - "xor": (%, %) -> % + xor: (%, %) -> % ++ xor(n,m) returns the bit-by-bit logical {\em xor} of ++ the single integers n and m. Not : % -> % @@ -281,8 +281,8 @@ SingleInteger(): Join(IntegerNumberSystem,OrderedFinite,Logic,OpenMath) with x = y == EQL(x,y)$Lisp ~ x == LOGNOT(x)$Lisp not(x) == LOGNOT(x)$Lisp - _/_\(x,y) == LOGAND(x,y)$Lisp - _\_/(x,y) == LOGIOR(x,y)$Lisp + x /\ y == LOGAND(x,y)$Lisp + x \/ y == LOGIOR(x,y)$Lisp Not(x) == LOGNOT(x)$Lisp And(x,y) == LOGAND(x,y)$Lisp Or(x,y) == LOGIOR(x,y)$Lisp diff --git a/src/algebra/sttaylor.spad.pamphlet b/src/algebra/sttaylor.spad.pamphlet index 42def454..febd20d1 100644 --- a/src/algebra/sttaylor.spad.pamphlet +++ b/src/algebra/sttaylor.spad.pamphlet @@ -48,29 +48,29 @@ StreamTaylorSeriesOperations(A): Exports == Implementation where YS ==> Y$ParadoxicalCombinatorsForStreams(A) UN ==> Union(ST A,"failed") Exports ==> with - "+" : (ST A,ST A) -> ST A + + : (ST A,ST A) -> ST A ++ a + b returns the power series sum of \spad{a} and \spad{b}: ++ \spad{[a0,a1,..] + [b0,b1,..] = [a0 + b0,a1 + b1,..]} - "-" : (ST A,ST A) -> ST A + - : (ST A,ST A) -> ST A ++ a - b returns the power series difference of \spad{a} and ++ \spad{b}: \spad{[a0,a1,..] - [b0,b1,..] = [a0 - b0,a1 - b1,..]} - "-" : ST A -> ST A + - : ST A -> ST A ++ - a returns the power series negative of \spad{a}: ++ \spad{- [a0,a1,...] = [- a0,- a1,...]} - "*" : (ST A,ST A) -> ST A + * : (ST A,ST A) -> ST A ++ a * b returns the power series (Cauchy) product of \spad{a} and b: ++ \spad{[a0,a1,...] * [b0,b1,...] = [c0,c1,...]} where ++ \spad{ck = sum(i + j = k,ai * bk)}. - "*" : (A,ST A) -> ST A + * : (A,ST A) -> ST A ++ r * a returns the power series scalar multiplication of r by \spad{a}: ++ \spad{r * [a0,a1,...] = [r * a0,r * a1,...]} - "*" : (ST A,A) -> ST A + * : (ST A,A) -> ST A ++ a * r returns the power series scalar multiplication of \spad{a} by r: ++ \spad{[a0,a1,...] * r = [a0 * r,a1 * r,...]} - "exquo" : (ST A,ST A) -> Union(ST A,"failed") + exquo : (ST A,ST A) -> Union(ST A,"failed") ++ exquo(a,b) returns the power series quotient of \spad{a} by b, ++ if the quotient exists, and "failed" otherwise - "/" : (ST A,ST A) -> ST A + / : (ST A,ST A) -> ST A ++ a / b returns the power series quotient of \spad{a} by b. ++ An error message is returned if \spad{b} is not invertible. ++ This function is used in fixed point computations. diff --git a/src/algebra/sttf.spad.pamphlet b/src/algebra/sttf.spad.pamphlet index 1cbc7038..b96dc31f 100644 --- a/src/algebra/sttf.spad.pamphlet +++ b/src/algebra/sttf.spad.pamphlet @@ -42,7 +42,7 @@ StreamTranscendentalFunctions(Coef): Exports == Implementation where ++ exp(st) computes the exponential of a power series st. log : ST -> ST ++ log(st) computes the log of a power series. - "**" : (ST,ST) -> ST + ** : (ST,ST) -> ST ++ st1 ** st2 computes the power of a power series st1 by another ++ power series st2. @@ -490,7 +490,7 @@ StreamTranscendentalFunctionsNonCommutative(Coef): _ ++ exp(st) computes the exponential of a power series st. log : ST -> ST ++ log(st) computes the log of a power series. - "**" : (ST,ST) -> ST + ** : (ST,ST) -> ST ++ st1 ** st2 computes the power of a power series st1 by another ++ power series st2. diff --git a/src/algebra/syntax.spad.pamphlet b/src/algebra/syntax.spad.pamphlet index b28ce3f4..3b1b0b73 100644 --- a/src/algebra/syntax.spad.pamphlet +++ b/src/algebra/syntax.spad.pamphlet @@ -101,16 +101,16 @@ Syntax(): Public == Private where compound?: % -> Boolean ++ compound? x is true when `x' is not an atomic syntax. - _case: (%, [|Integer|]) -> Boolean + case: (%, [|Integer|]) -> Boolean ++ x case Integer is true if `x' really is an Integer - _case: (%, [|DoubleFloat|]) -> Boolean + case: (%, [|DoubleFloat|]) -> Boolean ++ x case DoubleFloat is true if `x' really is a DoubleFloat - _case: (%, [|Identifier|]) -> Boolean + case: (%, [|Identifier|]) -> Boolean ++ x case Identifier is true if `x' really is an Identifier - _case: (%, [|String|]) -> Boolean + case: (%, [|String|]) -> Boolean ++ x case String is true if `x' really is a String Private == add @@ -341,188 +341,188 @@ SpadSyntaxCategory(): Category == AbstractSyntaxCategory ++ Description: This category describes the exported ++ signatures of the SpadAst domain. SpadAstExports(): Category == Join(SpadSyntaxCategory, UnionType) with - _case: (%, [|ImportAst()|]) -> Boolean + case: (%, [|ImportAst()|]) -> Boolean ++ s case ImportAst holds if `s' represents an `import' statement. autoCoerce: % -> ImportAst() ++ autoCoerce(s) returns the ImportAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|DefinitionAst()|]) -> Boolean + case: (%, [|DefinitionAst()|]) -> Boolean ++ s case DefinitionAst holds if `s' represents a definition. autoCoerce: % -> DefinitionAst() ++ autoCoerce(s) returns the DefinitionAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|MacroAst()|]) -> Boolean + case: (%, [|MacroAst()|]) -> Boolean ++ s case MacroAst holds if `s' represents a macro definition. autoCoerce: % -> MacroAst() ++ autoCoerce(s) returns the MacroAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|WhereAst()|]) -> Boolean + case: (%, [|WhereAst()|]) -> Boolean ++ s case WhereAst holds if `s' represents an expression with ++ local definitions. autoCoerce: % -> WhereAst() ++ autoCoerce(s) returns the WhereAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|CategoryAst()|]) -> Boolean + case: (%, [|CategoryAst()|]) -> Boolean ++ s case CategoryAst holds if `s' represents an unnamed category. autoCoerce: % -> CategoryAst() ++ autoCoerce(s) returns the CategoryAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|CapsuleAst()|]) -> Boolean + case: (%, [|CapsuleAst()|]) -> Boolean ++ s case CapsuleAst holds if `s' represents a domain capsule. autoCoerce: % -> CapsuleAst() ++ autoCoerce(s) returns the CapsuleAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|SignatureAst()|]) -> Boolean + case: (%, [|SignatureAst()|]) -> Boolean ++ s case SignatureAst holds if `s' represents a signature export. autoCoerce: % -> SignatureAst() ++ autoCoerce(s) returns the SignatureAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|AttributeAst()|]) -> Boolean + case: (%, [|AttributeAst()|]) -> Boolean ++ s case AttributeAst holds if `s' represents an attribute. autoCoerce: % -> AttributeAst() ++ autoCoerce(s) returns the AttributeAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|MappingAst()|]) -> Boolean + case: (%, [|MappingAst()|]) -> Boolean ++ s case MappingAst holds if `s' represents a mapping type. autoCoerce: % -> MappingAst() ++ autoCoerce(s) returns the MappingAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|IfAst()|]) -> Boolean + case: (%, [|IfAst()|]) -> Boolean ++ s case IfAst holds if `s' represents an if-statement. autoCoerce: % -> IfAst() ++ autoCoerce(s) returns the IfAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|RepeatAst()|]) -> Boolean + case: (%, [|RepeatAst()|]) -> Boolean ++ s case RepeatAst holds if `s' represents an repeat-loop. autoCoerce: % -> RepeatAst() ++ autoCoerce(s) returns the RepeatAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|WhileAst()|]) -> Boolean + case: (%, [|WhileAst()|]) -> Boolean ++ s case WhileAst holds if `s' represents a while-iterator autoCoerce: % -> WhileAst() ++ autoCoerce(s) returns the WhileAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|InAst()|]) -> Boolean + case: (%, [|InAst()|]) -> Boolean ++ s case InAst holds if `s' represents a in-iterator autoCoerce: % -> InAst() ++ autoCoerce(s) returns the InAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|CollectAst()|]) -> Boolean + case: (%, [|CollectAst()|]) -> Boolean ++ s case CollectAst holds if `s' represents a list-comprehension. autoCoerce: % -> CollectAst() ++ autoCoerce(s) returns the CollectAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|ConstructAst()|]) -> Boolean + case: (%, [|ConstructAst()|]) -> Boolean ++ s case ConstructAst holds if `s' represents a list-expression. autoCoerce: % -> ConstructAst() ++ autoCoerce(s) returns the ConstructAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|ExitAst()|]) -> Boolean + case: (%, [|ExitAst()|]) -> Boolean ++ s case ExitAst holds if `s' represents an exit-expression. autoCoerce: % -> ExitAst() ++ autoCoerce(s) returns the ExitAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|ReturnAst()|]) -> Boolean + case: (%, [|ReturnAst()|]) -> Boolean ++ s case ReturnAst holds if `s' represents a return-statement. autoCoerce: % -> ReturnAst() ++ autoCoerce(s) returns the ReturnAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|CoerceAst()|]) -> Boolean + case: (%, [|CoerceAst()|]) -> Boolean ++ s case ReturnAst holds if `s' represents a coerce-expression. autoCoerce: % -> CoerceAst() ++ autoCoerce(s) returns the CoerceAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|PretendAst()|]) -> Boolean + case: (%, [|PretendAst()|]) -> Boolean ++ s case PretendAst holds if `s' represents a pretend-expression. autoCoerce: % -> PretendAst() ++ autoCoerce(s) returns the PretendAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|RestrictAst()|]) -> Boolean + case: (%, [|RestrictAst()|]) -> Boolean ++ s case RestrictAst holds if `s' represents a restrict-expression. autoCoerce: % -> RestrictAst() ++ autoCoerce(s) returns the RestrictAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|SegmentAst()|]) -> Boolean + case: (%, [|SegmentAst()|]) -> Boolean ++ s case SegmentAst holds if `s' represents a segment-expression. autoCoerce: % -> SegmentAst() ++ autoCoerce(s) returns the SegmentAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|SequenceAst()|]) -> Boolean + case: (%, [|SequenceAst()|]) -> Boolean ++ s case SequenceAst holds if `s' represents a sequence-of-statements. autoCoerce: % -> SequenceAst() ++ autoCoerce(s) returns the SequenceAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|LetAst()|]) -> Boolean + case: (%, [|LetAst()|]) -> Boolean ++ s case LetAst holds if `s' represents an assignment-expression. autoCoerce: % -> LetAst() ++ autoCoerce(s) returns the LetAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|SuchThatAst()|]) -> Boolean + case: (%, [|SuchThatAst()|]) -> Boolean ++ s case SuchThatAst holds if `s' represents a qualified-expression. autoCoerce: % -> SuchThatAst() ++ autoCoerce(s) returns the SuchThatAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|ColonAst()|]) -> Boolean + case: (%, [|ColonAst()|]) -> Boolean ++ s case ColonAst holds if `s' represents a colon-expression. autoCoerce: % -> ColonAst() ++ autoCoerce(s) returns the ColoonAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|CaseAst()|]) -> Boolean + case: (%, [|CaseAst()|]) -> Boolean ++ s case CaseAst holds if `s' represents a case-expression. autoCoerce: % -> CaseAst() ++ autoCoerce(s) returns the CaseAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|HasAst()|]) -> Boolean + case: (%, [|HasAst()|]) -> Boolean ++ s case HasAst holds if `s' represents a has-expression. autoCoerce: % -> HasAst() ++ autoCoerce(s) returns the HasAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|IsAst()|]) -> Boolean + case: (%, [|IsAst()|]) -> Boolean ++ s case IsAst holds if `s' represents an is-expression. autoCoerce: % -> IsAst() ++ autoCoerce(s) returns the IsAst view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|Identifier|]) -> Boolean + case: (%, [|Identifier|]) -> Boolean ++ s case Identifier holds if `s' represents an identifier. autoCoerce: % -> Identifier ++ autoCoerce(s) returns the Identifier view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|String|]) -> Boolean + case: (%, [|String|]) -> Boolean ++ s case String holds if `s' represents a string literal. autoCoerce: % -> String ++ autoCoerce(s) returns the String view of `s'. Left at the ++ discretion of the compiler. - _case: (%, [|Integer|]) -> Boolean + case: (%, [|Integer|]) -> Boolean ++ s case Integer holds if `s' represents an integer literal. autoCoerce: % -> Integer ++ autoCoerce(s) returns the Integer view of `s'. Left at the @@ -1611,7 +1611,7 @@ SpadAst(): SpadAstExports() == add x case ExitAst == isAst(x,'exit) autoCoerce(x: %): ExitAst == x : ExitAst - x case ReturnAst == isAst(x,'_return) + x case ReturnAst == isAst(x,'return) autoCoerce(x: %): ReturnAst == x : ReturnAst x case CoerceAst == isAst(x,'_:_:) @@ -1638,13 +1638,13 @@ SpadAst(): SpadAstExports() == add x case ColonAst == isAst(x,'_:) autoCoerce(x: %): ColonAst == x : ColonAst - x case CaseAst == isAst(x,'_case) + x case CaseAst == isAst(x,'case) autoCoerce(x: %): CaseAst == x : CaseAst - x case HasAst == isAst(x,'_has) + x case HasAst == isAst(x,'has) autoCoerce(x: %): HasAst == x : HasAst - x case IsAst == isAst(x,'_is) + x case IsAst == isAst(x,'is) autoCoerce(x: %): IsAst == x : IsAst x case Identifier == (x::Syntax) case Identifier @@ -1668,7 +1668,7 @@ SpadAst(): SpadAstExports() == add op = 'exit => x:ExitAst::OutputForm op = 'return => x:ReturnAst::OutputForm op = 'SEQ => x:SequenceAst::OutputForm - op = '_%LET => x:LetAst::OutputForm + op = '%LET => x:LetAst::OutputForm op = 'pretend => x:PretendAst::OutputForm op = '_:_: => x:CoerceAst::OutputForm op = '_@ => x:RestrictAst::OutputForm @@ -1676,11 +1676,11 @@ SpadAst(): SpadAstExports() == add op = '_| => x:SuchThatAst::OutputForm op = '_: => x:ColonAst::OutputForm op = 'add => x:AddAst::OutputForm - op = '_case => x:CaseAst::OutputForm - op = '_has => x:CaseAst::OutputForm - op = '_is => x:CaseAst::OutputForm + op = 'case => x:CaseAst::OutputForm + op = 'has => x:CaseAst::OutputForm + op = 'is => x:CaseAst::OutputForm op = 'where => x:WhereAst::OutputForm - op = '_%Comma => x:CommaAst::OutputForm + op = '%Comma => x:CommaAst::OutputForm op = 'Mapping => x:MappingAst::OutputForm op = 'DEF => x:DefinitionAst::OutputForm op = 'MDEF => x:MacroAst::OutputForm diff --git a/src/algebra/taylor.spad.pamphlet b/src/algebra/taylor.spad.pamphlet index a54ec020..fa0debbc 100644 --- a/src/algebra/taylor.spad.pamphlet +++ b/src/algebra/taylor.spad.pamphlet @@ -59,11 +59,11 @@ InnerTaylorSeries(Coef): Exports == Implementation where ++ i.e. the degree of the first non-zero term of the series. order: (%,NNI) -> NNI ++\spad{order(x,n)} returns the minimum of n and the order of x. - "*" : (Coef,%)->% + * : (Coef,%)->% ++\spad{c*x} returns the product of c and the series x. - "*" : (%,Coef)->% + * : (%,Coef)->% ++\spad{x*c} returns the product of c and the series x. - "*" : (%,Integer)->% + * : (%,Integer)->% ++\spad{x*i} returns the product of integer i and the series x. if Coef has IntegralDomain then IntegralDomain --++ An IntegralDomain provides 'exquo' diff --git a/src/algebra/trigcat.spad.pamphlet b/src/algebra/trigcat.spad.pamphlet index e3d7bb32..e4c4f1d9 100644 --- a/src/algebra/trigcat.spad.pamphlet +++ b/src/algebra/trigcat.spad.pamphlet @@ -20,7 +20,7 @@ ElementaryFunctionCategory(): Category == with log : $ -> $ ++ log(x) returns the natural logarithm of x. exp : $ -> $ ++ exp(x) returns %e to the power x. - "**": ($, $) -> $ ++ x**y returns x to the power y. + **: ($, $) -> $ ++ x**y returns x to the power y. add if $ has Monoid then x ** y == exp(y * log x) diff --git a/src/algebra/tube.spad.pamphlet b/src/algebra/tube.spad.pamphlet index 9d74406f..b2efebff 100644 --- a/src/algebra/tube.spad.pamphlet +++ b/src/algebra/tube.spad.pamphlet @@ -86,16 +86,16 @@ TubePlotTools(): Exports == Implementation where ++ specified coordinates \spad{x1}, \spad{x2}, \spad{x3}, and also ++ a fourth coordinate, c, which is generally used to specify the ++ color of the point. - "*" : (SF,Pt) -> Pt + * : (SF,Pt) -> Pt ++ s * p returns a point whose coordinates are the scalar multiple ++ of the point p by the scalar s, preserving the color, or fourth ++ coordinate, of p. - "+" : (Pt,Pt) -> Pt + + : (Pt,Pt) -> Pt ++ p + q computes and returns a point whose coordinates are the sums ++ of the coordinates of the two points \spad{p} and \spad{q}, using ++ the color, or fourth coordinate, of the first point \spad{p} ++ as the color also of the point \spad{q}. - "-" : (Pt,Pt) -> Pt + - : (Pt,Pt) -> Pt ++ p - q computes and returns a point whose coordinates are the ++ differences of the coordinates of two points \spad{p} and \spad{q}, ++ using the color, or fourth coordinate, of the first point \spad{p} diff --git a/src/algebra/vector.spad.pamphlet b/src/algebra/vector.spad.pamphlet index 7342a113..2d52b422 100644 --- a/src/algebra/vector.spad.pamphlet +++ b/src/algebra/vector.spad.pamphlet @@ -31,24 +31,24 @@ VectorCategory(R:Type): Category == OneDimensionalArrayAggregate R with if R has AbelianSemiGroup then - _+ : (%, %) -> % + + : (%, %) -> % ++ x + y returns the component-wise sum of the vectors x and y. ++ Error: if x and y are not of the same length. if R has AbelianMonoid then zero: NonNegativeInteger -> % ++ zero(n) creates a zero vector of length n. if R has AbelianGroup then - _- : % -> % + - : % -> % ++ -x negates all components of the vector x. - _- : (%, %) -> % + - : (%, %) -> % ++ x - y returns the component-wise difference of the vectors x and y. ++ Error: if x and y are not of the same length. - _* : (Integer, %) -> % + * : (Integer, %) -> % ++ n * y multiplies each component of the vector y by the integer n. if R has Monoid then - _* : (R, %) -> % + * : (R, %) -> % ++ r * y multiplies the element r times each component of the vector y. - _* : (%, R) -> % + * : (%, R) -> % ++ y * r multiplies each component of the vector y by the element r. if R has Ring then dot: (%, %) -> R @@ -86,7 +86,7 @@ VectorCategory(R:Type): Category == OneDimensionalArrayAggregate R with if R has Ring then dot(u, v) == #u ~= #v => error "Vectors must be of the same length" - _+/[qelt(u, i) * qelt(v, i) for i in minIndex u .. maxIndex u] + +/[qelt(u, i) * qelt(v, i) for i in minIndex u .. maxIndex u] outerProduct(u, v) == matrix [[qelt(u, i) * qelt(v,j) for i in minIndex u .. maxIndex u] _ for j in minIndex v .. maxIndex v] @@ -256,10 +256,10 @@ DirectProductCategory(dim:NonNegativeInteger, R:Type): Category == if R has CancellationAbelianMonoid then CancellationAbelianMonoid if R has Monoid then Monoid - _* : (R, %) -> % + * : (R, %) -> % ++ r * y multiplies the element r times each component of the ++ vector y. - _* : (%, R) -> % + * : (%, R) -> % ++ y * r multiplies each component of the vector y by the element r. if R has Finite then Finite if R has CommutativeRing then @@ -346,7 +346,7 @@ DirectProduct(dim:NonNegativeInteger, R:Type): same?: % -> Boolean same? z == every?(#1 = z(minIndex z), z) - x = y == _and/[qelt(x,i)$Rep = qelt(y,i)$Rep for i in 1..dim] + x = y == and/[qelt(x,i)$Rep = qelt(y,i)$Rep for i in 1..dim] retract(z:%):R == same? z => z(minIndex z) diff --git a/src/algebra/wtpol.spad.pamphlet b/src/algebra/wtpol.spad.pamphlet index bd7f9805..81d9bbc2 100644 --- a/src/algebra/wtpol.spad.pamphlet +++ b/src/algebra/wtpol.spad.pamphlet @@ -151,7 +151,7 @@ OrdinaryWeightedPolynomials(R:Ring, wtlevel:NonNegativeInteger): Join(Ring, HomotopicTo Polynomial R) with if R has CommutativeRing then Algebra(R) - if R has Field then "/": ($,$) -> Union($,"failed") + if R has Field then /: ($,$) -> Union($,"failed") ++ x/y division (only works if minimum weight ++ of divisor is zero, and if R is a Field) changeWeightLevel: NonNegativeInteger -> Void diff --git a/src/algebra/xlpoly.spad.pamphlet b/src/algebra/xlpoly.spad.pamphlet index 26870df1..8cc83ee6 100644 --- a/src/algebra/xlpoly.spad.pamphlet +++ b/src/algebra/xlpoly.spad.pamphlet @@ -36,7 +36,7 @@ Magma(VarSet:OrderedSet):Public == Private where EX ==> OutputForm Public == Join(OrderedSet,RetractableTo VarSet) with - "*" : ($,$) -> $ + * : ($,$) -> $ ++ \axiom{x*y} returns the tree \axiom{[x,y]}. coerce : $ -> WORD ++ \axiom{coerce(x)} returns the element of \axiomType{OrderedFreeMonoid}(VarSet) @@ -362,7 +362,7 @@ LieAlgebra(R: CommutativeRing): Category == Module(R) with construct: ($,$) -> $ ++ \axiom{construct(x,y)} returns the Lie bracket of \axiom{x} and \axiom{y}. if R has Field then - "/" : ($,R) -> $ + / : ($,R) -> $ ++ \axiom{x/r} returns the division of \axiom{x} by \axiom{r}. diff --git a/src/algebra/xpoly.spad.pamphlet b/src/algebra/xpoly.spad.pamphlet index ef221d08..f5c9b047 100644 --- a/src/algebra/xpoly.spad.pamphlet +++ b/src/algebra/xpoly.spad.pamphlet @@ -43,11 +43,11 @@ OrderedFreeMonoid(S: OrderedSet): OFMcategory == OFMdefinition where REC ==> Record(gen:S, exp:NNI) OFMcategory == Join(OrderedMonoid, RetractableTo S) with - "*": (S, %) -> % + *: (S, %) -> % ++ \spad{s * x} returns the product of \spad{x} by \spad{s} on the left. - "*": (%, S) -> % + *: (%, S) -> % ++ \spad{x * s} returns the product of \spad{x} by \spad{s} on the right. - "**": (S, NNI) -> % + **: (S, NNI) -> % ++ \spad{s ** n} returns the product of \spad{s} by itself \spad{n} times. first: % -> S ++ \spad{first(x)} returns the first letter of \spad{x}. @@ -80,7 +80,7 @@ OrderedFreeMonoid(S: OrderedSet): OFMcategory == OFMdefinition where rquo: (%, S) -> Union(%, "failed") ++ \spad{rquo(x, s)} returns the exact right quotient ++ of \spad{x} by \spad{s}. - "div": (%, %) -> Union(Record(lm: %, rm: %), "failed") + div: (%, %) -> Union(Record(lm: %, rm: %), "failed") ++ \spad{x div y} returns the left and right exact quotients of ++ \spad{x} by \spad{y}, that is \spad{[l, r]} such that \spad{x = l * y * r}. ++ "failed" is returned iff \spad{x} is not of the form \spad{l * y * r}. @@ -205,7 +205,7 @@ FreeModuleCat(R, Basis):Category == Exports where TERM ==> Record(k: Basis, c: R) Exports == Join(BiModule(R,R), RetractableTo Basis) with - "*" : (R, Basis) -> % + * : (R, Basis) -> % ++ \spad{r*b} returns the product of \spad{r} by \spad{b}. coefficient : (%, Basis) -> R ++ \spad{coefficient(x,b)} returns the coefficient @@ -278,7 +278,7 @@ FreeModule1(R:Ring,S:OrderedSet): FMcat == FMdef where TERM ==> Record(k:S,c:R) FMcat == FreeModuleCat(R,S) with - "*":(S,R) -> % + *:(S,R) -> % ++ \spad{s*r} returns the product \spad{r*s} ++ used by \spadtype{XRecursivePolynomial} FMdef == FreeModule(R,S) add @@ -419,9 +419,9 @@ XFreeAlgebra(vl:OrderedSet,R:Ring):Category == Catdef where Catdef == Join(Ring, XAlgebra(R), RetractableTo WORD) with - "*": (vl,%) -> % + *: (vl,%) -> % ++ \spad{v * x} returns the product of a variable \spad{x} by \spad{x}. - "*": (%, R) -> % + *: (%, R) -> % ++ \spad{x * r} returns the product of \spad{x} by \spad{r}. ++ Usefull if \spad{R} is a non-commutative Ring. mindeg: % -> WORD @@ -547,9 +547,9 @@ XPolynomialRing(R:Ring,E:OrderedMonoid): T == C where T == Join(Ring, XAlgebra(R), FreeModuleCat(R,E),CoercibleFrom E) with --operations - "*": (%,R) -> % + *: (%,R) -> % ++ \spad{p*r} returns the product of \spad{p} by \spad{r}. - "#": % -> NonNegativeInteger + #: % -> NonNegativeInteger ++ \spad{# p} returns the number of terms in \spad{p}. maxdeg: % -> E ++ \spad{maxdeg(p)} returns the greatest word occurring in the polynomial \spad{p} @@ -574,7 +574,7 @@ XPolynomialRing(R:Ring,E:OrderedMonoid): T == C where ++ \spad{quasiRegular(x)} return \spad{x} minus its constant term. map : (R -> R, %) -> % ++ \spad{map(fn,x)} returns \spad{Sum(fn(r_i) w_i)} if \spad{x} writes \spad{Sum(r_i w_i)}. - if R has Field then "/" : (%,R) -> % + if R has Field then / : (%,R) -> % ++ \spad{p/r} returns \spad{p*(1/r)}. --assertions |