138 lines
5.1 KiB
Python
138 lines
5.1 KiB
Python
# -*- coding: utf-8 -*-
|
|
#
|
|
# Random/random.py : Strong alternative for the standard 'random' module
|
|
#
|
|
# Written in 2008 by Dwayne C. Litzenberger <dlitz@dlitz.net>
|
|
#
|
|
# ===================================================================
|
|
# The contents of this file are dedicated to the public domain. To
|
|
# the extent that dedication to the public domain is not available,
|
|
# everyone is granted a worldwide, perpetual, royalty-free,
|
|
# non-exclusive license to exercise all rights associated with the
|
|
# contents of this file for any purpose whatsoever.
|
|
# No rights are reserved.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
# SOFTWARE.
|
|
# ===================================================================
|
|
|
|
__all__ = ['StrongRandom', 'getrandbits', 'randrange', 'randint', 'choice', 'shuffle', 'sample']
|
|
|
|
from Cryptodome import Random
|
|
|
|
from Cryptodome.Util.py3compat import is_native_int
|
|
|
|
class StrongRandom(object):
|
|
def __init__(self, rng=None, randfunc=None):
|
|
if randfunc is None and rng is None:
|
|
self._randfunc = None
|
|
elif randfunc is not None and rng is None:
|
|
self._randfunc = randfunc
|
|
elif randfunc is None and rng is not None:
|
|
self._randfunc = rng.read
|
|
else:
|
|
raise ValueError("Cannot specify both 'rng' and 'randfunc'")
|
|
|
|
def getrandbits(self, k):
|
|
"""Return an integer with k random bits."""
|
|
|
|
if self._randfunc is None:
|
|
self._randfunc = Random.new().read
|
|
mask = (1 << k) - 1
|
|
return mask & bytes_to_long(self._randfunc(ceil_div(k, 8)))
|
|
|
|
def randrange(self, *args):
|
|
"""randrange([start,] stop[, step]):
|
|
Return a randomly-selected element from range(start, stop, step)."""
|
|
if len(args) == 3:
|
|
(start, stop, step) = args
|
|
elif len(args) == 2:
|
|
(start, stop) = args
|
|
step = 1
|
|
elif len(args) == 1:
|
|
(stop,) = args
|
|
start = 0
|
|
step = 1
|
|
else:
|
|
raise TypeError("randrange expected at most 3 arguments, got %d" % (len(args),))
|
|
if (not is_native_int(start) or not is_native_int(stop) or not
|
|
is_native_int(step)):
|
|
raise TypeError("randrange requires integer arguments")
|
|
if step == 0:
|
|
raise ValueError("randrange step argument must not be zero")
|
|
|
|
num_choices = ceil_div(stop - start, step)
|
|
if num_choices < 0:
|
|
num_choices = 0
|
|
if num_choices < 1:
|
|
raise ValueError("empty range for randrange(%r, %r, %r)" % (start, stop, step))
|
|
|
|
# Pick a random number in the range of possible numbers
|
|
r = num_choices
|
|
while r >= num_choices:
|
|
r = self.getrandbits(size(num_choices))
|
|
|
|
return start + (step * r)
|
|
|
|
def randint(self, a, b):
|
|
"""Return a random integer N such that a <= N <= b."""
|
|
if not is_native_int(a) or not is_native_int(b):
|
|
raise TypeError("randint requires integer arguments")
|
|
N = self.randrange(a, b+1)
|
|
assert a <= N <= b
|
|
return N
|
|
|
|
def choice(self, seq):
|
|
"""Return a random element from a (non-empty) sequence.
|
|
|
|
If the seqence is empty, raises IndexError.
|
|
"""
|
|
if len(seq) == 0:
|
|
raise IndexError("empty sequence")
|
|
return seq[self.randrange(len(seq))]
|
|
|
|
def shuffle(self, x):
|
|
"""Shuffle the sequence in place."""
|
|
# Fisher-Yates shuffle. O(n)
|
|
# See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
|
|
# Working backwards from the end of the array, we choose a random item
|
|
# from the remaining items until all items have been chosen.
|
|
for i in range(len(x)-1, 0, -1): # iterate from len(x)-1 downto 1
|
|
j = self.randrange(0, i+1) # choose random j such that 0 <= j <= i
|
|
x[i], x[j] = x[j], x[i] # exchange x[i] and x[j]
|
|
|
|
def sample(self, population, k):
|
|
"""Return a k-length list of unique elements chosen from the population sequence."""
|
|
|
|
num_choices = len(population)
|
|
if k > num_choices:
|
|
raise ValueError("sample larger than population")
|
|
|
|
retval = []
|
|
selected = {} # we emulate a set using a dict here
|
|
for i in range(k):
|
|
r = None
|
|
while r is None or r in selected:
|
|
r = self.randrange(num_choices)
|
|
retval.append(population[r])
|
|
selected[r] = 1
|
|
return retval
|
|
|
|
_r = StrongRandom()
|
|
getrandbits = _r.getrandbits
|
|
randrange = _r.randrange
|
|
randint = _r.randint
|
|
choice = _r.choice
|
|
shuffle = _r.shuffle
|
|
sample = _r.sample
|
|
|
|
# These are at the bottom to avoid problems with recursive imports
|
|
from Cryptodome.Util.number import ceil_div, bytes_to_long, long_to_bytes, size
|
|
|
|
# vim:set ts=4 sw=4 sts=4 expandtab:
|