2008-09-01 Martin Rubey <martin.rubey@univie.ac.at>

	    Gabriel Dos Reis  <gdr@cs.tamu.edu>

	Fix AW/431
	* algebra/ore.spad.pamphlet (SpareUnivariateSkewPolynomial):
	Implement **.

2008-09-01  Gabriel Dos Reis  <gdr@cs.tamu.edu>

	Make ^ an alias for **.
	* interp/postpar.boot (postAtom): Replace "^" with "**".
	* interp/format.boot (reportOpSymbol): Announce that "^" is an
	alias for "**".
	* interp/nrungo.boot (compiledLookup): Be sure to look for "**"
	when operation is "^".
	* interp/define.boot (noteCapsuleFunctionDefinition): New.
	(clearCapsuleFunctionTable): Likewise.
	(noteExport): Likewise.
	(clearExportsTable): Likewise.
	(compDefineCapsuleFunction): Rename "^" to "**".  Take a note
	of the capsule function being compiled.
	(compCapsule): Clear previous capsule functions table.
	(doItIf): Keep track of predicate validity.
	(compCategory): Clear previous exports table.
	(compCategoryItem): Take notes of declared attributes and signatures.
	* algebra/catdef.spad.pamphlet (DivisionRing): Remove duplicate
	definition for "^".
	(Group): Likewise.
	(Monoid): Likewise.
	(SemiGroup): Likewise.
	* algebra/poly.spad.pamphlet (PolynomialRing): Remove duplicate
	definitins of "^".
	(SparseUnivariatePolynomial): Likewise.
	* algebra/multpoly.spad.pamphlet (SparseMultivariatePolynomial):
	Remove duplicate definitions for "^".
	* algebra/interval.spad.pamphlet (Interval): Remove duplicate
	definition for "^".
	* algebra/curve.spad.pamphlet (FunctionFieldCategory): Remove
	duplicate declaration for represents.
	* algebra/strap/: Update cached Lisp translations.
	* share/algebra: Update databases.

1 files changed, 28 insertions, 44 deletions

diff --git a/src/algebra/strap/DIVRING-.lsp b/src/algebra/strap/DIVRING-.lsp
index 88bef6a2..21f2fc94 100644
--- a/src/algebra/strap/DIVRING-.lsp
+++ b/src/algebra/strap/DIVRING-.lsp
@@ -1,28 +1,25 @@
 
 (/VERSIONCHECK 2) 
 
-(DEFUN |DIVRING-;^;SIS;1| (|x| |n| $)
-  (SPADCALL |x| |n| (|getShellEntry| $ 8))) 
-
-(DEFUN |DIVRING-;**;SIS;2| (|x| |n| $)
+(DEFUN |DIVRING-;**;SIS;1| (|x| |n| $)
   (COND
-    ((ZEROP |n|) (|spadConstant| $ 10))
-    ((SPADCALL |x| (|getShellEntry| $ 12))
+    ((ZEROP |n|) (|spadConstant| $ 7))
+    ((SPADCALL |x| (|getShellEntry| $ 9))
      (COND ((< |n| 0) (|error| "division by zero")) ('T |x|)))
     ((< |n| 0)
-     (SPADCALL (SPADCALL |x| (|getShellEntry| $ 14)) (- |n|)
-         (|getShellEntry| $ 17)))
-    ('T (SPADCALL |x| |n| (|getShellEntry| $ 17))))) 
+     (SPADCALL (SPADCALL |x| (|getShellEntry| $ 11)) (- |n|)
+         (|getShellEntry| $ 14)))
+    ('T (SPADCALL |x| |n| (|getShellEntry| $ 14))))) 
 
-(DEFUN |DIVRING-;*;F2S;3| (|q| |x| $)
+(DEFUN |DIVRING-;*;F2S;2| (|q| |x| $)
   (SPADCALL
-      (SPADCALL (SPADCALL |q| (|getShellEntry| $ 20))
+      (SPADCALL (SPADCALL |q| (|getShellEntry| $ 18))
           (SPADCALL
-              (SPADCALL (SPADCALL |q| (|getShellEntry| $ 21))
-                  (|getShellEntry| $ 22))
-              (|getShellEntry| $ 14))
-          (|getShellEntry| $ 23))
-      |x| (|getShellEntry| $ 24))) 
+              (SPADCALL (SPADCALL |q| (|getShellEntry| $ 19))
+                  (|getShellEntry| $ 20))
+              (|getShellEntry| $ 11))
+          (|getShellEntry| $ 21))
+      |x| (|getShellEntry| $ 22))) 
 
 (DEFUN |DivisionRing&| (|#1|)
   (PROG (|dv$1| |dv$| $ |pv$|)
@@ -30,7 +27,7 @@
       (PROGN
         (LETT |dv$1| (|devaluate| |#1|) . #0=(|DivisionRing&|))
         (LETT |dv$| (LIST '|DivisionRing&| |dv$1|) . #0#)
-        (LETT $ (|newShell| 27) . #0#)
+        (LETT $ (|newShell| 25) . #0#)
         (|setShellEntry| $ 0 |dv$|)
         (|setShellEntry| $ 3
             (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
@@ -39,42 +36,36 @@
         $)))) 
 
 (MAKEPROP '|DivisionRing&| '|infovec|
-    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|Integer|)
-             (0 . **) |DIVRING-;^;SIS;1| (6 . |One|) (|Boolean|)
-             (10 . |zero?|) (15 . |Zero|) (19 . |inv|)
-             (|PositiveInteger|) (|RepeatedSquaring| 6) (24 . |expt|)
-             |DIVRING-;**;SIS;2| (|Fraction| 7) (30 . |numer|)
-             (35 . |denom|) (40 . |coerce|) (45 . *) (51 . *)
-             |DIVRING-;*;F2S;3| (|NonNegativeInteger|))
-          '#(^ 57 ** 63 * 69) 'NIL
+    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (0 . |One|)
+             (|Boolean|) (4 . |zero?|) (9 . |Zero|) (13 . |inv|)
+             (|PositiveInteger|) (|RepeatedSquaring| 6) (18 . |expt|)
+             (|Integer|) |DIVRING-;**;SIS;1| (|Fraction| 15)
+             (24 . |numer|) (29 . |denom|) (34 . |coerce|) (39 . *)
+             (45 . *) |DIVRING-;*;F2S;2| (|NonNegativeInteger|))
+          '#(** 51 * 57) 'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
-                            (|makeByteWordVec2| 25
-                                '(2 6 0 0 7 8 0 6 0 10 1 6 11 0 12 0 6
-                                  0 13 1 6 0 0 14 2 16 6 6 15 17 1 19 7
-                                  0 20 1 19 7 0 21 1 6 0 7 22 2 6 0 7 0
-                                  23 2 6 0 0 0 24 2 0 0 0 7 9 2 0 0 0 7
-                                  18 2 0 0 19 0 25)))))
+                            (|makeByteWordVec2| 23
+                                '(0 6 0 7 1 6 8 0 9 0 6 0 10 1 6 0 0 11
+                                  2 13 6 6 12 14 1 17 15 0 18 1 17 15 0
+                                  19 1 6 0 15 20 2 6 0 15 0 21 2 6 0 0
+                                  0 22 2 0 0 0 15 16 2 0 0 17 0 23)))))
           '|lookupComplete|)) 
 
 (SETQ |$CategoryFrame|
       (|put| '|DivisionRing&| '|isFunctor|
-             '(((^ ($ $ (|Integer|))) T (ELT $ 9))
-               ((** ($ $ (|Integer|))) T (ELT $ 18))
+             '(((** ($ $ (|Integer|))) T (ELT $ 16))
                ((* ($ $ (|Fraction| (|Integer|)))) T (ELT $ NIL))
-               ((* ($ (|Fraction| (|Integer|)) $)) T (ELT $ 25))
+               ((* ($ (|Fraction| (|Integer|)) $)) T (ELT $ 23))
                ((** ($ $ (|NonNegativeInteger|))) T (ELT $ NIL))
-               ((^ ($ $ (|NonNegativeInteger|))) T (ELT $ NIL))
                ((* ($ $ $)) T (ELT $ NIL))
                ((** ($ $ (|PositiveInteger|))) T (ELT $ NIL))
-               ((^ ($ $ (|PositiveInteger|))) T (ELT $ NIL))
                ((* ($ (|Integer|) $)) T (ELT $ NIL))
                ((* ($ (|NonNegativeInteger|) $)) T (ELT $ NIL))
                ((* ($ (|PositiveInteger|) $)) T (ELT $ NIL)))
              (|addModemap| '|DivisionRing&| '(|DivisionRing&| |#1|)
                  '((CATEGORY |domain|
-                       (SIGNATURE ^ (|#1| |#1| (|Integer|)))
                        (SIGNATURE ** (|#1| |#1| (|Integer|)))
                        (SIGNATURE *
                            (|#1| |#1| (|Fraction| (|Integer|))))
@@ -82,10 +73,8 @@
                            (|#1| (|Fraction| (|Integer|)) |#1|))
                        (SIGNATURE **
                            (|#1| |#1| (|NonNegativeInteger|)))
-                       (SIGNATURE ^ (|#1| |#1| (|NonNegativeInteger|)))
                        (SIGNATURE * (|#1| |#1| |#1|))
                        (SIGNATURE ** (|#1| |#1| (|PositiveInteger|)))
-                       (SIGNATURE ^ (|#1| |#1| (|PositiveInteger|)))
                        (SIGNATURE * (|#1| (|Integer|) |#1|))
                        (SIGNATURE * (|#1| (|NonNegativeInteger|) |#1|))
                        (SIGNATURE * (|#1| (|PositiveInteger|) |#1|)))
@@ -94,7 +83,6 @@
                  (|put| '|DivisionRing&| '|mode|
                         '(|Mapping|
                              (CATEGORY |domain|
-                                 (SIGNATURE ^ (|#1| |#1| (|Integer|)))
                                  (SIGNATURE ** (|#1| |#1| (|Integer|)))
                                  (SIGNATURE *
                                      (|#1| |#1|
@@ -104,13 +92,9 @@
                                       |#1|))
                                  (SIGNATURE **
                                      (|#1| |#1| (|NonNegativeInteger|)))
-                                 (SIGNATURE ^
-                                     (|#1| |#1| (|NonNegativeInteger|)))
                                  (SIGNATURE * (|#1| |#1| |#1|))
                                  (SIGNATURE **
                                      (|#1| |#1| (|PositiveInteger|)))
-                                 (SIGNATURE ^
-                                     (|#1| |#1| (|PositiveInteger|)))
                                  (SIGNATURE * (|#1| (|Integer|) |#1|))
                                  (SIGNATURE *
                                      (|#1| (|NonNegativeInteger|) |#1|))