diff --git a/doc/gambit-c.txi b/doc/gambit-c.txi
index 079b540..f21328e 100644
--- a/doc/gambit-c.txi
+++ b/doc/gambit-c.txi
@@ -4402,7 +4402,8 @@ pseudo random number is generated from this random source object.
 
 The global variable @code{default-random-source} is bound to the
 random source object which is used by the @code{random-integer},
-@code{random-real} and @code{random-u8vector} procedures.
+@code{random-real}, @code{random-u8vector} and @code{random-f64vector}
+procedures.
 
 @end defvr
 
@@ -4448,7 +4449,7 @@ For example:
 This procedure returns a u8vector of length @var{n} containing pseudo
 random exact integers in the range 0 to 255.  The random source object
 in the global variable @code{default-random-source} is used to
-generate this number.  The parameter @var{n} must be a nonnegative
+generate these numbers.  The parameter @var{n} must be a nonnegative
 exact integer.
 
 For example:
@@ -4460,6 +4461,23 @@ For example:
 
 @end deffn
 
+@deffn procedure random-f64vector @var{n}
+
+This procedure returns a f64vector of length @var{n} containing pseudo
+random inexact reals between, but not including, 0 and 1.  The random
+source object in the global variable @code{default-random-source} is
+used to generate these numbers.  The parameter @var{n} must be a nonnegative
+exact integer.
+
+For example:
+
+@smallexample
+> @b{(random-f64vector 3)}
+#f64(.7145854494613069 .47089632669147946 .5400124875182746)
+@end smallexample
+
+@end deffn
+
 @deffn procedure make-random-source
 
 This procedure returns a new random source object initialized to a
@@ -4576,12 +4594,14 @@ For example:
 
 @end deffn
 
-@deffn procedure random-source-make-reals @var{random-source}
+@deffn procedure random-source-make-reals @var{random-source} @r{[}@var{precision}@r{]}
 
 This procedure returns a procedure for generating pseudo random
 inexact reals using the random source object @var{random-source}.  The
 returned procedure accepts no parameters and returns a pseudo random
-inexact real between, but not including, 0 and 1.
+inexact real between, but not including, 0 and 1.  The optional parameter
+@var{precision} specifies an upper bound on the minimum amount by which two
+generated pseudo-random numbers can be separated.
 
 For example:
 
@@ -4617,6 +4637,29 @@ For example:
 
 @end deffn
 
+@deffn procedure random-source-make-f64vectors @var{random-source} @r{[}@var{precision}@r{]}
+
+This procedure returns a procedure for generating pseudo random
+f64vectors using the random source object @var{random-source}.  The
+returned procedure accepts a single parameter @var{n}, a nonnegative
+exact integer, and returns an f64vector of length @var{n} containing
+pseudo random inexact reals between, but not including, 0 and 1.
+The optional parameter @var{precision} specifies an upper bound on the
+minimum amount by which two generated pseudo-random numbers can be separated.
+
+For example:
+
+@smallexample
+> @b{(define rs (make-random-source))}
+> @b{(define rv (random-source-make-f64vectors rs))}
+> @b{(rv 3)}
+#f64(.7342236104231586 .2876463473845367 .8574025375628211)
+> @b{(rv 3)}
+#f64(.013863292728449427 .33449296573515447 .8162050798467028)
+@end smallexample
+
+@end deffn
+
 @node Homogeneous vectors, Hashing and weak references, Numbers, Top
 @chapter Homogeneous vectors
 @cindex homogeneous vectors
diff --git a/doc/makefile.in b/doc/makefile.in
index 109c8c8..80b7dd1 100644
--- a/doc/makefile.in
+++ b/doc/makefile.in
@@ -76,12 +76,12 @@ m1.c m2.scm m3.scm m4.scm m5.scm m6.scm m7.scm x.c x.h h.scm w.six \
 test1.scm test2.scm test3.scm
 
 GENDISTFILES = stamp.vti version.txi \
-gambit-c.pdf gambit-c.html gambit-c.txt \
+gambit-c.pdf gambit-c*.html gambit-c.txt \
 gambit-c.info gambit-c.info-1 gambit-c.info-2 gambit-c.info-3
 
 DISTFILES = $(RCFILES) $(GENDISTFILES)
 
-INSTFILES_DOC = gambit-c.pdf gambit-c.html gambit-c.txt
+INSTFILES_DOC = gambit-c.pdf gambit-c*.html gambit-c.txt
 INSTFILES_INFO = gambit-c.info*
 
 all: all-pre all-recursive all-post
diff --git a/include/stamp.h b/include/stamp.h
index 8251925..8889472 100644
--- a/include/stamp.h
+++ b/include/stamp.h
@@ -3,4 +3,4 @@
  */
 
 #define ___STAMP_YMD 20090113
-#define ___STAMP_HMS 190741
+#define ___STAMP_HMS 191201
diff --git a/lib/_num.scm b/lib/_num.scm
index bca6bfa..344d32b 100644
--- a/lib/_num.scm
+++ b/lib/_num.scm
@@ -10671,6 +10671,7 @@ ___RESULT = result;
   (make-integers     unprintable: read-only:)
   (make-reals        unprintable: read-only:)
   (make-u8vectors    unprintable: read-only:)
+  (make-f64vectors   unprintable: read-only:)
   )
 
 (define-check-type random-source
@@ -10953,7 +10954,8 @@ ___RESULT = result;
 
     (define (advance-state!)
       (##declare (not interrupts-enabled))
-      (let* ((x10
+      (let* ((state state)
+	     (x10
               (fl- (fl* 1403580.0 (f64vector-ref state 1))
                    (fl* 810728.0 (f64vector-ref state 2))))
              (y10
@@ -10966,20 +10968,19 @@ ___RESULT = result;
              (y20
               (fl- x20
                    (fl* (flfloor (fl/ x20 (macro-m2-inexact)))
-                        (macro-m2-inexact))))
-             (dx
-              (fl- y10 y20))
-             (dy
-              (fl- dx
-                   (fl* (flfloor (fl/ dx (macro-m1-inexact)))
-                        (macro-m1-inexact)))))
+                        (macro-m2-inexact)))))
         (f64vector-set! state 5 (f64vector-ref state 4))
         (f64vector-set! state 4 (f64vector-ref state 3))
         (f64vector-set! state 3 y20)
         (f64vector-set! state 2 (f64vector-ref state 1))
         (f64vector-set! state 1 (f64vector-ref state 0))
         (f64vector-set! state 0 y10)
-        (f64vector-set! state 6 dy)))
+	(if (fl< y10 y20)
+	    (f64vector-set! state 6 (fl+ (macro-m1-inexact)
+					 (fl- (f64vector-ref state 0)
+					      (f64vector-ref state 3))))
+	    (f64vector-set! state 6 (fl- (f64vector-ref state 0)
+					 (f64vector-ref state 3))))))
 
     (define (make-integers)
 
@@ -11093,8 +11094,8 @@ ___RESULT = result;
           (lambda ()
             (##declare (not interrupts-enabled))
             (advance-state!)
-            (fl/ (fl+ (macro-inexact-+1) (f64vector-ref state 6))
-                 (macro-m1-plus-1-inexact)))))
+            (fl* (fl+ (macro-inexact-+1) (f64vector-ref state 6))
+                 (macro-inv-m1-plus-1-inexact)))))
 
     (define (make-u8vectors)
 
@@ -11111,6 +11112,34 @@ ___RESULT = result;
 
       random-u8vector)
 
+    (define (make-f64vectors precision)
+      (if (fl< precision (macro-inv-m1-plus-1-inexact))
+	  (let ((make-real (make-reals precision)))
+	    (lambda (len)
+	      (macro-force-vars (len)
+                (macro-check-index len 1 (random-f64vector len)
+                  (let ((f64vect (##make-f64vector len 0.)))
+		    (let loop ((i (fx- len 1)))
+		      (if (fx< i 0)
+			  f64vect
+			  (begin
+			    (##f64vector-set! f64vect i (make-real))
+			    (loop (fx- i 1))))))))))
+	  (lambda (len)
+	    (macro-force-vars (len)
+              (macro-check-index len 1 (random-f64vector len)
+                (let ((f64vect (##make-f64vector len 0.)))
+		  (let loop ((i (fx- len 1)))
+		    (if (fx< i 0)
+			f64vect
+			(let ()
+			  (##declare (not interrupts-enabled))
+			  (advance-state!)
+			  (##f64vector-set! f64vect i (fl* (fl+ (macro-inexact-+1)
+								(f64vector-ref state 6))
+							   (macro-inv-m1-plus-1-inexact)))
+			  (loop (fx- i 1)))))))))))
+
     (macro-make-random-source
      state-ref
      state-set!
@@ -11118,7 +11147,8 @@ ___RESULT = result;
      pseudo-randomize!
      make-integers
      make-reals
-     make-u8vectors)))
+     make-u8vectors
+     make-f64vectors)))
 
 (define-prim (make-random-source)
   (##make-random-source-mrg32k3a))
@@ -11194,6 +11224,25 @@ ___RESULT = result;
                     (##raise-range-exception 2 random-source-make-reals rs p)))
               (##fail-check-finite-real 2 random-source-make-reals rs p))))))
 
+(define-prim (##random-source-make-f64vectors rs #!optional (p (macro-absent-obj)))
+  ((macro-random-source-make-f64vectors rs)
+   (if (eq? p (macro-absent-obj))
+       (macro-inexact-+1)
+       p)))
+
+(define-prim (random-source-make-f64vectors rs #!optional (p (macro-absent-obj)))
+  (macro-force-vars (rs p)
+    (macro-check-random-source rs 1 (random-source-make-f64vectors rs p)
+      (if (eq? p (macro-absent-obj))
+          (##random-source-make-f64vectors rs)
+          (if (rational? p)
+              (let ((precision (macro-real->inexact p)))
+                (if (and (fl< (macro-inexact-+0) precision)
+                         (fl< precision (macro-inexact-+1)))
+                    (##random-source-make-f64vectors rs precision)
+                    (##raise-range-exception 2 random-source-make-f64vectors rs p)))
+              (##fail-check-finite-real 2 random-source-make-f64vectors rs p))))))
+
 (define-prim (##random-source-make-u8vectors rs)
   ((macro-random-source-make-u8vectors rs)))
 
@@ -11214,4 +11263,7 @@ ___RESULT = result;
 (define random-u8vector
   (##random-source-make-u8vectors default-random-source))
 
+(define random-f64vector
+  (##random-source-make-f64vectors default-random-source))
+
 ;;;============================================================================
