powerdlz23 1.2.2 → 1.2.3

package/pto/crypto/mt19937/go/README.rst

@@ -0,0 +1,103 @@
+The Mersenne Twister in Go
+==========================
+
+An implementation of Takuji Nishimura's and Makoto Matsumoto's
+`Mersenne Twister`_ pseudo random number generator in Go.
+
+Copyright (C) 2013  Jochen Voss
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The homepage of this package is at <http://www.seehuhn.de/pages/mt19937>.
+Please send any comments or bug reports to the program's author,
+Jochen Voss <voss@seehuhn.de>.
+
+.. _Mersenne Twister: http://en.wikipedia.org/wiki/Mersenne_twister
+
+Overview
+--------
+
+The Mersenne Twister is a pseudo random number generator (PRNG),
+developed by Takuji Nishimura and Makoto Matsumoto.  The Mersenne
+Twister is, for example, commonly used in Monte Carlo simulations and
+is the default random number generator for many programming languages,
+e.g. Python_ and R_.  This package implements the `64bit version`_ of the
+algorithm.
+
+.. _Python: http://www.python.org/
+.. _R: http://www.r-project.org/
+.. _64bit version: http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt64.html
+
+
+Installation
+------------
+
+This package can be installed using the ``go get`` command::
+
+    go get github.com/seehuhn/mt19937
+
+
+Usage
+-----
+
+Detailed usage instructions are available via the package's online
+help, either on godoc.org_ or on the command line::
+
+    go doc github.com/seehuhn/mt19937
+
+.. _godoc.org: http://godoc.org/github.com/seehuhn/mt19937
+
+The class ``MT19937`` represents instances of the Mersenne Twister.
+New instances can be allocated using the ``mt19937.New()`` function.
+A seed can be set using the .Seed() or .SeedFromSlice() methods.
+``MT19937`` implements the ``rand.Source`` interface from the
+``math/rand`` package.  Typically the PRNG is wrapped in a rand.Rand
+object as in the following example::
+
+    rng := rand.New(mt19937.New())
+    rng.Seed(time.Now().UnixNano())
+
+Comparison to the Go Default PRNG
+---------------------------------
+
+Go has a built-in PRNG provided by the math/rand package.  I did not
+find any information about this built-in PRNG except for a comment in
+the source code which says "algorithm by DP Mitchell and JA Reeds".
+In contrast, the MT19737 generator provided in this package is a
+well-understood random number generator.  Relevant references include
+[Ni2000]_ and [MatNi1998]_.
+
+.. [Ni2000] T. Nishimura, *Tables of 64-bit Mersenne Twisters*, ACM
+     Transactions on Modeling and Computer Simulation 10, 2000, pages
+     348-357.
+.. [MatNi1998] M. Matsumoto and T. Nishimura, *Mersenne Twister: a
+     623-dimensionally equidistributed uniform pseudorandom number
+     generator*, ACM Transactions on Modeling and Computer Simulation
+     8, 1998, pages 3--30.
+
+The unit tests for the mt19937 package verify that the output of the
+Go implementation coincides with the output of the references
+implementation.
+
+The mt19937 generator is slightly slower than the Go default PRNG.
+A speed comparison can be performed using the following command::
+
+    go test -bench=. github.com/seehuhn/mt19937
+
+On my (64bit) system I get the following results:
+
+    +----------------+---------------+----------------+
+    | method         | time per call |      thoughput |
+    +================+===============+================+
+    | MT19937.Uint64 |  14.9 ns/op   |    537.48 MB/s |
+    +----------------+---------------+----------------+
+    | MT19937.Int63  |  15.0 ns/op   |    533.54 MB/s |
+    +----------------+---------------+----------------+
+    | builtin Int63  |  11.9 ns/op   |    674.07 MB/s |
+    +----------------+---------------+----------------+
+
+This shows that, on my system, a call to the ``Int63()`` method of the
+built-in PRNG takes about 80% of the time that MT19937.Int63() takes.

package/pto/crypto/mt19937/go/doc.go

@@ -0,0 +1,35 @@
+// doc.go - package documentation for github.com/seehuhn/mt19937
+// Copyright (C) 2013  Jochen Voss <voss@seehuhn.de>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+// Package mt19937 is a pure-go implementation of the 64bit Mersenne
+// Twister pseudo random number generator (PRNG).  The Mersenne
+// Twister, developed by Takuji Nishimura and Makoto Matsumoto, is,
+// for example, commonly used in Monte Carlo simulations.  The
+// implementation in the mt19937 package closely follows the reference
+// implementation from
+//
+//     http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt64.html
+//
+// and, for identical seeds, gives identical output to the reference
+// implementation.
+//
+// The PRNG from the mt19937 package implements the rand.Source
+// interface from the math/rand package.  Typically the PRNG is
+// wrapped in a rand.Rand object as in the following example:
+//
+//     rng := rand.New(mt19937.New())
+//     rng.Seed(time.Now().UnixNano())
+package mt19937

package/pto/crypto/mt19937/go/example.go

@@ -0,0 +1,32 @@
+// example.go - a test program for the mt19937 package
+// Copyright (C) 2013  Jochen Voss <voss@seehuhn.de>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+// +build ignore
+
+package main
+
+import (
+	"fmt"
+	"github.com/funny/mt19937/go"
+	"math/rand"
+	"time"
+)
+
+func main() {
+	rng := rand.New(mt19937.New())
+	rng.Seed(time.Now().UnixNano())
+	fmt.Println(rng.NormFloat64())
+}

package/pto/crypto/mt19937/go/mt19937.go

@@ -0,0 +1,149 @@
+// mt19937.go - an implementation of the 64bit Mersenne Twister PRNG
+// Copyright (C) 2013  Jochen Voss <voss@seehuhn.de>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+package mt19937
+
+const (
+	n         = 312
+	m         = 156
+	notSeeded = n + 1
+
+	hiMask uint64 = 0xffffffff80000000
+	loMask uint64 = 0x000000007fffffff
+
+	matrixA uint64 = 0xB5026F5AA96619E9
+)
+
+// MT19937 is the structure to hold the state of one instance of the
+// Mersenne Twister PRNG.  New instances can be allocated using the
+// mt19937.New() function.  MT19937 implements the rand.Source
+// interface and rand.New() from the math/rand package can be used to
+// generate different distributions from a MT19937 PRNG.
+//
+// This class is not safe for concurrent accesss by different
+// goroutines.  If more than one goroutine accesses the PRNG, the
+// callers must synchronise access using sync.Mutex or similar.
+type MT19937 struct {
+	state []uint64
+	index int
+}
+
+// New allocates a new instance of the 64bit Mersenne Twister.
+// A seed can be set using the .Seed() or .SeedFromSlice() methods.
+func New() *MT19937 {
+	res := &MT19937{
+		state: make([]uint64, n),
+		index: notSeeded,
+	}
+	return res
+}
+
+// Seed uses the given 64bit value to initialise the generator state.
+// This method is part of the rand.Source interface.
+func (mt *MT19937) Seed(seed int64) {
+	x := mt.state
+	x[0] = uint64(seed)
+	for i := uint64(1); i < n; i++ {
+		x[i] = 6364136223846793005*(x[i-1]^(x[i-1]>>62)) + i
+	}
+	mt.index = n
+}
+
+// SeedFromSlice uses the given slice of 64bit values to set the
+// generator state.
+func (mt *MT19937) SeedFromSlice(key []uint64) {
+	mt.Seed(19650218)
+
+	x := mt.state
+	i := uint64(1)
+	j := 0
+	k := len(key)
+	if n > k {
+		k = n
+	}
+	for k > 0 {
+		x[i] = (x[i] ^ ((x[i-1] ^ (x[i-1] >> 62)) * 3935559000370003845) + key[j] + uint64(j))
+		i++
+		if i >= n {
+			x[0] = x[n-1]
+			i = 1
+		}
+		j++
+		if j >= len(key) {
+			j = 0
+		}
+		k--
+	}
+	for j := uint64(0); j < n-1; j++ {
+		x[i] = x[i] ^ ((x[i-1] ^ (x[i-1] >> 62)) * 2862933555777941757) - i
+		i++
+		if i >= n {
+			x[0] = x[n-1]
+			i = 1
+		}
+	}
+	x[0] = 1 << 63
+}
+
+// Uint64 generates a (pseudo-)random 64bit value.  The output can be
+// used as a replacement for a sequence of independent, uniformly
+// distributed samples in the range 0, 1, ..., 2^64-1.
+func (mt *MT19937) Uint64() uint64 {
+	x := mt.state
+	if mt.index >= n {
+		if mt.index == notSeeded {
+			mt.Seed(5489) // default seed, as in mt19937-64.c
+		}
+		for i := 0; i < n-m; i++ {
+			y := (x[i] & hiMask) | (x[i+1] & loMask)
+			x[i] = x[i+m] ^ (y >> 1) ^ ((y & 1) * matrixA)
+		}
+		for i := n - m; i < n-1; i++ {
+			y := (x[i] & hiMask) | (x[i+1] & loMask)
+			x[i] = x[i+(m-n)] ^ (y >> 1) ^ ((y & 1) * matrixA)
+		}
+		y := (x[n-1] & hiMask) | (x[0] & loMask)
+		x[n-1] = x[m-1] ^ (y >> 1) ^ ((y & 1) * matrixA)
+		mt.index = 0
+	}
+	y := x[mt.index]
+	y ^= (y >> 29) & 0x5555555555555555
+	y ^= (y << 17) & 0x71D67FFFEDA60000
+	y ^= (y << 37) & 0xFFF7EEE000000000
+	y ^= (y >> 43)
+	mt.index++
+	return y
+}
+
+// Int63 generates a (pseudo-)random 63bit value.  The output can be
+// used as a replacement for a sequence of independent, uniformly
+// distributed samples in the range 0, 1, ..., 2^63-1.  This method is
+// part of the rand.Source interface.
+func (mt *MT19937) Int63() int64 {
+	return int64(mt.Uint64() >> 1)
+}
+
+func (mt *MT19937) Real1() float64 {
+	return float64(mt.Uint64()>>11) * (1.0 / 9007199254740991.0)
+}
+
+func (mt *MT19937) Real2() float64 {
+	return float64(mt.Uint64()>>11) * (1.0 / 9007199254740992.0)
+}
+
+func (mt *MT19937) Real3() float64 {
+	return (float64(mt.Uint64()>>12) + 0.5) * (1.0 / 4503599627370496.0)
+}