The following are code examples for showing how to use . They are extracted from open source Python projects. You can vote up the examples you like or vote down the exmaples you don’t like. You can also save this page to your account.
Example 1
def set_value(self, value: int) -> None:
value = self.bounds(value)
# automatically performs 2s comp if needed
binary = np.binary_repr(value, width=8)
self.values = np.array(list(binary), dtype=np.uint8) Example 2
def calc_sent_loss(sent):
# Create a computation graph
dy.renew_cg()
W_c = dy.parameter(W_c_p)
# Get embeddings for the sentence
emb = [W_w_p[x] for x in sent]
# Step through the sentence and calculate binary prediction losses
all_losses = []
for i, my_emb in enumerate(emb):
scores = dy.logistic(W_c * my_emb)
pos_words = ([sent[x] if x >= 0 else S for x in range(i-N,i)] +
[sent[x] if x < len(sent) else S for x in range(i+1,i+N+1)])
word_repr = [[float(y) for y in np.binary_repr(x).zfill(nbits)] for x in pos_words]
word_repr = [dy.inputVector(x) for x in word_repr]
all_losses.extend([dy.binary_log_loss(scores, x) for x in word_repr])
return dy.esum(all_losses) Example 3
def _compute_grover_oracle_matrix(bitstring_map):
"""Computes the unitary matrix that encodes the oracle function for Grover's algorithm
:param bitstring_map: dict with string keys corresponding to bitstrings,
and integer values corresponding to the desired phase on the output state.
:type bitstring_map: Dict[String, Int]
:return: a numpy array corresponding to the unitary matrix for oracle for the given
bitstring_map
:rtype: numpy.ndarray
"""
n_bits = len(list(bitstring_map.keys())[0])
oracle_matrix = np.zeros(shape=(2 ** n_bits, 2 ** n_bits))
for b in range(2 ** n_bits):
pad_str = np.binary_repr(b, n_bits)
phase_factor = bitstring_map[pad_str]
oracle_matrix[b, b] = phase_factor
return oracle_matrix Example 4
def get_key_bounds(self, level, cell_iarr):
"""
Get index keys for index file supplied.
level: int
Requested level
cell_iarr: array-like, length 3
Requested cell from given level.
Returns:
lmax_lk, lmax_rk
"""
shift = self.level-level
level_buff = 0
level_lk = self.get_key(cell_iarr + level_buff)
level_rk = self.get_key(cell_iarr + level_buff) + 1
lmax_lk = (level_lk << shift*3)
lmax_rk = (((level_rk) << shift*3) -1)
#print "Level ", level, np.binary_repr(level_lk, width=self.level*3), np.binary_repr(level_rk, width=self.level*3)
#print "Level ", self.level, np.binary_repr(lmax_lk, width=self.level*3), np.binary_repr(lmax_rk, width=self.level*3)
return lmax_lk, lmax_rk Example 5
def find_all_subsets(s):
"""
find all subsets of a set, except for the empty set
:param s: a set represented by a list
:return: a list of subsets
"""
subsets = []
N = np.power(2,len(s))
for n in range(N-1): # each number represent a subset
set = [] # the subset corresponding to n
binary_ind = np.binary_repr(n+1) # binary
for idx in range(1,len(binary_ind)+1): # each bit of the binary number
if binary_ind[-idx] == '1': # '1' means to add the element corresponding to that bit
set.append(s[-idx])
subsets.append(set)
return subsets Example 6
def main():
import numpy.random as random
from trace import trace
import sys
if len(sys.argv) == 1:
sys.exit("{} [directory]".format(sys.argv[0]))
directory = sys.argv[1]
directory_ad = "{}_ad/".format(directory)
discriminator = Discriminator(directory_ad).load()
name = "generated_actions.csv"
N = discriminator.net.input_shape[1]
lowbit = 20
highbit = N - lowbit
print("batch size: {}".format(2**lowbit))
xs = (((np.arange(2**lowbit )[:,None] & (1 << np.arange(N)))) > 0).astype(int)
# xs_h = (((np.arange(2**highbit)[:,None] & (1 << np.arange(highbit)))) > 0).astype(int)
try:
print(discriminator.local(name))
with open(discriminator.local(name), 'wb') as f:
for i in range(2**highbit):
print("Iteration {}/{} base: {}".format(i,2**highbit,i*(2**lowbit)), end=' ')
# h = np.binary_repr(i*(2**lowbit), width=N)
# print(h)
# xs_h = np.unpackbits(np.array([i*(2**lowbit)],dtype=int))
xs_h = (((np.array([i])[:,None] & (1 << np.arange(highbit)))) > 0).astype(int)
xs[:,lowbit:] = xs_h
# print(xs_h)
# print(xs[:10])
ys = discriminator.discriminate(xs,batch_size=100000)
ind = np.where(ys > 0.5)
valid_xs = xs[ind]
print(len(valid_xs))
np.savetxt(f,valid_xs,"%d")
except KeyboardInterrupt:
print("dump stopped") Example 7
def test_binary_repr_0(self,level=rlevel):
# Ticket #151
assert_equal('0', np.binary_repr(0)) Example 8
def test_binary_repr_0_width(self, level=rlevel):
assert_equal(np.binary_repr(0, width=3), '000') Example 9
def test_zero(self):
assert_equal(np.binary_repr(0), '0') Example 10
def test_large(self):
assert_equal(np.binary_repr(10736848), '101000111101010011010000') Example 11
def test_negative(self):
assert_equal(np.binary_repr(-1), '-1')
assert_equal(np.binary_repr(-1, width=8), '11111111') Example 12
def binary_repr(num, width=None):
"""Return the binary representation of the input number as a string.
.. seealso:: :func:`numpy.binary_repr`
"""
return numpy.binary_repr(num, width)
# -----------------------------------------------------------------------------
# Data type routines (borrowed from NumPy)
# ----------------------------------------------------------------------------- Example 13
def create_bv_bitmap(dot_product_vector, dot_product_bias):
"""
This function creates a map from bitstring to function value for a boolean formula :math:`f`
with a dot product vector :math:`a` and a dot product bias :math:`b`
.. math::
f:\\{0,1\\}^n\\rightarrow \\{0,1\\}
\\mathbf{x}\\rightarrow \\mathbf{a}\\cdot\\mathbf{x}+b\\pmod{2}
(\\mathbf{a}\\in\\{0,1\\}^n, b\\in\\{0,1\\})
:param String dot_product_vector: a string of 0's and 1's that represents the dot-product
partner in :math:`f`
:param String dot_product_bias: 0 or 1 as a string representing the bias term in :math:`f`
:return: A dictionary containing all possible bitstring of length equal to :math:`a` and the
function value :math:`f`
:rtype: Dict[String, String]
"""
n_bits = len(dot_product_vector)
bit_map = {}
for bit_val in range(2 ** n_bits):
bit_map[np.binary_repr(bit_val, width=n_bits)] = str(
(int(utils.bitwise_dot_product(np.binary_repr(bit_val, width=n_bits),
dot_product_vector))
+ int(dot_product_bias, 2)) % 2
)
return bit_map Example 14
def _compute_unitary_oracle_matrix(bitstring_map):
"""
Computes the unitary matrix that encodes the orcale function for Simon's algorithm
:param Dict[String, String] bitstring_map: truth-table of the input bitstring map in
dictionary format
:return: a dense matrix containing the permutation of the bit strings and a dictionary
containing the indices of the non-zero elements of the computed permutation matrix as
key-value-pairs
:rtype: Tuple[2darray, Dict[String, String]]
"""
n_bits = len(list(bitstring_map.keys())[0])
# We instantiate an empty matrix of size 2 * n_bits to encode the mapping from n qubits
# to n ancillas, which explains the factor 2 overhead.
# To construct the matrix we go through all possible state transitions and pad the index
# according to all possible states the ancilla-subsystem could be in
ufunc = np.zeros(shape=(2 ** (2 * n_bits), 2 ** (2 * n_bits)))
index_mapping_dct = defaultdict(dict)
for b in range(2**n_bits):
# padding according to ancilla state
pad_str = np.binary_repr(b, n_bits)
for k, v in bitstring_map.items():
# add mapping from initial state to the state in the ancilla system.
# pad_str corresponds to the initial state of the ancilla system.
index_mapping_dct[pad_str + k] = utils.bitwise_xor(pad_str, v) + k
# calculate matrix indices that correspond to the transition-matrix-element
# of the oracle unitary
i, j = int(pad_str+k, 2), int(utils.bitwise_xor(pad_str, v) + k, 2)
ufunc[i, j] = 1
return ufunc, index_mapping_dct Example 15
def index_2_bit(state_index, num_bits):
"""Returns bit string corresponding to quantum state index
Args:
state_index : basis index of a quantum state
num_bits : the number of bits in the returned string
Returns:
A integer array with the binary representation of state_index
"""
return np.array([int(c) for c
in np.binary_repr(state_index, num_bits)[::-1]],
dtype=np.uint8) Example 16
def test_binary_repr_0(self,level=rlevel):
# Ticket #151
assert_equal('0', np.binary_repr(0)) Example 17
def test_binary_repr_0_width(self, level=rlevel):
assert_equal(np.binary_repr(0, width=3), '000') Example 18
def test_zero(self):
assert_equal(np.binary_repr(0), '0') Example 19
def test_large(self):
assert_equal(np.binary_repr(10736848), '101000111101010011010000') Example 20
def test_negative(self):
assert_equal(np.binary_repr(-1), '-1')
assert_equal(np.binary_repr(-1, width=8), '11111111') Example 21
def get_node(self, nodeid):
path = np.binary_repr(nodeid)
depth = 1
temp = self.tree.trunk
for depth in range(1, len(path)):
if path[depth] == '0':
temp = temp.left
else:
temp = temp.right
assert(temp is not None)
return temp Example 22
def get_key_slow(self, iarr, level=None):
if level is None:
level = self.level
i1, i2, i3 = iarr
rep1 = np.binary_repr(i1, width=self.level)
rep2 = np.binary_repr(i2, width=self.level)
rep3 = np.binary_repr(i3, width=self.level)
inter = np.zeros(self.level*3, dtype='c')
inter[self.dim_slices[0]] = rep1
inter[self.dim_slices[1]] = rep2
inter[self.dim_slices[2]] = rep3
return int(inter.tostring(), 2) Example 23
def get_slice_key(self, ind, dim='r'):
slb = np.binary_repr(ind, width=self.level)
expanded = np.array([0]*self.level*3, dtype='c')
expanded[self.dim_slices[dim]] = slb
return int(expanded.tostring(), 2) Example 24
def get_ind_from_key(self, key, dim='r'):
ind = [0,0,0]
br = np.binary_repr(key, width=self.level*3)
for dim in range(3):
ind[dim] = int(br[self.dim_slices[dim]],2)
return ind Example 25
def test_binary_repr_0(self,level=rlevel):
# Ticket #151
assert_equal('0', np.binary_repr(0)) Example 26
def test_binary_repr_0_width(self, level=rlevel):
assert_equal(np.binary_repr(0, width=3), '000') Example 27
def test_zero(self):
assert_equal(np.binary_repr(0), '0') Example 28
def test_large(self):
assert_equal(np.binary_repr(10736848), '101000111101010011010000') Example 29
def test_negative(self):
assert_equal(np.binary_repr(-1), '-1')
assert_equal(np.binary_repr(-1, width=8), '11111111') Example 30
def test_binary_repr_0(self,level=rlevel):
# Ticket #151
assert_equal('0', np.binary_repr(0)) Example 31
def test_binary_repr_0_width(self, level=rlevel):
assert_equal(np.binary_repr(0, width=3), '000') Example 32
def test_zero(self):
assert_equal(np.binary_repr(0), '0') Example 33
def test_large(self):
assert_equal(np.binary_repr(10736848), '101000111101010011010000') Example 34
def test_negative(self):
assert_equal(np.binary_repr(-1), '-1')
assert_equal(np.binary_repr(-1, width=8), '11111111') Example 35
def Bin(a,N):
a_bin = np.binary_repr(a)
while len(a_bin) < N:
a_bin = '0'+a_bin
return a_bin Example 36
def test_binary_repr_0(self,level=rlevel):
# Ticket #151
assert_equal('0', np.binary_repr(0)) Example 37
def test_binary_repr_0_width(self, level=rlevel):
assert_equal(np.binary_repr(0, width=3), '000') Example 38
def test_zero(self):
assert_equal(np.binary_repr(0), '0') Example 39
def test_large(self):
assert_equal(np.binary_repr(10736848), '101000111101010011010000') Example 40
def test_negative(self):
assert_equal(np.binary_repr(-1), '-1')
assert_equal(np.binary_repr(-1, width=8), '11111111') Example 41
def test_binary_repr_0(self, level=rlevel):
# Ticket #151
assert_equal('0', np.binary_repr(0)) Example 42
def test_binary_repr_0_width(self, level=rlevel):
assert_equal(np.binary_repr(0, width=3), '000') Example 43
def test_zero(self):
assert_equal(np.binary_repr(0), '0') Example 44
def test_positive(self):
assert_equal(np.binary_repr(10), '1010')
assert_equal(np.binary_repr(12522),
'11000011101010')
assert_equal(np.binary_repr(10736848),
'101000111101010011010000') Example 45
def test_negative(self):
assert_equal(np.binary_repr(-1), '-1')
assert_equal(np.binary_repr(-10), '-1010')
assert_equal(np.binary_repr(-12522),
'-11000011101010')
assert_equal(np.binary_repr(-10736848),
'-101000111101010011010000') Example 46
def test_insufficient_width_positive(self):
args = (10,)
kwargs = {'width': 2}
self.message = ("Insufficient bit width provided. This behavior "
"will raise an error in the future.")
self.assert_deprecated(np.binary_repr, args=args, kwargs=kwargs) Example 47
def test_insufficient_width_negative(self):
args = (-5,)
kwargs = {'width': 2}
self.message = ("Insufficient bit width provided. This behavior "
"will raise an error in the future.")
self.assert_deprecated(np.binary_repr, args=args, kwargs=kwargs) Example 48
def _getAllowedShapes(self, shape):
''' Return set of allowed shapes that can be squeezed into given shape.
Examples
--------
>>> PB = ParamBag() # fixing K,D doesn't matter
>>> PB._getAllowedShapes(())
set([()])
>>> PB._getAllowedShapes((1,))
set([(), (1,)])
>>> aSet = PB._getAllowedShapes((23,))
>>> sorted(aSet)
[(23,)]
>>> sorted(PB._getAllowedShapes((3,1)))
[(3,), (3, 1)]
>>> sorted(PB._getAllowedShapes((1,1)))
[(), (1,), (1, 1)]
'''
assert isinstance(shape, tuple)
allowedShapes = set()
if len(shape) == 0:
allowedShapes.add(tuple())
return allowedShapes
shapeVec = np.asarray(shape, dtype=np.int32)
onesMask = shapeVec == 1
keepMask = np.logical_not(onesMask)
nOnes = sum(onesMask)
for b in range(2**nOnes):
bStr = np.binary_repr(b)
bStr = '0' * (nOnes - len(bStr)) + bStr
keepMask[onesMask] = np.asarray([int(x) > 0 for x in bStr])
curShape = shapeVec[keepMask]
allowedShapes.add(tuple(curShape))
return allowedShapes Example 49
def _get_contrast_indices(effect_idx, n_factors):
"""Henson's factor coding, see num2binvec"""
binrepr = np.binary_repr(effect_idx, n_factors)
return np.array([int(i) for i in binrepr], dtype=int) Example 50
def activate_network(self, num_activations=1):
"""Activates the Markov Network
Parameters
----------
num_activations: int (default: 1)
The number of times the Markov Network should be activated
Returns
-------
None
"""
original_input_values = np.copy(self.states[:self.num_input_states])
for _ in range(num_activations):
for markov_gate, mg_input_ids, mg_output_ids in zip(self.markov_gates, self.markov_gate_input_ids, self.markov_gate_output_ids):
# Determine the input values for this Markov Gate
mg_input_values = self.states[mg_input_ids]
mg_input_index = int(''.join([str(int(val)) for val in mg_input_values]), base=2)
# Determine the corresponding output values for this Markov Gate
roll = np.random.uniform()
mg_output_index = np.where(markov_gate[mg_input_index, :] >= roll)[0][0]
mg_output_values = np.array(list(np.binary_repr(mg_output_index, width=len(mg_output_ids))), dtype=np.uint8)
self.states[mg_output_ids] = np.bitwise_or(self.states[mg_output_ids], mg_output_values)
self.states[:self.num_input_states] = original_input_values 