async def quantumrolls(client, message):
dice = message.content[13:]
if re.match("[0-9]+d[0-9]+", dice):
die = int(dice[0:dice.find("d")])
sides = int(dice[dice.find("d") + 1:])
if die > 20:
response = "Cannot roll more than 20 die at a time."
await message.channel.send(response.format(message))
elif sides > 100 or sides < 1:
response = "Sides cannot be greater than 100."
await message.channel.send(response.format(message))
else:
total = 0
rollstr = ""
qrolls = quantumrandom.get_data(data_type='uint16',
array_length=die)
maxrand = math.floor(65535 / sides) * sides
rolls = []
for roll in qrolls:
while roll > maxrand:
roll = quantumrandom.get_data()[0]
i = roll % sides
if i == 0:
i = sides
rolls.append(i)
total = total + i
rollstr = rollstr + ", " + str(i)
response = "You rolled a total of " + str(
total) + " {0.author.mention}: (" + rollstr[2:] + ")"
await message.channel.send(response.format(message))
return
else:
response = "Unrecognised die format. Use `{{n}}d{{s}}`. For example 2d6 or 1d3."
await message.channel.send(response.format(message))
return
def __init__(self, playerNumber, n, strat):
self.id = playerNumber
self.strat = strat
self.randArr = quantumrandom.get_data(array_length = n)
self.entropyArr = quantumrandom.get_data(array_length = n)
self.choice = -1
self.years = 0
self.minYears = 0
self.entropyInvoked = 0
self.tribalThreshold = 0.8
def main_generate_location(start_lat, start_lon, radius, num_points):
if num_points % 1024 != 0:
print("ERROR: num_points must be divisible by 1024")
return
numbers = []
for i, x in enumerate(range(int(num_points / 1024))):
x += 1
print(
f"Getting {1024*x} random unsigned 16-bit integers from QRNG...",
end=" ",
)
print(f"({1024*x}/{num_points})", end="\r")
numbers.extend(
quantumrandom.get_data(data_type="uint16",
array_length=1024,
block_size=1))
print("\nConverting integers to coordinates...")
coord_list = []
# Iterate over numbers from QRNG in pairs and convert them to coordinates
for v, w in pairwise(numbers):
v = int_to_float(v)
w = int_to_float(w)
longitude, latitude = random_location(start_lat, start_lon, radius, v,
w)
coord_list.append([longitude, latitude])
# Create DataFrame from list of coordinates
df = pd.DataFrame(coord_list, columns=["longitude", "latitude"])
x_data = df.latitude
y_data = df.longitude
print("Calculating gaussian kernel density estimate...")
kernel = stats.gaussian_kde(np.vstack([x_data, y_data]),
bw_method="silverman")
# define grid.
xmin, xmax = min(x_data), max(x_data)
ymin, ymax = min(y_data), max(y_data)
x, y = np.mgrid[xmin:xmax:100j, ymin:ymax:100j]
positions = np.vstack([x.ravel(), y.ravel()])
k_pos = kernel(positions)
max_dense_lat, max_dense_lon = positions.T[np.argmax(k_pos)]
print(f"KDE cordinates: {max_dense_lat}, {max_dense_lon}")
return max_dense_lon, max_dense_lat, radius, num_points
def generate_random_gaussians(sample_size, ndists, verbose=True):
if verbose:
print('Drawing {} random samples (n={}) from Gaussian'.format(
ndists, sample_size))
d = defaultdict(list)
for i in range(ndists):
# we even seed with a quantum random number generator!
seed = quantumrandom.get_data()
np.random.seed(seed)
x = np.random.normal(size=sample_size)
for j in range(21):
d['i'].append(i)
d['x'].append(x[j])
return pd.DataFrame(d)
def create_random_numbers(minimum, maximum, n): # type: (int, int, int) -> [int]
whole, prev = frozenset(), frozenset()
while len(whole) < n:
whole = reduce(
frozenset.union,
(
frozenset(
map(
lambda num: minimum + (num % maximum),
quantumrandom.get_data(data_type="uint16", array_length=1024),
)
),
prev,
),
)
prev = whole
print(len(whole), "of", n)
return sample(whole, n)
def qrandom(n):
"""
Creates an array of n true random numbers obtained from the quantum random
number generator at qrng.anu.edu.au
This function requires the package quantumrandom and an internet connection.
Args:
n (int):
length of the random array
Return:
array of ints:
array of truly random unsigned 16 bit int values
"""
import quantumrandom
return np.concatenate([
quantumrandom.get_data(data_type='uint16', array_length=1024)
for i in range(int(np.ceil(n/1024.0)))
])[:n]
def qrandom(n):
"""
Creates an array of n true random numbers obtained from the quantum random
number generator at qrng.anu.edu.au
This function requires the package quantumrandom and an internet connection.
Args:
n (int):
length of the random array
Return:
array of ints:
array of truly random unsigned 16 bit int values
"""
import quantumrandom
return np.concatenate([
quantumrandom.get_data(data_type='uint16', array_length=1024)
for i in range(int(np.ceil(n / 1024.0)))
])[:n]
def quantum_generator(n, d, mode=1):
tg = time()
a = []
if mode:
file = open("quantum.txt", 'a')
print(' ', file=file)
else:
with open("quantum.txt", 'r') as file:
strfile = file.read().replace("\n", " ")
a = list(map(int, strfile.split()))
file.close()
return a
while len(a) < n:
a += list(
map(lambda x: x % (d + 1),
get_data(data_type='uint16', array_length=1024)))
print(*a[-1024:], file=file, end=" ")
print(len(a) / n * 100, '%')
print('time: ', round(time() - tg, 3))
file.close()
return a
def new_game_grid(l, bomb_no=20):
game_grid = [[TileItems.BLANKS for i in range(l)] for j in range(l)]
# construct groups of numbers for tiles
_cur = 0
_index = [
TileItems.GROUP1, TileItems.GROUP2, TileItems.GROUP3, TileItems.GROUP4,
TileItems.GROUP5, TileItems.GROUP6
]
random.shuffle(_index)
_groups = [[random.randint(0, 1) for i in range(l)] for i in range(l)]
for y in range(0, l, 4):
for x in range(0, l, 6):
for _y in range(y, y + 4):
for _x in range(x, x + 6):
if _groups[_y][_x] >= 1:
game_grid[_y][_x] = _index[_cur]
_cur += 1
# ANU quantum random number generator to generate 20 bomb positions
bomb_xy = qr.get_data(data_type='uint16', array_length=bomb_no * 2)
bomb_xy = list(map(lambda x: x % l, bomb_xy))
# classical random number generator for debugging
# bomb_xy = [random.randint(0, l-1) for i in range(bomb_no * 2)]
bomb_xy = [bomb_xy[i:i + 2] for i in range(0, bomb_no * 2, 2)]
for coord in bomb_xy:
if len(coord) > 0:
game_grid[coord[0]][coord[1]] = TileItems.BOMB_UNEXPLODED
# golden Cat
game_grid[random.randint(0, l - 1)][random.randint(
0, l - 1)] = TileItems.GOLDEN_CAT
return game_grid
def test_ensure_bytestrings(self):
data = quantumrandom.get_data('hex16', 1, 1)
assert type(data[0]) is str, data
def test_uint16_json_api_invalid_type(self):
try:
data = quantumrandom.get_data('binary', 1, 1)
assert False, "Invalid type didn't throw exception: %s" % data
except:
pass
def test_uint16_json_api_large_blocksize(self):
try:
data = quantumrandom.get_data('uint16', 1, 101)
assert False, "Invalid block size didn't cause error: %s" % data
except:
pass
def test_uint16_json_api_long_array(self):
try:
data = quantumrandom.get_data('uint16', 101, 1)
assert False, "Invalid array length didn't cause error: %s" % data
except:
pass
def test_hex16_json_api(self):
data = quantumrandom.get_data('hex16', 1, 1)
assert len(data) == 1
for h in data[0]:
assert h in '0123456789abcdef', h
def test_uint16_json_api(self):
data = quantumrandom.get_data('uint16', 1, 1)
assert len(data) == 1
for i in str(data[0]):
assert i in '0123456789', i
def test_uint16_json_api_max_array(self):
data = quantumrandom.get_data('uint16', 100, 100)
assert len(data) == 100
def _update(self):
if not self.queryMade:
self.randomhexnum = str(
quantumrandom.get_data(data_type='hex16',
array_length=1,
block_size=198))
self.queryMade = True
sliceNum = self.randomhexnum[self.sliceIndex:self.sliceIndex + 6]
if "'" not in sliceNum:
self.new_label = QtWidgets.QLabel(self.gridLayoutWidget)
self.gridLayout.addWidget(self.new_label, self.grid_row,
self.grid_column, 1, 1)
if self.grid_column > 21:
self.grid_column = 0
self.grid_row += 1
else:
self.grid_column += 1
if len(sliceNum) == 6:
self.new_label.setText(
self._translate(
"Dialog",
"<html><head/><body><p><span style=\" color:#" +
sliceNum + ";\">█</span></p></body></html>"))
rgb_vector = get_rgb_vector(sliceNum)
distance = euclidian_distance(rgb_vector,
self.favoriteColorRGB)
self.average_distance(distance)
print(str(self.NumColorsGenerated) + " colors generated.")
self.label_2.setText(
str(round(self.runningAverage, 2)) + " Euclidian Average")
self.ax.cla()
self.ax.axhspan(422, 426, 0, 1, color=('b'))
self.ax.set_xlabel('Num Colors Generated')
self.ax.set_ylabel("Distance from Blue")
self.ax2.set_title('Colors generated')
#self.ax.axhspan(380,423,0,1,color=('xkcd:greeny yellow'))
#self.ax.axhspan(425,460,0,1,color=('xkcd:black'))
self.ax.plot(self.averages[-(int((len(self.averages)) - 3)):],
'r.-')
colorInt = int(sliceNum, 16)
self.colorDistances.append(distance)
self.ax2.scatter(colorInt, distance, c=("#" + sliceNum))
self.canvas.draw()
self.canvas2.draw()
print("euclidian distance of " + str(round(distance, 2)))
print("running average = " +
str(round(self.runningAverage, 2)))
print("=============================")
self.sliceIndex += 1
else:
self.timer.stop()
self.label_2.setText("calculating statistics from this run....")
self.calculate_variance()
self.calculate_p_value()
p_value = str(round(self.pValue, 3))
self.append_human_results()
global_p_value = str(round(self.global_p_value, 5))
if (self.pValue > .05):
self.label_2.setText(
self._translate(
"Dialog",
"<html><head/><body><p><span style=\" color: red;\"> p value of "
+ p_value +
". (Null hypothesis supported.)</span></p></body></html>"
))
else:
self.label_2.setText(
self._translate(
"Dialog",
"<html><head/><body><p><span style=\" color: green;\"> p value of "
+ p_value +
". (Psi hypothesis supported.)</span></p></body></html>"
))
if (self.global_p_value > .05):
self.label_3.setText(
self._translate(
"Dialog",
"<html><head/><body><p><span style=\" color: red;\"> global p value of "
+ global_p_value +
". (null evident.)</span></p></body></html>"))
else:
self.label_3.setText(
self._translate(
"Dialog",
"<html><head/><body><p><span style=\" color: green;\"> global p value of "
+ global_p_value +
". (psi evident!!)</span></p></body></html>"))
global_average = str(round(self.global_average, 2))
if (self.global_average > 424):
self.label_4.setText(
self._translate(
"Dialog",
"<html><head/><body><p><span style=\" color: red;\"> cumulative average distance of "
+ global_average +
". <br />(Farther from blue than control.) </span></p></body></html>"
))
else:
self.label_4.setText(
self._translate(
"Dialog",
"<html><head/><body><p><span style=\" color: green;\"> cumulative average distance of "
+ global_average +
". <br />(Closer to blue than control.) </span></p></body></html>"
))
self.queryMade = False
self.pushButton.setText("continue?")
self.pushButton.setEnabled(True)
def getQuantumRandomSeed(self):
return quantumrandom.get_data()
def test_uint16_json_api_long_array(self):
try:
data = quantumrandom.get_data('uint16', 101, 1)
assert False, "Invalid array length didn't cause error: %s" % data
except:
pass
def test_uint16_json_api_large_blocksize(self):
try:
data = quantumrandom.get_data('uint16', 1, 101)
assert False, "Invalid block size didn't cause error: %s" % data
except:
pass
def test_uint16_json_api_invalid_type(self):
try:
data = quantumrandom.get_data('binary', 1, 1)
assert False, "Invalid type didn't throw exception: %s" % data
except:
pass
def few_numbers():
return quantumrandom.get_data(data_type='uint16', array_length=5)
def test_uint16_json_api(self):
data = quantumrandom.get_data('uint16', 1, 1)
assert len(data) == 1
for i in str(data[0]):
assert i in '0123456789', i
def test_hex16_json_api(self):
data = quantumrandom.get_data('hex16', 1, 1)
assert len(data) == 1
for h in data[0]:
assert h in '0123456789abcdef', h
def test_uint16_json_api_max_array(self):
data = quantumrandom.get_data('uint16', 100, 100)
assert len(data) == 100
def get_values(self):
"""
Get an array of 1000 random numbers from the server
"""
self.rns = quantumrandom.get_data(data_type='uint16', array_length=1000)
def test_ensure_bytestrings(self):
data = quantumrandom.get_data('hex16', 1, 1)
assert type(data[0]) is str, data
