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 test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 2
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 3
def dec10216(data):
"""Unpacking the 10 bit data to 16 bit"""
arr10 = data.astype(np.uint16).flat
new_shape = list(data.shape[:-1]) + [(data.shape[-1] * 8) / 10]
new_shape = [int(s) for s in new_shape]
arr16 = np.zeros(new_shape, dtype=np.uint16)
arr16.flat[::4] = np.left_shift(arr10[::5], 2) + \
np.right_shift((arr10[1::5]), 6)
arr16.flat[1::4] = np.left_shift((arr10[1::5] & 63), 4) + \
np.right_shift((arr10[2::5]), 4)
arr16.flat[2::4] = np.left_shift(arr10[2::5] & 15, 6) + \
np.right_shift((arr10[3::5]), 2)
arr16.flat[3::4] = np.left_shift(arr10[3::5] & 3, 8) + \
arr10[4::5]
return arr16 Example 4
def dec10216(inbuf):
arr10 = inbuf.astype(np.uint16)
arr16 = np.zeros((int(len(arr10) * 4 / 5),), dtype=np.uint16)
arr10_len = int((len(arr16) * 5) / 4)
arr10 = arr10[:arr10_len] # adjust size
"""
/*
* pack 4 10-bit words in 5 bytes into 4 16-bit words
*
* 0 1 2 3 4 5
* 01234567890123456789012345678901234567890
* 0 1 2 3 4
*/
ip = &in_buffer[i];
op = &out_buffer[j];
op[0] = ip[0]*4 + ip[1]/64;
op[1] = (ip[1] & 0x3F)*16 + ip[2]/16;
op[2] = (ip[2] & 0x0F)*64 + ip[3]/4;
op[3] = (ip[3] & 0x03)*256 +ip[4];
"""
arr16.flat[::4] = np.left_shift(arr10[::5], 2) + \
np.right_shift((arr10[1::5]), 6)
arr16.flat[1::4] = np.left_shift((arr10[1::5] & 63), 4) + \
np.right_shift((arr10[2::5]), 4)
arr16.flat[2::4] = np.left_shift(arr10[2::5] & 15, 6) + \
np.right_shift((arr10[3::5]), 2)
arr16.flat[3::4] = np.left_shift(arr10[3::5] & 3, 8) + \
arr10[4::5]
return arr16 Example 5
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 6
def flatten_and_pack(img, bits):
"""
Packs reduced bit depth images into bytes and returns a flattened array
Args:
img (uint8 numpy array): grayscale or multi-channel image
bits (int): 1, 2, 4, or 8 bits per channel
Returns:
uint8 numpy array: flattened and packed array
"""
# pad the image at the end of the rows, so that each row ends on a byte boundary
pixels_per_byte = 8 // bits
if len(img.shape) > 1:
if img.shape[1] % pixels_per_byte != 0:
img = np.hstack((img, np.zeros((img.shape[0], pixels_per_byte - img.shape[1] % pixels_per_byte), dtype=np.uint8)))
a = np.right_shift(img, 8-bits) # reduce bit depth
b = a.flatten() # flatten
c = np.zeros(b.size // pixels_per_byte, dtype=np.uint8)
for i in range(0, pixels_per_byte):
c += np.left_shift(b[i::pixels_per_byte], (pixels_per_byte-1-i)*bits) # pack pixels and add to result
return c Example 7
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 8
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 9
def _rgb_integers_to_components(self, rgb_integers):
red_mask = 0x00FF0000
green_mask = 0x0000FF00
blue_mask = 0x000000FF
masks = np.asarray([[red_mask, green_mask, blue_mask]])
masked_rgb_components = np.bitwise_and(rgb_integers, masks)
red_shifted = np.right_shift(masked_rgb_components[:,0], 16)
green_shifted = np.right_shift(masked_rgb_components[:,1], 8)
blue_shifted = np.right_shift(masked_rgb_components[:,2], 0)
return np.array([red_shifted, green_shifted, blue_shifted]).transpose() Example 10
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 11
def __rshift__(self, other):
return right_shift(self, other) Example 12
def __irshift__(self, other):
return right_shift(self, other, self) Example 13
def __rrshift__(self, other):
return right_shift(other, self) Example 14
def test_NotImplemented_not_returned(self):
# See gh-5964 and gh-2091. Some of these functions are not operator
# related and were fixed for other reasons in the past.
binary_funcs = [
np.power, np.add, np.subtract, np.multiply, np.divide,
np.true_divide, np.floor_divide, np.bitwise_and, np.bitwise_or,
np.bitwise_xor, np.left_shift, np.right_shift, np.fmax,
np.fmin, np.fmod, np.hypot, np.logaddexp, np.logaddexp2,
np.logical_and, np.logical_or, np.logical_xor, np.maximum,
np.minimum, np.mod
]
# These functions still return NotImplemented. Will be fixed in
# future.
# bad = [np.greater, np.greater_equal, np.less, np.less_equal, np.not_equal]
a = np.array('1')
b = 1
for f in binary_funcs:
assert_raises(TypeError, f, a, b) Example 15
def doDecompression( packedDataList, shape, n_threads ):
blosc.set_nthreads( n_threads )
dataList = [None] * len(packedDataList)
for J in np.arange(len(packedDataList) ):
# dataStack[J,:,:] = np.reshape(
# np.frombuffer( blosc.decompress( packedDataList[J] ), dtype='uint8' ),
# shape[1:] )
# Something here Numpy-side is very slow, so let's not include that in our
# benchmark.
dataList[J] = blosc.decompress( packedDataList[J] )
return dataList
#t_half0 = time.time()
#halfimage = dm4image_8bit[:,:,::2] + np.left_shift(dm4image_8bit[:,:,1::2],4)
#t_half1 = time.time()
#restoreimage = np.empty( header['dimensions'], dtype='uint8' )
##image[0::2] = np.left_shift(interlaced_image,4)/16
##image[1::2] = np.right_shift(interlaced_image,4)
## Different interlace option
## TODO: AND array with 15 instead?
#restoreimage[:,:,::2] = (np.left_shift( halfimage, 4 ) & 15 )
#restoreimage[:,:,1::2] = np.right_shift( halfimage, 4 )
#t_half2 = time.time()
#
#print( "4-byte encoding time (s): %f" % (t_half1 - t_half0) )
#print( "4-byte DEcoding time (s): %f" % (t_half2 - t_half1) ) Example 16
def numpy_int16_to_uint8(depth):
x, y = depth.shape
out = np.ndarray((x, y, 2), dtype=np.uint8)
out[:, :, 0] = np.right_shift(depth, 8)
out[:, :, 1] = depth.astype(np.uint8)
return out Example 17
def binary_permutations(n_bits):
"""
Given some number of bits, return a shape (2**n_bits, n_bits) boolean array containing every permoutation
of those bits as a row.
:param n_bits: An integer number of bits
:return: A shape (2**n_bits, n_bits) boolean array containing every permoutation
of those bits as a row.
"""
return np.right_shift(np.arange(2**n_bits)[:, None], np.arange(n_bits-1, -1, -1)[None, :]) & 1 Example 18
def _mix(a, b, f):
#Used for the blend function (mixes colors according to their alpha values)
c = numpy.multiply(numpy.subtract(b,a),f)
return numpy.add(numpy.right_shift(c,8),a) Example 19
def complex_data(self):
'''
This will cast each byte to an int8 and interpret each byte
as 4 bits real values and 4 bits imag values (RRRRIIII). The data are then
used to create a 3D numpy array of dtype=complex, which is returned.
The shape of the numpy array is N half frames, M subbands, K data points per half frame,
where K = constants.bins_per_half_frame, N is typically 129 and M is typically 1 for
compamp files and 16 for archive-compamp files.
Note that this returns a Numpy array of type complex64. This data is not retained within Compamp objects.
'''
#note that since we can only pack into int8 types, we must pad each 4-bit value with 4, 0 bits
#this effectively multiplies each 4-bit value by 16 when that value is represented as an 8-bit signed integer.
packed_data = self._packed_data()
header = self.header()
real_val = np.bitwise_and(packed_data, 0xf0).astype(np.int8) # coef's are: RRRRIIII (4 bits real,
imag_val = np.left_shift(np.bitwise_and(packed_data, 0x0f), 4).astype(np.int8) # 4 bits imaginary in 2's complement)
cdata = np.empty(len(real_val), np.complex64)
#"Normalize" by making appropriate bit-shift. Otherwise, values for real and imaginary coefficients are
#inflated by 16x.
cdata.real = np.right_shift(real_val, 4)
cdata.imag = np.right_shift(imag_val, 4)
# expose compamp measurement blocks
cdata = cdata.reshape((header['number_of_half_frames'], header['number_of_subbands'], constants.bins_per_half_frame))
return cdata Example 20
def _get_voc_color_map(n=256):
color_map = np.zeros((n, 3))
for i in xrange(n):
r = b = g = 0
cid = i
for j in xrange(0, 8):
r = np.bitwise_or(r, np.left_shift(np.unpackbits(np.array([cid], dtype=np.uint8))[-1], 7-j))
g = np.bitwise_or(g, np.left_shift(np.unpackbits(np.array([cid], dtype=np.uint8))[-2], 7-j))
b = np.bitwise_or(b, np.left_shift(np.unpackbits(np.array([cid], dtype=np.uint8))[-3], 7-j))
cid = np.right_shift(cid, 3)
color_map[i][0] = r
color_map[i][1] = g
color_map[i][2] = b
return color_map 