XorShift On CommonLisp, Common Lisp

Language: Layout:

;XorShift Module
(provide :XorShifts)
(defpackage XorShifts
    (:use common-lisp)
    (:nicknames :xs)
    (:export
        :XorShift
        :XorShift-defaultSeed
        :defaults
        :seeds
        :randCount
        :rand
        :randInt
        :randFloat
        :shuffle))
(in-package XorShifts)

(defparameter defaults '(
    (:x . 123456789)
    (:y . 362436069)
    (:z . 521288629)
    (:w . 88675123)
))

(defclass XorShift()(
    (w  :initarg :w
        :initform (get-universal-time))
    (x  :initarg :x
        :initform nil)
    (y  :initarg :y
        :initform nil)
    (z  :initarg :z
        :initform nil)
    (seeds
        :initform nil)
    (randCount
        :reader randCount
        :initform 0)))

(defmethod new((me XorShift))
    (unless (slot-value me 'x) (setf (slot-value me 'x) (ash(slot-value me 'w) 13)))
    (unless (slot-value me 'y) (setf (slot-value me 'y) (logxor (ash(slot-value me 'w) -9) (ash(slot-value me 'x) 6))))
    (unless (slot-value me 'z) (setf (slot-value me 'z) (ash(slot-value me 'y) -7)))
    (setf (slot-value me 'seeds) `(
        (:x . ,(slot-value me 'x))
        (:y . ,(slot-value me 'y))
        (:z . ,(slot-value me 'z))
        (:w . ,(slot-value me 'w))
    ))
)

(defmethod seeds((me XorShift))
    (if (= (randCount me) 0) (new me))
    (slot-value me 'seeds)
)

(defmethod rand((me XorShift))
    (if (= (randCount me) 0) (new me))
    (incf (slot-value me 'randCount))
    (let (
        (x (slot-value me 'x))
        (y (slot-value me 'y))
        (z (slot-value me 'z))
        (w (slot-value me 'w))
        tt
    )
        (setf tt (logxor x (logand (ash x 11) #xFFFFFFFF)))
        (setf (slot-value me 'x) y)
        (setf (slot-value me 'y) z)
        (setf (slot-value me 'z) w)
        (setf (slot-value me 'w) (logxor (logxor w (ash w -19)) (logxor tt (ash tt -8))))))

(defmethod randInt((me XorShift) &optional (min 0) (max #x7FFFFFFF))
    (+(mod(rand me) (1+(- max min))) min))

(defmethod randFloat((me XorShift) &optional (min 0) (max 1))
    (+(*(float(/(mod(rand me) #xFFFF) #xFFFF)) (- max min)) min))

(defmethod shuffle((me XorShift) _arr)
    (let ((arr (copy-seq _arr)) r tmp)
        (dotimes (i (1- (length arr))) (progn
            (setf r (randInt me i (1- (length arr))))
            (setf tmp (elt arr i))
            (setf (elt arr i) (elt arr r))
            (setf (elt arr r) tmp)))
        arr))

(defclass XorShift-defaultSeed(XorShift)(
    (w :initform (rest(assoc :w defaults)))
    (x :initform (rest(assoc :x defaults)))
    (y :initform (rest(assoc :y defaults)))
    (z :initform (rest(assoc :z defaults)))))
;XorShift End

;(load "XorShift")
(require :XorShifts)

(let (
    (r_def (make-instance 'xs:XorShift-defaultSeed))
    (r_const (make-instance 'xs:XorShift :w 100))
    (r (make-instance 'xs:XorShift))
    a
)
    ;デフォルトのシード値を取得
    (format t ">> defaults~%")
    (format t "~a~%" xs:defaults)

;今の乱数に与えたシード値初期値
    (format t ">> seeds in r~%")
    (format t "~d~%" (xs:seeds r))

;乱数の生データを取得
    (format t ">> rand 0 to UInt32Max~%")
    (dotimes (i 5)
        (format t "~d~%" (xs:rand r_def)))

;0-100の乱数(100含む)を整数で取得
    (format t ">> randInt 0 to 100~%")
    (dotimes (i 5)
        (format t "~d~%" (xs:randInt r_const 0 100)))

;0-1の乱数を浮遊小数点で取得
    (format t ">> randFloat 0 to 1~%")
    (dotimes (i 5)
        (format t "~d~%" (xs:randFloat r)))

;listのシャッフル
    ;値渡しとなるので元の配列は破壊されない
    (format t ">> shuffle list~%")
    (setf a (loop for i from 0 below 20 collect i))
    (format t "~A~%" (xs:shuffle r a))
    (format t "~A~%" a)

;今の乱数を回した回数
    (format t ">> randCount in r~%")
    (format t "~d~%" (xs:randCount r)))

[ + ] Show input
Absolute running time: 0.14 sec, cpu time: 0.02 sec, memory peak: 6 Mb, absolute service time: 0,14 sec