;;; -*- Mode: Lisp; Package: Kernel -*-

 ;;;

 ;;; **********************************************************************

 (ext:file-comment

   "$Header: src/code/rand-xoroshiro.lisp $")

 (sys:register-lisp-feature :random-xoroshiro)

 (defun generate-seed (&optional (nwords 1))

   ;; On some systems (as reported by Ole Rohne on cmucl-imp),

   ;; /dev/urandom isn't what we think it is, so if it doesn't work,

     (flet ((splitmix64 ()

 	     ;; See http://xoroshiro.di.unimi.it/splitmix64.c for the

 	     ;; definitive reference.  The basic algorithm, where x is

 	     ;;

 	     ;;   uint64_t z = (x += 0x9e3779b97f4a7c15);

 	     ;;   z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;

 		 (aref state 1) (make-double s1))

 	   state))))

 (defun vec-init-xoro-state (key &optional (state (make-array 2 :element-type 'double-float)))

   (declare (type (array (unsigned-byte 64) (2)) key)

 	   (type (simple-array double-float (2)) state))

   (flet ((make-double (x)

 	   (let ((hi (ldb (byte 32 32) x))

 		 (lo (ldb (byte 32 0) x)))

 	     (kernel:make-double-float

     (setf (aref state 0) (make-double (aref key 0))

 	  (aref state 1) (make-double (aref key 1)))

     state))

 (defun init-random-state (&optional (seed 5772156649015328606) state)

   (declare (type (or null integer

 		     (array (unsigned-byte 64) (*)))

 		 seed))

   (make-random-object))

 (defun make-random-state (&optional state)

   (flet ((copy-random-state (state)

 	   (let ((old-state (random-state-state state))

 		 (new-state

 			       :rand 0

 			       :cached-p nil))

 	  (t

 (defun rand-initializer ()

   (init-random-state (generate-seed)

 			  (double-float 0d0))

 		%random-double-float))

 ;;;

 ;;;

 (defun %random-double-float (arg state)

   (declare (type (double-float (0d0)) arg)

       (declare (fixnum count)))))

 (defun random (arg &optional (state *random-state*))

   and Arg.  State, if supplied, is the random state to use."

   (cond

     ((typep arg '(integer 1 #x100000000))

      ;; Let the compiler deftransform take care of this case.

      (%random-single-float arg state))

     ((and (typep arg 'double-float) (> arg 0.0D0))

      (%random-double-float arg state))

     #+double-double

     ((and (typep arg 'double-double-float) (> arg 0.0w0))

      (%random-double-double-float arg state))

     (t

      (error 'simple-type-error

 	    :expected-type '(or (integer 1) (float (0.0))) :datum arg

 	    :format-arguments (list arg)))))

 ;; Jump function for the generator.  See the jump function in

 ;; http://xoroshiro.di.unimi.it/xoroshiro128plus.c

 (defun random-state-jump (&optional (rng-state *random-state*))

   xoroshiro128+ generator.  It can be used to generate 2^64

   non-overlapping subsequences for parallel computations."

   (declare (type random-state rng-state))

 #: src/code/intl.lisp src/compiler/globaldb.lisp src/code/defstruct.lisp

 #: src/code/remote.lisp src/code/wire.lisp src/code/internet.lisp

 #: src/code/loop.lisp src/code/run-program.lisp src/code/parse-time.lisp

 #: src/code/debug.lisp src/code/debug-int.lisp src/code/debug-info.lisp

 #: src/code/eval.lisp src/code/filesys.lisp src/code/pathname.lisp

 #: src/code/fd-stream.lisp src/code/extfmts.lisp src/code/serve-event.lisp

 msgid "Type \"yes\" for yes or \"no\" for no. "

 msgstr ""

 msgid ""

 "Generate an random state vector from the given SEED.  The seed can be\n"

 msgstr ""

 msgid ""

 "Make a random state object.  If STATE is not supplied, return a copy\n"

 "  of the default random state.  If STATE is a random state, then return a\n"

 "  the universal time or /dev/urandom if available."

 msgstr ""

 msgstr ""

 msgid ""

 "Generate a uniformly distributed pseudo-random number between zero\n"

 "  and Arg.  State, if supplied, is the random state to use."

 msgstr ""

 msgid "Argument is not a positive integer or a positive float: ~S"

 msgstr ""

 #: src/code/ntrace.lisp

 msgid ""

 "This is bound to the returned values when evaluating :BREAK-AFTER and\n"

 msgstr ""

 #: src/compiler/float-tran.lisp

 msgid "Can't open-code float to rational comparison."

 msgstr ""