aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/ChangeLog21
-rw-r--r--src/algebra/alql.spad.pamphlet4
-rw-r--r--src/algebra/asp.spad.pamphlet14
-rw-r--r--src/algebra/catdef.spad.pamphlet10
-rw-r--r--src/algebra/formula.spad.pamphlet5
-rw-r--r--src/algebra/fortran.spad.pamphlet2
-rw-r--r--src/algebra/fs2ups.spad.pamphlet5
-rw-r--r--src/algebra/laurent.spad.pamphlet5
-rw-r--r--src/algebra/manip.spad.pamphlet4
-rw-r--r--src/algebra/modmon.spad.pamphlet4
-rw-r--r--src/algebra/ore.spad.pamphlet4
-rw-r--r--src/algebra/poly.spad.pamphlet4
-rw-r--r--src/algebra/prtition.spad.pamphlet4
-rw-r--r--src/algebra/puiseux.spad.pamphlet10
-rw-r--r--src/algebra/radix.spad.pamphlet29
-rw-r--r--src/algebra/rf.spad.pamphlet3
-rw-r--r--src/algebra/stream.spad.pamphlet4
-rw-r--r--src/algebra/sum.spad.pamphlet4
-rw-r--r--src/algebra/supxs.spad.pamphlet5
-rw-r--r--src/algebra/symbol.spad.pamphlet4
-rw-r--r--src/algebra/syntax.spad.pamphlet4
-rw-r--r--src/algebra/tex.spad.pamphlet5
-rw-r--r--src/algebra/tree.spad.pamphlet5
-rw-r--r--src/algebra/xpoly.spad.pamphlet9
24 files changed, 57 insertions, 111 deletions
diff --git a/src/ChangeLog b/src/ChangeLog
index 7b1351e0..297c7c21 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,5 +1,26 @@
2008-11-20 Gabriel Dos Reis <gdr@cs.tamu.edu>
+ * algebra/alql.spad.pamphlet (Database): Now CoercibleFrom List S.
+ * algebra/asp.spad.pamphlet (Asp20): Now CoercibleFrom MAT FEXPR.
+ (Asp6): Now CoercibleFrom Vector FEXPR.
+ * algebra/catdef.spad.pamphlet (Algebra): Extend CoercibleFrom R.
+ (Ring): Extend CoercibleFrom Integer.
+ * algebra/formula.spad.pamphlet (ScriptFormulaFormat): Now
+ CoercibleFrom E.
+ * algebra/fortran.spad.pamphlet (FortranCode): Remove redundant
+ signature.
+ * algebra/fs2ups.spad.pamphlet
+ (FunctionSpaceToUnivariatePowerSeries): Tidy parameter.
+ * algebra/laurent.spad.pamphlet
+ (UnivariateLaurentSeriesConstructorCategory): Extend CoercibleFrom
+ UTS.
+ * algebra/manip.spad.pamphlet (PolynomialRoots): Tidy parameter.
+ * algebra/modmon.spad.pamphlet (ModMonic): Now CoercibleFrom Rep.
+ * algebra/ore.spad.pamphlet (UnivariateSkewPolynomial): Now
+ CoercibleFrom Variable x.
+
+2008-11-20 Gabriel Dos Reis <gdr@cs.tamu.edu>
+
* algebra/annacat.spad.pamphlet (NumericalIntegrationProblem):
Remove redundant signature.
(NumericalODEProblem): Likewise.
diff --git a/src/algebra/alql.spad.pamphlet b/src/algebra/alql.spad.pamphlet
index 4e568141..a7f895a1 100644
--- a/src/algebra/alql.spad.pamphlet
+++ b/src/algebra/alql.spad.pamphlet
@@ -114,7 +114,7 @@ Database(S): Exports == Implementation where
++ display(x) displays x in some form
fullDisplay: % -> Void
++ fullDisplay(x) displays x in detail
- Exports == SetCategory with
+ Exports == Join(SetCategory, CoercibleFrom List S) with
elt: (%,QueryEquation) -> %
++ elt(db,q) returns all elements of \axiom{db} which satisfy \axiom{q}.
elt: (%,Symbol) -> DataList String
@@ -124,8 +124,6 @@ Database(S): Exports == Implementation where
_-: (%,%) -> %
++ db1-db2 returns the difference of databases db1 and db2 i.e. consisting
++ of elements in db1 but not in db2
- coerce: List S -> %
- ++ coerce(l) makes a database out of a list
display: % -> Void
++ display(db) prints a summary line for each entry in \axiom{db}.
fullDisplay: % -> Void
diff --git a/src/algebra/asp.spad.pamphlet b/src/algebra/asp.spad.pamphlet
index b83fcbf5..e5f2b900 100644
--- a/src/algebra/asp.spad.pamphlet
+++ b/src/algebra/asp.spad.pamphlet
@@ -654,12 +654,8 @@ Asp20(name): Exports == Implementation where
MAT EXPR FLOAT, FEXPR,VEC FEXPR,VEC FEXPR,MAT FEXPR)
- Exports ==> FortranMatrixFunctionCategory with
- coerce: MAT FEXPR -> $
- ++coerce(f) takes objects from the appropriate instantiation of
- ++\spadtype{FortranExpression} and turns them into an ASP.
-
- Implementation ==> add
+ Exports == Join(FortranMatrixFunctionCategory, CoercibleFrom MAT FEXPR)
+ Implementation == add
real : UFST := ["real"::FST]$UFST
syms : SYMTAB := empty()
@@ -2986,11 +2982,7 @@ Asp6(name): Exports == Implementation where
VEC ==> Vector
VF2 ==> VectorFunctions2
- Exports == FortranVectorFunctionCategory with
- coerce: Vector FEXPR -> %
- ++coerce(f) takes objects from the appropriate instantiation of
- ++\spadtype{FortranExpression} and turns them into an ASP.
-
+ Exports == Join(FortranVectorFunctionCategory, CoercibleFrom Vector FEXPR)
Implementation == add
real : UFST := ["real"::FST]$UFST
diff --git a/src/algebra/catdef.spad.pamphlet b/src/algebra/catdef.spad.pamphlet
index 56860d9f..45d087d0 100644
--- a/src/algebra/catdef.spad.pamphlet
+++ b/src/algebra/catdef.spad.pamphlet
@@ -149,10 +149,7 @@ AbelianSemiGroup(): Category == SetCategory with
++ \spad{b*x = (b::%)*x}
++ \spad{r*(a*b) = (r*a)*b = a*(r*b)}
Algebra(R:CommutativeRing): Category ==
- Join(Ring, Module R) with
- --operations
- coerce: R -> %
- ++ coerce(r) maps the ring element r to a member of the algebra.
+ Join(Ring, Module R, CoercibleFrom R)
add
coerce(x:R):% == x * 1$%
@@ -1529,7 +1526,7 @@ RightModule(R:Rng):Category == AbelianGroup with
++ not necessarily commutative.
--Ring(): Category == Join(Rng,Monoid,LeftModule(%:Rng)) with
-Ring(): Category == Join(Rng,Monoid,LeftModule(%)) with
+Ring(): Category == Join(Rng,Monoid,LeftModule(%),CoercibleFrom Integer) with
--operations
characteristic: () -> NonNegativeInteger
++ characteristic() returns the characteristic of the ring
@@ -1537,9 +1534,6 @@ Ring(): Category == Join(Rng,Monoid,LeftModule(%)) with
++ \spad{n*x=0} for all x in the ring, or zero if no such n
++ exists.
--We can not make this a constant, since some domains are mutable
- coerce: Integer -> %
- ++ coerce(i) converts the integer i to a member of the given domain.
--- recip: % -> Union(%,"failed") -- inherited from Monoid
unitsKnown
++ recip truly yields
++ reciprocal or "failed" if not a unit.
diff --git a/src/algebra/formula.spad.pamphlet b/src/algebra/formula.spad.pamphlet
index 51506fc6..a46bf05d 100644
--- a/src/algebra/formula.spad.pamphlet
+++ b/src/algebra/formula.spad.pamphlet
@@ -44,10 +44,7 @@ ScriptFormulaFormat(): public == private where
L ==> List
S ==> String
- public == SetCategory with
- coerce: E -> %
- ++ coerce(o) changes o in the standard output format to
- ++ SCRIPT formula format.
+ public == Join(SetCategory, CoercibleFrom E) with
convert: (E,I) -> %
++ convert(o,step) changes o in standard output format to
++ SCRIPT formula format and also adds the given step number.
diff --git a/src/algebra/fortran.spad.pamphlet b/src/algebra/fortran.spad.pamphlet
index f0c2cc29..2507beda 100644
--- a/src/algebra/fortran.spad.pamphlet
+++ b/src/algebra/fortran.spad.pamphlet
@@ -163,8 +163,6 @@ FortranCode(): public == private where
commonBranch:COMMON, printBranch:PRINTLIST)
public == SetCategory with
- coerce: $ -> O
- ++ coerce(f) returns an object of type OutputForm.
forLoop: (SegmentBinding PIN,$) -> $
++ forLoop(i=1..10,c) creates a representation of a FORTRAN DO loop with
++ \spad{i} ranging over the values 1 to 10.
diff --git a/src/algebra/fs2ups.spad.pamphlet b/src/algebra/fs2ups.spad.pamphlet
index 9751dd40..a27834ae 100644
--- a/src/algebra/fs2ups.spad.pamphlet
+++ b/src/algebra/fs2ups.spad.pamphlet
@@ -34,10 +34,7 @@ FunctionSpaceToUnivariatePowerSeries(R,FE,Expon,UPS,TRAN,x):_
R : Join(GcdDomain,OrderedSet,RetractableTo Integer,_
LinearlyExplicitRingOver Integer)
FE : Join(AlgebraicallyClosedField,TranscendentalFunctionCategory,_
- FunctionSpace R)
- with
- coerce: Expon -> %
- ++ coerce(e) converts an 'exponent' e to an 'expression'
+ FunctionSpace R, CoercibleFrom Expon)
Expon : OrderedRing
UPS : Join(UnivariatePowerSeriesCategory(FE,Expon),Field,_
TranscendentalFunctionCategory)
diff --git a/src/algebra/laurent.spad.pamphlet b/src/algebra/laurent.spad.pamphlet
index 1a162ede..23d39979 100644
--- a/src/algebra/laurent.spad.pamphlet
+++ b/src/algebra/laurent.spad.pamphlet
@@ -35,7 +35,7 @@ UnivariateLaurentSeriesConstructorCategory(Coef,UTS):_
I ==> Integer
Definition ==> Join(UnivariateLaurentSeriesCategory(Coef),_
- RetractableTo UTS) with
+ RetractableTo UTS, CoercibleFrom UTS) with
laurent: (I,UTS) -> %
++ \spad{laurent(n,f(x))} returns \spad{x**n * f(x)}.
degree: % -> I
@@ -63,9 +63,6 @@ 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.
- coerce: UTS -> %
- ++ \spad{coerce(f(x))} converts the Taylor series \spad{f(x)} to a
- ++ Laurent series.
taylor: % -> UTS
++ taylor(f(x)) converts the Laurent series f(x) to a Taylor series,
++ if possible. Error: if this is not possible.
diff --git a/src/algebra/manip.spad.pamphlet b/src/algebra/manip.spad.pamphlet
index 83657f90..cfe3fcc6 100644
--- a/src/algebra/manip.spad.pamphlet
+++ b/src/algebra/manip.spad.pamphlet
@@ -67,13 +67,11 @@ PolynomialRoots(E, V, R, P, F):Exports == Implementation where
V: OrderedSet
R: IntegralDomain
P: PolynomialCategory(R, E, V)
- F: Field with
+ F: Join(Field,CoercibleFrom P) with
numer : $ -> P
++ numer(x) \undocumented
denom : $ -> P
++ denom(x) \undocumented
- coerce: P -> $
- ++ coerce(p) \undocumented
N ==> NonNegativeInteger
Z ==> Integer
diff --git a/src/algebra/modmon.spad.pamphlet b/src/algebra/modmon.spad.pamphlet
index 0d4241e2..79ad7718 100644
--- a/src/algebra/modmon.spad.pamphlet
+++ b/src/algebra/modmon.spad.pamphlet
@@ -21,7 +21,7 @@ ModMonic(R,Rep): C == T
where
R: Ring
Rep: UnivariatePolynomialCategory(R)
- C == UnivariatePolynomialCategory(R) with
+ C == Join(UnivariatePolynomialCategory(R),CoercibleFrom Rep) with
--operations
setPoly : Rep -> Rep
++ setPoly(x) \undocumented
@@ -31,8 +31,6 @@ ModMonic(R,Rep): C == T
++ reduce(x) \undocumented
lift: % -> Rep --reduce lift = identity
++ lift(x) \undocumented
- coerce: Rep -> %
- ++ coerce(x) \undocumented
Vectorise: % -> Vector(R)
++ Vectorise(x) \undocumented
UnVectorise: Vector(R) -> %
diff --git a/src/algebra/ore.spad.pamphlet b/src/algebra/ore.spad.pamphlet
index 3e2f769c..87268627 100644
--- a/src/algebra/ore.spad.pamphlet
+++ b/src/algebra/ore.spad.pamphlet
@@ -506,9 +506,7 @@ SparseUnivariateSkewPolynomial(R:Ring, sigma:Automorphism R, delta: R -> R):
++ coefficient field in a named variable.
++ The multiplication is given by \spad{x a = \sigma(a) x + \delta a}.
UnivariateSkewPolynomial(x:Symbol, R:Ring, sigma:Automorphism R, delta: R -> R):
- UnivariateSkewPolynomialCategory R with
- coerce: Variable x -> %
- ++ coerce(x) returns x as a skew-polynomial.
+ Join(UnivariateSkewPolynomialCategory R,CoercibleFrom Variable x)
== SparseUnivariateSkewPolynomial(R, sigma, delta) add
Rep := SparseUnivariateSkewPolynomial(R, sigma, delta)
coerce(v:Variable(x)):% == monomial(1, 1)
diff --git a/src/algebra/poly.spad.pamphlet b/src/algebra/poly.spad.pamphlet
index 9cdc6ad8..ff21510e 100644
--- a/src/algebra/poly.spad.pamphlet
+++ b/src/algebra/poly.spad.pamphlet
@@ -785,9 +785,7 @@ SparseUnivariatePolynomialFunctions2(R:Ring, S:Ring): with
++ Note: if the coefficient ring is a field, then this domain forms a euclidean domain.
UnivariatePolynomial(x:Symbol, R:Ring):
- UnivariatePolynomialCategory(R) with
- coerce: Variable(x) -> %
- ++ coerce(x) converts the variable x to a univariate polynomial.
+ Join(UnivariatePolynomialCategory(R),CoercibleFrom Variable x) with
fmecg: (%,NonNegativeInteger,R,%) -> %
++ fmecg(p1,e,r,p2) finds X : p1 - r * X**e * p2
== SparseUnivariatePolynomial(R) add
diff --git a/src/algebra/prtition.spad.pamphlet b/src/algebra/prtition.spad.pamphlet
index 45466b9c..dd09fcd3 100644
--- a/src/algebra/prtition.spad.pamphlet
+++ b/src/algebra/prtition.spad.pamphlet
@@ -36,7 +36,7 @@ Partition: Exports == Implementation where
UN ==> Union(%,"failed")
Exports ==> Join(OrderedCancellationAbelianMonoid,
- ConvertibleTo List Integer) with
+ ConvertibleTo List Integer,CoercibleTo List Integer) with
partition: L I -> %
++ partition(li) converts a list of integers li to a partition
powers: L I -> L L I
@@ -51,8 +51,6 @@ Partition: Exports == Implementation where
++ This function is used in the package \spadtype{CycleIndicators}.
conjugate: % -> %
++ conjugate(p) returns the conjugate partition of a partition p
- coerce:% -> List Integer
- ++ coerce(p) coerces a partition into a list of integers
Implementation ==> add
diff --git a/src/algebra/puiseux.spad.pamphlet b/src/algebra/puiseux.spad.pamphlet
index 8b4bb665..e0c2dc5d 100644
--- a/src/algebra/puiseux.spad.pamphlet
+++ b/src/algebra/puiseux.spad.pamphlet
@@ -36,7 +36,7 @@ UnivariatePuiseuxSeriesConstructorCategory(Coef,ULS):_
RN ==> Fraction Integer
Definition ==> Join(UnivariatePuiseuxSeriesCategory(Coef),_
- RetractableTo ULS) with
+ RetractableTo ULS,CoercibleFrom ULS) with
puiseux: (RN,ULS) -> %
++ \spad{puiseux(r,f(x))} returns \spad{f(x^r)}.
rationalPower: % -> RN
@@ -48,9 +48,6 @@ UnivariatePuiseuxSeriesConstructorCategory(Coef,ULS):_
degree: % -> RN
++ \spad{degree(f(x))} returns the degree of the leading term of the
++ Puiseux series \spad{f(x)}, which may have zero as a coefficient.
- coerce: ULS -> %
- ++ \spad{coerce(f(x))} converts the Laurent series \spad{f(x)} to a
- ++ Puiseux series.
laurent: % -> ULS
++ \spad{laurent(f(x))} converts the Puiseux series \spad{f(x)} to a
++ Laurent series if possible. Error: if this is not possible.
@@ -448,10 +445,7 @@ UnivariatePuiseuxSeries(Coef,var,cen): Exports == Implementation where
ULS ==> UnivariateLaurentSeries(Coef,var,cen)
Exports ==> Join(UnivariatePuiseuxSeriesConstructorCategory(Coef,ULS),_
- RetractableTo UTS) with
- coerce: Variable(var) -> %
- ++ coerce(var) converts the series variable \spad{var} into a
- ++ Puiseux series.
+ RetractableTo UTS,CoercibleFrom Variable var) with
differentiate: (%,Variable(var)) -> %
++ \spad{differentiate(f(x),x)} returns the derivative of
++ \spad{f(x)} with respect to \spad{x}.
diff --git a/src/algebra/radix.spad.pamphlet b/src/algebra/radix.spad.pamphlet
index 3fb80cd2..80b12c4c 100644
--- a/src/algebra/radix.spad.pamphlet
+++ b/src/algebra/radix.spad.pamphlet
@@ -42,9 +42,8 @@ RadixExpansion(bb): Exports == Implementation where
ST ==> Stream Integer
QuoRem ==> Record(quotient: Integer, remainder: Integer)
- Exports ==> QuotientFieldCategory(Integer) with
- coerce: % -> Fraction Integer
- ++ coerce(rx) converts a radix expansion to a rational number.
+ Exports == Join(QuotientFieldCategory(Integer),_
+ CoercibleTo Fraction Integer) with
fractionPart: % -> Fraction Integer
++ fractionPart(rx) returns the fractional part of a radix expansion.
wholeRagits: % -> List Integer
@@ -280,11 +279,8 @@ RadixExpansion(bb): Exports == Implementation where
++ binary expansions.
BinaryExpansion(): Exports == Implementation where
- Exports ==> QuotientFieldCategory(Integer) with
- coerce: % -> Fraction Integer
- ++ coerce(b) converts a binary expansion to a rational number.
- coerce: % -> RadixExpansion(2)
- ++ coerce(b) converts a binary expansion to a radix expansion with base 2.
+ Exports == Join(QuotientFieldCategory(Integer),_
+ CoercibleTo Fraction Integer,CoercibleTo RadixExpansion(2)) with
fractionPart: % -> Fraction Integer
++ fractionPart(b) returns the fractional part of a binary expansion.
binary: Fraction Integer -> %
@@ -312,12 +308,8 @@ BinaryExpansion(): Exports == Implementation where
++ This domain allows rational numbers to be presented as repeating
++ decimal expansions.
DecimalExpansion(): Exports == Implementation where
- Exports ==> QuotientFieldCategory(Integer) with
- coerce: % -> Fraction Integer
- ++ coerce(d) converts a decimal expansion to a rational number.
- coerce: % -> RadixExpansion(10)
- ++ coerce(d) converts a decimal expansion to a radix expansion
- ++ with base 10.
+ Exports == Join(QuotientFieldCategory(Integer),_
+ CoercibleTo Fraction Integer,CoercibleTo RadixExpansion 10) with
fractionPart: % -> Fraction Integer
++ fractionPart(d) returns the fractional part of a decimal expansion.
decimal: Fraction Integer -> %
@@ -346,12 +338,9 @@ DecimalExpansion(): Exports == Implementation where
++ hexadecimal expansions.
HexadecimalExpansion(): Exports == Implementation where
- Exports ==> QuotientFieldCategory(Integer) with
- coerce: % -> Fraction Integer
- ++ coerce(h) converts a hexadecimal expansion to a rational number.
- coerce: % -> RadixExpansion(16)
- ++ coerce(h) converts a hexadecimal expansion to a radix expansion
- ++ with base 16.
+ Exports == Join(QuotientFieldCategory(Integer),_
+ CoercibleTo Fraction Integer,_
+ CoercibleTo RadixExpansion 16) with
fractionPart: % -> Fraction Integer
++ fractionPart(h) returns the fractional part of a hexadecimal expansion.
hex: Fraction Integer -> %
diff --git a/src/algebra/rf.spad.pamphlet b/src/algebra/rf.spad.pamphlet
index c8e40f71..764a50a7 100644
--- a/src/algebra/rf.spad.pamphlet
+++ b/src/algebra/rf.spad.pamphlet
@@ -26,8 +26,7 @@ PolynomialCategoryQuotientFunctions(E, V, R, P, F):
V: OrderedSet
R: Ring
P: PolynomialCategory(R, E, V)
- F: Field with
- coerce: P -> %
+ F: Join(Field,CoercibleFrom P) with
numer : % -> P
denom : % -> P
diff --git a/src/algebra/stream.spad.pamphlet b/src/algebra/stream.spad.pamphlet
index 66d7a227..a691aab2 100644
--- a/src/algebra/stream.spad.pamphlet
+++ b/src/algebra/stream.spad.pamphlet
@@ -587,13 +587,11 @@ Stream(S): Exports == Implementation where
NNI ==> NonNegativeInteger
U ==> UniversalSegment I
- Exports ==> LazyStreamAggregate(S) with
+ Exports == Join(LazyStreamAggregate(S),CoercibleFrom L S) with
shallowlyMutable
++ one may destructively alter a stream by assigning new
++ values to its entries.
- coerce: L S -> %
- ++ coerce(l) converts a list l to a stream.
repeating: L S -> %
++ repeating(l) is a repeating stream whose period is the list l.
if S has SetCategory then
diff --git a/src/algebra/sum.spad.pamphlet b/src/algebra/sum.spad.pamphlet
index e866dc11..a4eef16f 100644
--- a/src/algebra/sum.spad.pamphlet
+++ b/src/algebra/sum.spad.pamphlet
@@ -79,8 +79,8 @@ GosperSummationMethod(E, V, R, P, Q): Exports == Impl where
V: OrderedSet
R: IntegralDomain
P: PolynomialCategory(R, E, V)
- Q: Join(RetractableTo Fraction Integer, Field with
- (coerce: P -> %; numer : % -> P; denom : % -> P))
+ Q: Join(RetractableTo Fraction Integer, CoercibleFrom P, Field with
+ (numer : % -> P; denom : % -> P))
I ==> Integer
RN ==> Fraction I
diff --git a/src/algebra/supxs.spad.pamphlet b/src/algebra/supxs.spad.pamphlet
index 311d6cd6..adddd2e9 100644
--- a/src/algebra/supxs.spad.pamphlet
+++ b/src/algebra/supxs.spad.pamphlet
@@ -43,10 +43,7 @@ SparseUnivariatePuiseuxSeries(Coef,var,cen): Exports == Implementation where
SUPS ==> InnerSparseUnivariatePowerSeries(Coef)
Exports ==> Join(UnivariatePuiseuxSeriesConstructorCategory(Coef,SULS),_
- RetractableTo SUTS) with
- coerce: Variable(var) -> %
- ++ coerce(var) converts the series variable \spad{var} into a
- ++ Puiseux series.
+ RetractableTo SUTS,CoercibleFrom Variable var) with
differentiate: (%,Variable(var)) -> %
++ \spad{differentiate(f(x),x)} returns the derivative of
++ \spad{f(x)} with respect to \spad{x}.
diff --git a/src/algebra/symbol.spad.pamphlet b/src/algebra/symbol.spad.pamphlet
index 8367da5c..b41a4f0a 100644
--- a/src/algebra/symbol.spad.pamphlet
+++ b/src/algebra/symbol.spad.pamphlet
@@ -23,7 +23,7 @@ Symbol(): Exports == Implementation where
Scripts ==> Record(sub:L,sup:L,presup:L,presub:L,args:L)
Exports ==> Join(OrderedSet, ConvertibleTo InputForm, OpenMath,
- ConvertibleTo Symbol,
+ ConvertibleTo Symbol,CoercibleFrom String,
ConvertibleTo Pattern Integer, ConvertibleTo Pattern Float,
PatternMatchable Integer, PatternMatchable Float) with
new: () -> %
@@ -33,8 +33,6 @@ Symbol(): Exports == Implementation where
resetNew: () -> Void
++ resetNew() resets the internals counters that new() and
++ new(s) use to return distinct symbols every time.
- coerce: String -> %
- ++ coerce(s) converts the string s to a symbol.
name: % -> %
++ name(s) returns s without its scripts.
scripted?: % -> Boolean
diff --git a/src/algebra/syntax.spad.pamphlet b/src/algebra/syntax.spad.pamphlet
index e0d71282..ca967397 100644
--- a/src/algebra/syntax.spad.pamphlet
+++ b/src/algebra/syntax.spad.pamphlet
@@ -372,9 +372,7 @@ import CoercibleTo Syntax
++ Date Last Modified: September 21, 2008
++ Description: This is the category of Spad abstract syntax trees.
AbstractSyntaxCategory(): Category ==
- Join(SetCategory, CoercibleTo Syntax) with
- coerce: Syntax -> %
- ++ coerce(s) parses syntax object `s' as a Spad construct.
+ Join(SetCategory, HomotopicTo Syntax)
add
coerce(x: %): Syntax ==
x pretend Syntax
diff --git a/src/algebra/tex.spad.pamphlet b/src/algebra/tex.spad.pamphlet
index adc11106..1144842d 100644
--- a/src/algebra/tex.spad.pamphlet
+++ b/src/algebra/tex.spad.pamphlet
@@ -89,10 +89,7 @@ TexFormat(): public == private where
S ==> String
US ==> UniversalSegment(Integer)
- public == SetCategory with
- coerce: E -> $
- ++ coerce(o) changes o in the standard output format to TeX
- ++ format.
+ public == Join(SetCategory,CoercibleFrom E) with
convert: (E,I) -> $
++ convert(o,step) changes o in standard output format to
++ TeX format and also adds the given step number. This is useful
diff --git a/src/algebra/tree.spad.pamphlet b/src/algebra/tree.spad.pamphlet
index c574d9a4..5b573f8f 100644
--- a/src/algebra/tree.spad.pamphlet
+++ b/src/algebra/tree.spad.pamphlet
@@ -615,14 +615,11 @@ BalancedBinaryTree(S: SetCategory): Exports == Implementation where
++ A PendantTree(S)is either a leaf? and is an S or has
++ a left and a right both PendantTree(S)'s
PendantTree(S: SetCategory): T == C where
- T == BinaryRecursiveAggregate(S) with
+ T == Join(BinaryRecursiveAggregate(S),CoercibleTo Tree S) with
ptree : S->%
++ ptree(s) is a leaf? pendant tree
ptree:(%, %)->%
++ ptree(x,y) \undocumented
- coerce:%->Tree S
- ++ coerce(x) \undocumented
-
C == add
Rep := Tree S
diff --git a/src/algebra/xpoly.spad.pamphlet b/src/algebra/xpoly.spad.pamphlet
index 4049f1b6..c80e3e53 100644
--- a/src/algebra/xpoly.spad.pamphlet
+++ b/src/algebra/xpoly.spad.pamphlet
@@ -379,10 +379,7 @@ import Algebra
++ Author: Michel Petitot (petitot@lifl.fr)
XAlgebra(R: Ring): Category ==
- Join(Ring, BiModule(R,R)) with
- --operations
- coerce: R -> %
- ++ \spad{coerce(r)} equals \spad{r*1}.
+ Join(Ring, BiModule(R,R),CoercibleFrom R) with
-- attributs
if R has CommutativeRing then Algebra(R)
-- if R has CommutativeRing then Module(R)
@@ -548,14 +545,12 @@ XPolynomialRing(R:Ring,E:OrderedMonoid): T == C where
EX ==> OutputForm
NNI ==> NonNegativeInteger
- T == Join(Ring, XAlgebra(R), FreeModuleCat(R,E)) with
+ T == Join(Ring, XAlgebra(R), FreeModuleCat(R,E),CoercibleFrom E) with
--operations
"*": (%,R) -> %
++ \spad{p*r} returns the product of \spad{p} by \spad{r}.
"#": % -> NonNegativeInteger
++ \spad{# p} returns the number of terms in \spad{p}.
- coerce: E -> %
- ++ \spad{coerce(e)} returns \spad{1*e}
maxdeg: % -> E
++ \spad{maxdeg(p)} returns the greatest word occurring in the polynomial \spad{p}
++ with a non-zero coefficient. An error is produced if \spad{p} is zero.