# Python numpy.binary_repr() 使用实例

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):
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]
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
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.
# calculate matrix indices that correspond to the transition-matrix-element
# of the oracle unitary
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:
return allowedShapes
shapeVec = np.asarray(shape, dtype=np.int32)
for b in range(2**nOnes):
bStr = np.binary_repr(b)
bStr = '0' * (nOnes - len(bStr)) + bStr
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