Index: /branches/new-random/level-0/l0-numbers.lisp
===================================================================
--- /branches/new-random/level-0/l0-numbers.lisp	(revision 13322)
+++ /branches/new-random/level-0/l0-numbers.lisp	(revision 13323)
@@ -1806,5 +1806,5 @@
 ;;; too bad in a 64-bit CCL, but the generator pretty much has to be
 ;;; in LAP for 32-bit ports.
-#-x86-target
+#-(or x8632-target ppc32-target x8664-target)
 (defun %mrg31k3p (state)
   (let* ((v state))
@@ -1845,11 +1845,6 @@
   (declaim (inline %16-random-bits)))
 
-#-x86-target
 (defun %16-random-bits (state)
-  (%next-random-seed state))
-
-#+x86-target
-(defun %16-random-bits (state)
-  (logand #xffff (the fixnum (%mrg31kp3 state))))
+  (logand #xffff (the fixnum (%mrg31k3p state))))
 
 #+64-bit-target
@@ -1862,54 +1857,4 @@
     (fast-mod (logior low (the fixnum (ash high 30)))
 	      number)))
-
-#|
-Date: Mon, 3 Feb 1997 10:04:08 -0500
-To: info-mcl@digitool.com, wineberg@franz.scs.carleton.ca
-From: dds@flavors.com (Duncan Smith)
-Subject: Re: More info on the random number generator
-Sender: owner-info-mcl@digitool.com
-Precedence: bulk
-
-The generator is a Linear Congruential Generator:
-
-   X[n+1] = (aX[n] + c) mod m
-
-where: a = 16807  (Park&Miller recommend 48271)
-       c = 0
-       m = 2^31 - 1
-
-See: Knuth, Seminumerical Algorithms (Volume 2), Chapter 3.
-
-The period is: 2^31 - 2  (zero is excluded).
-
-What makes this generator so simple is that multiplication and addition mod
-2^n-1 is easy.  See Knuth Ch. 4.3.2 (2nd Ed. p 272).
-
-    ab mod m = ...
-
-If         m = 2^n-1
-           u = ab mod 2^n
-           v = floor( ab / 2^n )
-
-    ab mod m = u + v                   :  u+v < 2^n
-    ab mod m = ((u + v) mod 2^n) + 1   :  u+v >= 2^n
-
-What we do is use 2b and 2^n so we can do arithemetic mod 2^32 instead of
-2^31.  This reduces the whole generator to 5 instructions on the 680x0 or
-80x86, and 8 on the 60x.
-
--Duncan
-
-|#
-
-#+(and 32-bit-target (not x86-target))
-(defun %next-random-seed (state)
-  (multiple-value-bind (high low) (%next-random-pair (random.seed-1 state)
-                                                     (random.seed-2 state))
-    (declare (type (unsigned-byte 15) high)
-             (type (unsigned-byte 16) low))
-    (setf (random.seed-1 state) high
-          (random.seed-2 state) low)
-    (logior high (thes fixnum (logand low (ash 1 15))))))
 
 ;;; When using a dead simple random number generator, it's reasonable
@@ -1958,27 +1903,4 @@
     (* number ratio)))
 
-#+(and 32-bit-target (not x86-target))
-(defun random (number &optional (state *random-state*))
-  (if (not (typep state 'random-state)) (report-bad-arg state 'random-state))
-  (cond
-     ((and (fixnump number) (> (the fixnum number) 0))
-      (locally (declare (fixnum number))
-        (if (< number 65536)
-          (fast-mod (%next-random-seed state) number)
-          (let* ((n 0)
-                 (nhalf (ash (+ 15 (integer-length number)) -4)))
-            (declare (fixnum n nhalf))
-            (dotimes (i nhalf (fast-mod n number))
-              (setq n (logior (the fixnum (ash n 16))
-                              (the fixnum (%next-random-seed state)))))))))
-     ((and (typep number 'double-float) (> (the double-float number) 0.0))
-      (%float-random number state))
-     ((and (typep number 'short-float) (> (the short-float number) 0.0s0))
-      (%float-random number state))
-     ((and (bignump number) (> number 0))
-      (%bignum-random number state))
-     (t (report-bad-arg number '(or (integer (0)) (float (0.0)))))))
-
-#+x86-target
 (defun random (number &optional (state *random-state*))
   (if (not (typep state 'random-state)) (report-bad-arg state 'random-state))