我们从Python开源项目中，提取了以下20个代码示例，用于说明如何使用numpy.left_shift()。
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)
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
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
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
def __lshift__(self, other): return left_shift(self, other)
def __ilshift__(self, other): return left_shift(self, other, self)
def __rlshift__(self, other): return left_shift(other, self)
def create_binary_wf_data(wf, sync_mkr=0, samp_mkr=0, vertical_resolution=12): """Given numpy arrays of waveform and marker data convert to binary format. Assumes waveform data is np.float in range -1 to 1 and marker data can be cast to bool Binary format is waveform in MSB and and markers in LSB waveform sync_mkr samp_mkr 15 downto 4/2 1 0 """ #cast the waveform to integers if not((vertical_resolution == 12) or (vertical_resolution == 14)): raise ValueError("vertical resolution must be 12 or 14 bits") #convert waveform to integers scale_factor = 2**(vertical_resolution-1) bin_data = np.int16((scale_factor-1)*np.array(wf)) #clip if necessary if np.max(bin_data) > scale_factor-1 or np.min(bin_data) < -scale_factor: warnings.warn("Clipping waveform. Max value: {:d} Min value: {:d}. Scale factor: {:d}.".format(np.max(bin_data), np.min(bin_data),scale_factor)) bin_data = np.clip(bin_data, -scale_factor, scale_factor-1) # bin_data = bin_data.byteswap() #shift up to the MSB bin_data = np.left_shift(bin_data, 4 if vertical_resolution == 12 else 2) #add in the marker bits bin_data = np.bitwise_or(bin_data, np.bitwise_or(np.left_shift(np.bitwise_and(sync_mkr, 0x1), 1), np.bitwise_and(samp_mkr, 0x1))) return bin_data
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) )
def numpy_uint8_to_int16(depth8): x, y, c = depth8.shape out = np.ndarray((x, y), dtype=np.int16) out[:, :] = depth8[:, :, 0] out = np.left_shift(out, 8) out[:, :] += depth8[:, :, 1] return out
def DilatedConvBlock(name, input_dim, output_dim, filter_size, inputs): result = inputs for i in xrange(DILATION_LEVEL): d = numpy.left_shift(2, i) result = DilatedConv1D(name+'Dilation'+str(d), DIM, DIM, 5, result, d, mask_type='b') result = relu(result) return result
def _read_3(fid): """ Read 3 byte integer from file """ data = np.fromfile(fid, dtype=np.uint8, count=3).astype(np.int32) out = np.left_shift(data[0], 16) + np.left_shift(data[1], 8) + data[2] return out
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
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
