Fix AW/66

	* algebra/zerodim.spad.pamphlet: Restore use of one? 
	* algebra/updivp.spad.pamphlet: Likewise.
	* algebra/unifact.spad.pamphlet: Likewise.
	* algebra/triset.spad.pamphlet: Likewise.
	* algebra/tools.spad.pamphlet: Likewise.
	* algebra/suts.spad.pamphlet: Likewise.
	* algebra/sttaylor.spad.pamphlet: Likewise.
	* algebra/string.spad.pamphlet: Likewise.
	* algebra/sregset.spad.pamphlet: Likewise.
	* algebra/si.spad.pamphlet: Likewise.
	* algebra/sf.spad.pamphlet: Likewise.
	* algebra/riccati.spad.pamphlet: Likewise.
	* algebra/rf.spad.pamphlet: Likewise.
	* algebra/regset.spad.pamphlet: Likewise.
	* algebra/rderf.spad.pamphlet: Likewise.
	* algebra/rdeef.spad.pamphlet: Likewise.
	* algebra/quat.spad.pamphlet: Likewise.
	* algebra/puiseux.spad.pamphlet: Likewise.
	* algebra/pscat.spad.pamphlet: Likewise.
	* algebra/prtition.spad.pamphlet: Likewise.
	* algebra/prs.spad.pamphlet: Likewise.
	* algebra/primelt.spad.pamphlet: Likewise.
	* algebra/polycat.spad.pamphlet: Likewise.
	* algebra/poly.spad.pamphlet: Likewise.
	* algebra/polset.spad.pamphlet: Likewise.
	* algebra/pfo.spad.pamphlet: Likewise.
	* algebra/perm.spad.pamphlet: Likewise.
	* algebra/pattern.spad.pamphlet: Likewise.
	* algebra/padiclib.spad.pamphlet:Likewise.
	* algebra/openmath.spad.pamphlet: Likewise.
	* algebra/opalg.spad.pamphlet: Likewise.
	* algebra/op.spad.pamphlet: Likewise.
	* algebra/omerror.spad.pamphlet: Likewise.
	* algebra/oderf.spad.pamphlet: Likewise.
	* algebra/odeef.spad.pamphlet: Likewise.
	* algebra/oct.spad.pamphlet: Likewise.
	* algebra/nlinsol.spad.pamphlet: Likewise.
	* algebra/newpoly.spad.pamphlet: Likewise.
	* algebra/naalgc.spad.pamphlet: Likewise.
	* algebra/naalg.spad.pamphlet: Likewise.
	* algebra/multpoly.spad.pamphlet: Likewise.
	* algebra/mring.spad.pamphlet: Likewise.
	* algebra/modring.spad.pamphlet: Likewise.
	* algebra/moddfact.spad.pamphlet: Likewise.
	* algebra/mkfunc.spad.pamphlet: Likewise.
	* algebra/matstor.spad.pamphlet: Likewise.
	* algebra/matrix.spad.pamphlet: Likewise.
	* algebra/matcat.spad.pamphlet: Likewise.
	* algebra/manip.spad.pamphlet: Likewise.
	* algebra/lodof.spad.pamphlet: Likewise.
	* algebra/liouv.spad.pamphlet: Likewise.
	* algebra/laplace.spad.pamphlet: Likewise.
	* algebra/irexpand.spad.pamphlet: Likewise.
	* algebra/intrf.spad.pamphlet: Likewise.
	* algebra/intpm.spad.pamphlet: Likewise.
	* algebra/intfact.spad.pamphlet: Likewise.
	* algebra/integer.spad.pamphlet: Likewise.
	* algebra/intclos.spad.pamphlet: Likewise.
	* algebra/intaux.spad.pamphlet: Likewise.
	* algebra/intalg.spad.pamphlet: Likewise.
	* algebra/intaf.spad.pamphlet: Likewise.
	* algebra/gpol.spad.pamphlet: Likewise.
	* algebra/gpgcd.spad.pamphlet: Likewise.
	* algebra/gb.spad.pamphlet: Likewise.
	* algebra/gaussian.spad.pamphlet: Likewise.
	* algebra/galutil.spad.pamphlet: Likewise.
	* algebra/galpolyu.spad.pamphlet: Likewise.
	* algebra/galfact.spad.pamphlet: Likewise.
	* algebra/fspace.spad.pamphlet: Likewise.
	* algebra/fs2ups.spad.pamphlet: Likewise.
	* algebra/fs2expxp.spad.pamphlet: Likewise.
	* algebra/free.spad.pamphlet: Likewise.
	* algebra/fraction.spad.pamphlet: Likewise.
	* algebra/fr.spad.pamphlet: Likewise.
	* algebra/fparfrac.spad.pamphlet: Likewise.
	* algebra/fortran.spad.pamphlet: Likewise.
	* algebra/fmod.spad.pamphlet: Likewise.
	* algebra/float.spad.pamphlet: Likewise.
	* algebra/ffx.spad.pamphlet: Likewise.
	* algebra/ffnb.spad.pamphlet: Likewise.
	* algebra/ffcg.spad.pamphlet: Likewise.
	* algebra/ffcat.spad.pamphlet: Likewise.
	* algebra/exprode.spad.pamphlet: Likewise.
	* algebra/expr.spad.pamphlet: Likewise.
	* algebra/expexpan.spad.pamphlet: Likewise.
	* algebra/elemntry.spad.pamphlet: Likewise.
	* algebra/efupxs.spad.pamphlet: Likewise.
	* algebra/efuls.spad.pamphlet: Likewise.
	* algebra/e04routine.spad.pamphlet: Likewise.
	* algebra/e04agents.spad.pamphlet: Likewise.
	* algebra/divisor.spad.pamphlet: Likewise.
	* algebra/derham.spad.pamphlet: Likewise.
	* algebra/defintrf.spad.pamphlet: Likewise.
	* algebra/defintef.spad.pamphlet: Likewise.
	* algebra/defaults.spad.pamphlet: Likewise.
	* algebra/d03agents.spad.pamphlet: Likewise.
	* algebra/d01weights.spad.pamphlet: Likewise.
	* algebra/d01routine.spad.pamphlet: Likewise.
	* algebra/d01agents.spad.pamphlet: Likewise.
	* algebra/curve.spad.pamphlet: Likewise.
	* algebra/crfp.spad.pamphlet: Likewise.
	* algebra/cont.spad.pamphlet: Likewise.
	* algebra/constant.spad.pamphlet: Likewise.
	* algebra/complet.spad.pamphlet: Likewise.
	* algebra/combfunc.spad.pamphlet: Likewise.
	* algebra/catdef.spad.pamphlet: Likewise.
	* algebra/brill.spad.pamphlet: Likewise.
	* algebra/array1.spad.pamphlet: Likewise.
	* algebra/algfunc.spad.pamphlet: Likewise.
	* algebra/algfact.spad.pamphlet: Likewise.

1 files changed, 10 insertions, 20 deletions

diff --git a/src/algebra/manip.spad.pamphlet b/src/algebra/manip.spad.pamphlet
index e112a811..17fb455a 100644
--- a/src/algebra/manip.spad.pamphlet
+++ b/src/algebra/manip.spad.pamphlet
@@ -33,8 +33,7 @@ FactoredFunctions(M:IntegralDomain): Exports == Implementation where
   Implementation ==> add
     nthRoot(ff, n) ==
       coeff:M       := 1
---      radi:List(M)  := (one? unit ff => empty(); [unit ff])
-      radi:List(M)  := (((unit ff) = 1) => empty(); [unit ff])
+      radi:List(M)  := (one? unit ff => empty(); [unit ff])
       lf            := factors ff
       d:N :=
         empty? radi => gcd(concat(n, [t.exponent::N for t in lf]))::N
@@ -100,8 +99,7 @@ PolynomialRoots(E, V, R, P, F):Exports == Implementation where
     zroot : (Z, N) -> Record(exponent:N, coef:Z, radicand:Z)
 
     zroot(x, n) ==
---      zero? x or one? x => [1, x, 1]
-      zero? x or (x = 1) => [1, x, 1]
+      zero? x or one? x => [1, x, 1]
       s := nthRoot(squareFree x, n)
       [s.exponent, s.coef, */s.radicand]
 
@@ -164,8 +162,7 @@ PolynomialRoots(E, V, R, P, F):Exports == Implementation where
       else nthr(x, n) == nthRoot(squareFree x, n)
 
       froot(x, n) ==
---        zero? x or one? x => [1, x, 1]
-        zero? x or (x = 1) => [1, x, 1]
+        zero? x or one? x => [1, x, 1]
         sn := nthr(numer x, n)
         sd := nthr(denom x, n)
         pn := rsplit(sn.radicand)
@@ -358,18 +355,15 @@ AlgebraicManipulations(R, F): Exports == Implementation where
         q := univariate(p, k)
         while (d := degree q) > 0 repeat
           term :=
---            one?(g := gcd(d, n)) => monomial(1, k, d)
-            ((g := gcd(d, n)) = 1) => monomial(1, k, d)
+            one?(g := gcd(d, n)) => monomial(1, k, d)
             monomial(1, kernel(operator k, [a,(n quo g)::F], height k), d quo g)
           ans := ans + leadingCoefficient(q)::F * term::F
           q := reductum q
         leadingCoefficient(q)::F + ans
 
       inroot(op, x, n) ==
---        one? x => x
-        (x = 1) => x
---        (x ~= -1) and (one?(num := numer x) or (num = -1)) =>
-        (x ~= -1) and (((num := numer x) = 1) or (num = -1)) =>
+        one? x => x
+        (x ~= -1) and (one?(num := numer x) or (num = -1)) =>
           inv inroot(op, (num * denom x)::F, n)
         (u := isExpt(x, op)) case "failed" => kernel(op, [x, n::F])
         pr := u::Record(var:K, exponent:Integer)
@@ -648,13 +642,11 @@ TranscendentalManipulations(R, F): Exports == Implementation where
       not (terms case "failed") => logArgs(terms) 
 
       expt : Union(POW, "failed") := isPower(e)
---      (expt case POW) and not one? expt.exponent =>
-      (expt case POW) and not (expt.exponent = 1) =>
+      (expt case POW) and not one? expt.exponent =>
         simplifyLog(expt.val)**(expt.exponent)
     
       kers : List K := kernels e
---      not(one?(#kers)) => e -- Have a constant
-      not(((#kers) = 1)) => e -- Have a constant
+      not(one?(#kers)) => e -- Have a constant
       kernel(operator first kers,[simplifyLog(u) for u in argument first kers])
 
 
@@ -666,10 +658,8 @@ TranscendentalManipulations(R, F): Exports == Implementation where
     expandpow k ==
       a := expandPower first(arg := argument k)
       b := expandPower second arg
---      ne:F := (one? numer a => 1; numer(a)::F ** b)
-      ne:F := (((numer a) = 1) => 1; numer(a)::F ** b)
---      de:F := (one? denom a => 1; denom(a)::F ** (-b))
-      de:F := (((denom a) = 1) => 1; denom(a)::F ** (-b))
+      ne:F := (one? numer a => 1; numer(a)::F ** b)
+      de:F := (one? denom a => 1; denom(a)::F ** (-b))
       ne * de
 
     termexp p ==