我们从Python开源项目中,提取了以下50个代码示例,用于说明如何使用numpy.logical_xor()。
def calculate_plane_histogram(plane, doseplane, dosegridpoints, maxdose, dd, id, structure, hist): """Calculate the DVH for the given plane in the structure.""" contours = [[x[0:2] for x in c['data']] for c in plane] # If there is no dose for the current plane, go to the next plane if not len(doseplane): return (np.arange(0, maxdose), 0) # Create a zero valued bool grid grid = np.zeros((dd['rows'], dd['columns']), dtype=np.uint8) # Calculate the histogram for each contour in the plane # and boolean xor to remove holes for i, contour in enumerate(contours): m = get_contour_mask(dd, id, dosegridpoints, contour) grid = np.logical_xor(m.astype(np.uint8), grid).astype(np.bool) hist, vol = calculate_contour_dvh( grid, doseplane, maxdose, dd, id, structure) return (hist, vol)
def _gene_signature(self,wm,size,key): '''????????????????????????''' wm = cv2.resize(wm,(size,size)) wU,_,wV = np.linalg.svd(np.mat(wm)) sumU = np.sum(np.array(wU),axis=0) sumV = np.sum(np.array(wV),axis=0) sumU_mid = np.median(sumU) sumV_mid = np.median(sumV) sumU=np.array([1 if sumU[i] >sumU_mid else 0 for i in range(len(sumU)) ]) sumV=np.array([1 if sumV[i] >sumV_mid else 0 for i in range(len(sumV)) ]) uv_xor=np.logical_xor(sumU,sumV) np.random.seed(key) seq=np.random.randint(2,size=len(uv_xor)) signature = np.logical_xor(uv_xor, seq) sqrts = int(np.sqrt(size)) return np.array(signature,dtype=np.int8).reshape((sqrts,sqrts))
def _gene_signature(self,wm,key): '''????????????????????????''' wm = cv2.resize(wm,(256,256)) wU,_,wV = np.linalg.svd(np.mat(wm)) sumU = np.sum(np.array(wU),axis=0) sumV = np.sum(np.array(wV),axis=0) sumU_mid = np.median(sumU) sumV_mid = np.median(sumV) sumU=np.array([1 if sumU[i] >sumU_mid else 0 for i in range(len(sumU)) ]) sumV=np.array([1 if sumV[i] >sumV_mid else 0 for i in range(len(sumV)) ]) uv_xor=np.logical_xor(sumU,sumV) np.random.seed(key) seq=np.random.randint(2,size=len(uv_xor)) signature = np.logical_xor(uv_xor, seq) return np.array(signature,dtype=np.int8)
def _gene_signature(self,wU,wV,key): '''????????????????????????''' sumU = np.sum(wU,axis=0) sumV = np.sum(wV,axis=0) sumU_mid = np.median(sumU) sumV_mid = np.median(sumV) sumU=np.array([1 if sumU[i] >sumU_mid else 0 for i in range(len(sumU)) ]) sumV=np.array([1 if sumV[i] >sumV_mid else 0 for i in range(len(sumV)) ]) uv_xor=np.logical_xor(sumU,sumV) np.random.seed(key) seq=np.random.randint(2,size=len(uv_xor)) signature = np.logical_xor(uv_xor, seq) return np.array(signature,dtype=np.int8)
def test_truth_table_logical(self): # 2, 3 and 4 serves as true values input1 = [0, 0, 3, 2] input2 = [0, 4, 0, 2] typecodes = (np.typecodes['AllFloat'] + np.typecodes['AllInteger'] + '?') # boolean for dtype in map(np.dtype, typecodes): arg1 = np.asarray(input1, dtype=dtype) arg2 = np.asarray(input2, dtype=dtype) # OR out = [False, True, True, True] for func in (np.logical_or, np.maximum): assert_equal(func(arg1, arg2).astype(bool), out) # AND out = [False, False, False, True] for func in (np.logical_and, np.minimum): assert_equal(func(arg1, arg2).astype(bool), out) # XOR out = [False, True, True, False] for func in (np.logical_xor, np.not_equal): assert_equal(func(arg1, arg2).astype(bool), out)
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 calculate_plane_histogram(plane, doseplane, dosegridpoints, maxdose, dd, id, structure, hist): """Calculate the DVH for the given plane in the structure.""" contours = [[x[0:2] for x in c['data']] for c in plane] # Create a zero valued bool grid grid = np.zeros((dd['rows'], dd['columns']), dtype=np.uint8) # Calculate the dose plane mask for each contour in the plane # and boolean xor to remove holes for i, contour in enumerate(contours): m = get_contour_mask(dd, id, dosegridpoints, contour) grid = np.logical_xor(m.astype(np.uint8), grid).astype(np.bool) hist, vol = calculate_contour_dvh(grid, doseplane, maxdose, dd, id, structure) return (hist, vol)
def data_cleaning(file_path): data = pd.read_csv(file_path, index_col=False) data.drop(['Street', 'Utilities', 'Condition2', 'RoofMatl', 'Alley', 'GarageYrBlt', 'GarageCond', 'PoolQC', 'MiscFeature'], axis=1, inplace=True) # marked as NA in BsmtExposure and not NA in other Bsmt Attributes data.loc[np.logical_xor(data['BsmtCond'].isnull(), data['BsmtExposure'].isnull()), 'BsmtExposure'] = 'No' # LotFrontage's N/A is assigned zero, will it cause problem? data.fillna(value={'MasVnrType': 'None', 'MasVnrArea': 0, 'BsmtQual': 'NoBsmt', 'BsmtCond': 'NoBsmt', 'BsmtExposure': 'NoBsmt', 'BsmtFinType1': 'NoBsmt', 'BsmtFinType2': 'NoBsmt', 'Electrical': 'SBrkr', 'FireplaceQu': 'NoFP', 'GarageType': 'Noga', 'GarageFinish': 'Noga', 'GarageQual': 'Noga', 'Fence': 'NoFence', 'LotFrontage': 0}, inplace=True) data.loc[:, 'YrSold'] = 2016 - data.loc[:, 'YrSold'] data.loc[data.loc[:, 'PoolArea'] != 0, 'PoolArea'] = 1 data.loc[:, 'Porch'] = np.sum(data.loc[:, ['EnclosedPorch', '3SsnPorch', 'ScreenPorch']], axis=1) data.drop(['EnclosedPorch', '3SsnPorch', 'ScreenPorch'], axis=1, inplace=True) data.replace({'BsmtFullBath': {3: 2}, 'LotShape': {'IR3': 'IR2'}}, inplace=True) data.columns # examine columns containing NA value print(data) print(data.columns[np.sum(data.isnull(), axis=0) != 0])
def m_menu(self): """Runs the Mathmatically defined sculpture menu item.""" sin, cos = np.sin, np.cos res = raw_input("Enter a functional definition of a volume (x**2+y**2+z**2 < 1) \n") self.user_text = res self.volume_data = self.bool_ops() self.create_iso_surface(.7) while True: res = raw_input("Enter another functional definition of a volume (x**2+y**2+z**2 < 1) \n") self.user_text = res self.sec_volume_data = self.bool_ops() self.create_iso_surface(.7, second=True) res = raw_input("Enter a boolean operation to do with the previous solid (a = and, o = or, n = not, x = xor):\n") if res == "a": self.sec_volume_data = 0+ np.logical_and(my_sculpture.volume_data, my_sculpture.bool_ops()) elif res == "o": self.sec_volume_data = 0+ np.logical_or(my_sculpture.volume_data, my_sculpture.bool_ops()) elif res == "n": self.sec_volume_data = 0+ np.logical_not(my_sculpture.volume_data, my_sculpture.bool_ops()) elif res == "x": self.sec_volume_data = 0+ np.logical_xor(my_sculpture.volume_data, my_sculpture.bool_ops()) self.create_iso_surface(.7, second=True)
def selectShell(ref_coords, coords, R, sw): """ Return indices of the particles within the spherical shell of inner radius (R-sw) and outer radius R, ie the shell. Parameters ---------- ref_coords : array_like (n_atoms, n_dim) Reference atoms positions coords : array_like (n_atoms, n_dim) atoms positions R : float distance to any atoms Returns ------- array particle indices within shell """ if R < sw: raise RuntimeError("selection radius smaller then shell width") body_query = get_selection(coords, ref_coords, R=R) core_query = get_selection(coords, ref_coords, R=R - sw) query = np.logical_xor(body_query, core_query) return np.where(query)
def encodeMask(M): """ Encode binary mask M using run-length encoding. :param M (bool 2D array) : binary mask to encode :return: R (object RLE) : run-length encoding of binary mask """ [h, w] = M.shape M = M.flatten(order='F') N = len(M) counts_list = [] pos = 0 # counts counts_list.append(1) diffs = np.logical_xor(M[0:N-1], M[1:N]) for diff in diffs: if diff: pos +=1 counts_list.append(1) else: counts_list[pos] += 1 # if array starts from 1. start with 0 counts for 0 if M[0] == 1: counts_list = [0] + counts_list return {'size': [h, w], 'counts': counts_list , }
def _gene_signature(wm,size,key): ''' ???????????????????????? wm : ???? size ?????????? key ???????? ''' wm = cv2.resize(wm,(size,size)) wU,_,wV = np.linalg.svd(np.mat(wm)) sumU = np.sum(np.array(wU),axis=0) sumV = np.sum(np.array(wV),axis=0) sumU_mid = np.median(sumU) sumV_mid = np.median(sumV) sumU=np.array([1 if sumU[i] >sumU_mid else 0 for i in range(len(sumU)) ]) sumV=np.array([1 if sumV[i] >sumV_mid else 0 for i in range(len(sumV)) ]) uv_xor=np.logical_xor(sumU,sumV) np.random.seed(key) seq=np.random.randint(2,size=len(uv_xor)) signature = np.logical_xor(uv_xor, seq) sqrts = int(np.sqrt(size)) return np.array(signature,dtype=np.int8).reshape((sqrts,sqrts))
def test_logical_and_or_xor(self): assert_array_equal(self.t | self.t, self.t) assert_array_equal(self.f | self.f, self.f) assert_array_equal(self.t | self.f, self.t) assert_array_equal(self.f | self.t, self.t) np.logical_or(self.t, self.t, out=self.o) assert_array_equal(self.o, self.t) assert_array_equal(self.t & self.t, self.t) assert_array_equal(self.f & self.f, self.f) assert_array_equal(self.t & self.f, self.f) assert_array_equal(self.f & self.t, self.f) np.logical_and(self.t, self.t, out=self.o) assert_array_equal(self.o, self.t) assert_array_equal(self.t ^ self.t, self.f) assert_array_equal(self.f ^ self.f, self.f) assert_array_equal(self.t ^ self.f, self.t) assert_array_equal(self.f ^ self.t, self.t) np.logical_xor(self.t, self.t, out=self.o) assert_array_equal(self.o, self.f) assert_array_equal(self.nm & self.t, self.nm) assert_array_equal(self.im & self.f, False) assert_array_equal(self.nm & True, self.nm) assert_array_equal(self.im & False, self.f) assert_array_equal(self.nm | self.t, self.t) assert_array_equal(self.im | self.f, self.im) assert_array_equal(self.nm | True, self.t) assert_array_equal(self.im | False, self.im) assert_array_equal(self.nm ^ self.t, self.im) assert_array_equal(self.im ^ self.f, self.im) assert_array_equal(self.nm ^ True, self.im) assert_array_equal(self.im ^ False, self.im)
def xor_(a: Bool = True, b: Bool = False) -> Bool: return np.logical_xor(a, b)
def count_matrices(data, start_state=None, threshold=None, display=False): num_clusters = 2 if threshold is None: clust = clusterer(data) state = clust.fit_predict(data.reshape(-1, 1)).reshape(data.shape) else: logger.debug("Cluster data based on threshold = {}".format(threshold)) state = data > threshold init_state = state[:,:,0] final_state = state[:,:,1] switched = np.logical_xor(init_state, final_state) init_state_frac = [np.mean(init_state == ct) for ct in range(num_clusters)] for ct, fraction in enumerate(init_state_frac): logger.debug("Initial fraction of state %d: %f" %(ct, fraction)) if start_state is not None and start_state in range(num_clusters): start_stt = start_state else: start_stt = np.argmax(init_state_frac) logger.debug("Start state set to state: {}".format(start_stt)) logger.debug("Switched state is state: {}".format(1-start_stt)) # This array contains a 2x2 count_matrix for each coordinate tuple count_mat = np.zeros((init_state.shape[0], 2, 2)) # count_mat = np.zeros((2,2), dtype=np.int) count_mat[:,0,0] = np.logical_and(init_state == 0, np.logical_not(switched)).sum(axis=-1) count_mat[:,0,1] = np.logical_and(init_state == 0, switched).sum(axis=-1) count_mat[:,1,0] = np.logical_and(init_state == 1, switched).sum(axis=-1) count_mat[:,1,1] = np.logical_and(init_state == 1, np.logical_not(switched)).sum(axis=-1) return count_mat, start_stt
def count_matrices_ber(data, start_state=None, threshold=None, display=None): num_clusters = 2 if threshold is None: clust = clusterer(data) state = clust.fit_predict(data.reshape(-1, 1)).reshape((-1,2)) else: logger.debug("Cluster data based on threshold = {}".format(threshold)) state = data > threshold state = state.reshape((-1,2)) init_state = state[:,0] final_state = state[:,1] switched = np.logical_xor(init_state, final_state) init_state_frac = [np.mean(init_state == ct) for ct in range(num_clusters)] for ct, fraction in enumerate(init_state_frac): logger.debug("Initial fraction of state %d: %f" %(ct, fraction)) if start_state is not None and start_state in range(num_clusters): start_stt = start_state else: start_stt = np.argmax(init_state_frac) logger.debug("Start state set to state: {}".format(start_stt)) logger.debug("Switched state is state: {}".format(1-start_stt)) # This array contains a 2x2 count_matrix for each coordinate tuple count_mat = np.zeros((2, 2)) # count_mat = np.zeros((2,2), dtype=np.int) count_mat[0,0] = np.logical_and(init_state == 0, np.logical_not(switched)).sum() count_mat[0,1] = np.logical_and(init_state == 0, switched).sum() count_mat[1,0] = np.logical_and(init_state == 1, switched).sum() count_mat[1,1] = np.logical_and(init_state == 1, np.logical_not(switched)).sum() return count_mat, start_stt
def encodeMask(M): """ Encode binary mask M using run-length encoding. :param M (bool 2D array) : binary mask to encode :return: R (object RLE) : run-length encoding of binary mask """ [h, w] = M.shape M = M.flatten(order='F') N = len(M) counts_list = [] pos = 0 # counts counts_list.append(1) diffs = np.logical_xor(M[0:N - 1], M[1:N]) for diff in diffs: if diff: pos += 1 counts_list.append(1) else: counts_list[pos] += 1 # if array starts from 1. start with 0 counts for 0 if M[0] == 1: counts_list = [0] + counts_list return {'size': [h, w], 'counts': counts_list, }
def compute_accuracy(scores, labels): is_pos = (labels != 0) is_neg = np.logical_not(is_pos) num_pos = np.sum(is_pos) num_neg = np.sum(is_neg) num_all = num_pos + num_neg is_correct = np.logical_xor(scores < 0, is_pos) accuracy_all = np.sum(is_correct) / num_all accuracy_pos = np.sum(is_correct[is_pos]) / (num_pos + 1) accuracy_neg = np.sum(is_correct[is_neg]) / num_neg return accuracy_all, accuracy_pos, accuracy_neg
def calcAnomaly(self, actual, predicted): """ Calculates the anomaly of two SDRs Uses the equation presented on the wiki: https://github.com/numenta/nupic/wiki/Anomaly-Score-Memo To put this in terms of the temporal pooler: A is the actual input array at a given timestep P is the predicted array that was produced from the previous timestep(s) [A - (A && P)] / [A] Rephrasing as questions: What bits are on in A that are not on in P? How does that compare to total on bits in A? Outputs 0 is there's no difference between P and A. Outputs 1 if P and A are totally distinct. Not a perfect metric - it doesn't credit proximity Next step: combine with a metric for a spatial pooler """ combined = numpy.logical_and(actual, predicted) delta = numpy.logical_xor(actual,combined) delta_score = sum(delta) actual_score = float(sum(actual)) return delta_score / actual_score
def points_in_polys(points, polys, polyy=None): """ :param points: Numpy array of Nx2 points :param polys: Numpy array of N polygons of degree M represented by Mx2 points (NxMx2) for each point, see if respective poly contains it. Returns array of True/False """ result = np.zeros((points.shape[0],), dtype=bool) if isinstance(points, np.ma.masked_array): points = points.data if isinstance(polys, np.ma.masked_array): polys = polys.data if polyy is not None and isinstance(polyy, np.ma.masked_array): polyy = polyy.data pointsx = points[:, 0] pointsy = points[:, 1] v1x = v1y = v2x = v2y = -1 for i in range(0, polys.shape[1]): if polyy is not None: v1x = polys[:, i - 1] v1y = polyy[:, i - 1] v2x = polys[:, i] v2y = polyy[:, i] else: v1x = polys[:, i - 1, 0] v1y = polys[:, i - 1, 1] v2x = polys[:, i, 0] v2y = polys[:, i, 1] test1 = (v2y > pointsy) != (v1y > pointsy) test2 = np.zeros(points.shape[0], dtype=bool) m = np.where(test1 == 1)[0] test2[m] = pointsx[m] < \ (v1x[m] - v2x[m]) * (pointsy[m] - v2y[m]) / \ (v1y[m] - v2y[m]) + v2x[m] np.logical_and(test1, test2, test1) np.logical_xor(result, test1, result) return result
def gold(bits, idx): """Generate the idx-th Gold code of length 2^bits - 1. Parameters ---------- bits : int Length of LFSR. The length of the gold code will be :math:`2^{\\mathtt{bits}} - 1`. idx : int Index of the code to generate within the set of gold codes, where :math:`0 \\le \\mathtt{idx} < 2^{\\mathtt{bits}} + 1`. """ bits = int(bits) if bits not in TAPS: raise ValueError('Preferred pairs for %d bits unknown.' % bits) seed = np.ones(bits, dtype=bool) seq1 = lfsr(TAPS[bits][0], seed) seq2 = lfsr(TAPS[bits][1], seed) if idx == 0: return seq1 elif idx == 1: return seq2 else: return np.logical_xor(seq1, np.roll(seq2, -idx + 2))
def read_train(file_path): data = pd.read_csv(file_path, index_col=False) data.drop(['Street', 'Utilities', 'Condition2', 'RoofMatl', 'Alley', 'GarageYrBlt', 'GarageCond', 'PoolQC', 'MiscFeature'], axis=1, inplace=True) # marked as NA in BsmtExposure and not NA in other Bsmt Attributes data.loc[np.logical_xor(data['BsmtCond'].isnull(), data['BsmtExposure'].isnull()), 'BsmtExposure'] = 'No' # LotFrontage's N/A is assigned zero, will it cause problem? data.fillna(value={'MasVnrType': 'None', 'MasVnrArea': 0, 'BsmtQual': 'NoBsmt', 'BsmtCond': 'NoBsmt', 'BsmtExposure': 'NoBsmt', 'BsmtFinType1': 'NoBsmt', 'BsmtFinType2': 'NoBsmt', 'Electrical': 'SBrkr', 'FireplaceQu': 'NoFP', 'GarageType': 'Noga', 'GarageFinish': 'Noga', 'GarageQual': 'Noga', 'Fence': 'NoFence', 'LotFrontage': 0}, inplace=True) data.loc[:, 'YrSold'] = 2016 - data.loc[:, 'YrSold'] data.loc[data.loc[:, 'PoolArea'] != 0, 'PoolArea'] = 1 data.loc[:, 'Porch'] = np.sum(data.loc[:, ['EnclosedPorch', '3SsnPorch', 'ScreenPorch']], axis=1) data.drop(['EnclosedPorch', '3SsnPorch', 'ScreenPorch'], axis=1, inplace=True) data.replace({'BsmtFullBath': {3: 2}, 'LotShape': {'IR3': 'IR2'}}, inplace=True) return data
def data_cleaning(file_path): data = pd.read_csv(file_path, index_col=False) data.drop(['Street', 'Utilities', 'Condition2', 'RoofMatl', 'Alley', 'GarageYrBlt', 'GarageCond', 'PoolQC', 'MiscFeature'], axis=1, inplace=True) # marked as NA in BsmtExposure and not NA in other Bsmt Attributes data.loc[np.logical_xor(data['BsmtCond'].isnull(), data['BsmtExposure'].isnull()), 'BsmtExposure'] = 'No' # LotFrontage's N/A is assigned zero, will it cause problem? data.fillna(value={'MasVnrType': 'None', 'MasVnrArea': 0, 'BsmtQual': 'NoBsmt', 'BsmtCond': 'NoBsmt', 'BsmtExposure': 'NoBsmt', 'BsmtFinType1': 'NoBsmt', 'BsmtFinType2': 'NoBsmt', 'Electrical': 'SBrkr', 'FireplaceQu': 'NoFP', 'GarageType': 'Noga', 'GarageFinish': 'Noga', 'GarageQual': 'Noga', 'Fence': 'NoFence', 'LotFrontage': 0}, inplace=True) data.loc[:, 'YrSold'] = 2016 - data.loc[:, 'YrSold'] data.loc[:, 'YearBuilt'] = 2016 - data.loc[:, 'YearBuilt'] data.loc[:, 'YearRemodAdd'] = 2016 - data.loc[:, 'YearRemodAdd'] data.loc[data.loc[:, 'PoolArea'] != 0, 'PoolArea'] = 'Y' data.loc[data.loc[:, 'PoolArea'] == 0, 'PoolArea'] = 'N' data.loc[:, 'Porch'] = np.sum(data.loc[:, ['EnclosedPorch', '3SsnPorch', 'ScreenPorch']], axis=1) data.drop(['EnclosedPorch', '3SsnPorch', 'ScreenPorch'], axis=1, inplace=True) data.replace({'BsmtFullBath': {3: 2}, 'LotShape': {'IR3': 'IR2'}}, inplace=True) return data # data.columns # examine columns containing NA value # print(data) # print(data.columns[np.sum(data.isnull(), axis=0) != 0])
def plot_xor(): np.random.seed(0) X_xor = np.random.randn(200, 2) y_xor = np.logical_xor(X_xor[:, 0] > 0, X_xor[:, 1] > 0) y_xor = np.where(y_xor, 1, -1) svm = SVC(kernel='rbf', random_state=0, gamma=0.1, C=10.0) svm.fit(X_xor, y_xor) plot_decision_regions(X_xor, y_xor, classifier=svm) plt.legend(loc='upper left') plt.show()
def shortest_path(mgrid, domain, targets, obstacles, buffer_radius): """Vector field guiding towards targets.""" obstacles_buffered = obstacles.buffer(buffer_radius).intersection(domain) dmap_targets = distance_map(mgrid, targets, obstacles_buffered) dir_map_targets = direction_map(dmap_targets) # Fill values between buffered region and obstacles mask = np.full(mgrid.shape, False, dtype=np.bool_) draw_geom(obstacles, mask, mgrid.indicer, True) fill_missing(np.logical_xor(mask, dir_map_targets[0].mask), *mgrid.values, *dir_map_targets) return dir_map_targets, dmap_targets
def from_xyxy(cls, xmin, ymin, xmax, ymax, correct_flipped=False): x_flipped = True if xmax >= 0 and xmin > xmax else False y_flipped = True if ymax >= 0 and ymin > ymax else False if correct_flipped: if np.logical_xor(x_flipped, y_flipped): assert False, "Invalid bounding box" elif x_flipped and y_flipped: xmin, xmax = xmax, xmin ymin, ymax = ymax, ymin return cls(xmin, ymin, xmax - xmin + 1, ymax - ymin + 1)
def xor_data(num_examples, noise=None): X = randn(num_examples, 2) if noise is None: X_ = X else: X_ = X + noise * randn(num_examples, 2) y = np.logical_xor(X_[:, 0] > 0, X_[:, 1] > 0).astype(int) return X, y
def test_half_ufuncs(self): """Test the various ufuncs""" a = np.array([0, 1, 2, 4, 2], dtype=float16) b = np.array([-2, 5, 1, 4, 3], dtype=float16) c = np.array([0, -1, -np.inf, np.nan, 6], dtype=float16) assert_equal(np.add(a, b), [-2, 6, 3, 8, 5]) assert_equal(np.subtract(a, b), [2, -4, 1, 0, -1]) assert_equal(np.multiply(a, b), [0, 5, 2, 16, 6]) assert_equal(np.divide(a, b), [0, 0.199951171875, 2, 1, 0.66650390625]) assert_equal(np.equal(a, b), [False, False, False, True, False]) assert_equal(np.not_equal(a, b), [True, True, True, False, True]) assert_equal(np.less(a, b), [False, True, False, False, True]) assert_equal(np.less_equal(a, b), [False, True, False, True, True]) assert_equal(np.greater(a, b), [True, False, True, False, False]) assert_equal(np.greater_equal(a, b), [True, False, True, True, False]) assert_equal(np.logical_and(a, b), [False, True, True, True, True]) assert_equal(np.logical_or(a, b), [True, True, True, True, True]) assert_equal(np.logical_xor(a, b), [True, False, False, False, False]) assert_equal(np.logical_not(a), [True, False, False, False, False]) assert_equal(np.isnan(c), [False, False, False, True, False]) assert_equal(np.isinf(c), [False, False, True, False, False]) assert_equal(np.isfinite(c), [True, True, False, False, True]) assert_equal(np.signbit(b), [True, False, False, False, False]) assert_equal(np.copysign(b, a), [2, 5, 1, 4, 3]) assert_equal(np.maximum(a, b), [0, 5, 2, 4, 3]) x = np.maximum(b, c) assert_(np.isnan(x[3])) x[3] = 0 assert_equal(x, [0, 5, 1, 0, 6]) assert_equal(np.minimum(a, b), [-2, 1, 1, 4, 2]) x = np.minimum(b, c) assert_(np.isnan(x[3])) x[3] = 0 assert_equal(x, [-2, -1, -np.inf, 0, 3]) assert_equal(np.fmax(a, b), [0, 5, 2, 4, 3]) assert_equal(np.fmax(b, c), [0, 5, 1, 4, 6]) assert_equal(np.fmin(a, b), [-2, 1, 1, 4, 2]) assert_equal(np.fmin(b, c), [-2, -1, -np.inf, 4, 3]) assert_equal(np.floor_divide(a, b), [0, 0, 2, 1, 0]) assert_equal(np.remainder(a, b), [0, 1, 0, 0, 2]) assert_equal(np.square(b), [4, 25, 1, 16, 9]) assert_equal(np.reciprocal(b), [-0.5, 0.199951171875, 1, 0.25, 0.333251953125]) assert_equal(np.ones_like(b), [1, 1, 1, 1, 1]) assert_equal(np.conjugate(b), b) assert_equal(np.absolute(b), [2, 5, 1, 4, 3]) assert_equal(np.negative(b), [2, -5, -1, -4, -3]) assert_equal(np.sign(b), [-1, 1, 1, 1, 1]) assert_equal(np.modf(b), ([0, 0, 0, 0, 0], b)) assert_equal(np.frexp(b), ([-0.5, 0.625, 0.5, 0.5, 0.75], [2, 3, 1, 3, 2])) assert_equal(np.ldexp(b, [0, 1, 2, 4, 2]), [-2, 10, 4, 64, 12])