# Python numpy.isinf() Examples

The following are 30 code examples for showing how to use numpy.isinf(). These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example.

You may check out the related API usage on the sidebar.

You may also want to check out all available functions/classes of the module , or try the search function .

Example 1
```def normalize_adj(A, is_sym=True, exponent=0.5):
"""

is_sym=True: D^{-1/2} A D^{-1/2}
is_sym=False: D^{-1} A
"""
rowsum = np.array(A.sum(1))

if is_sym:
r_inv = np.power(rowsum, -exponent).flatten()
else:
r_inv = np.power(rowsum, -1.0).flatten()

r_inv[np.isinf(r_inv)] = 0.

if sp.isspmatrix(A):
r_mat_inv = sp.diags(r_inv.squeeze())
else:
r_mat_inv = np.diag(r_inv)

if is_sym:
return r_mat_inv.dot(A).dot(r_mat_inv)
else:
return r_mat_inv.dot(A) ```
Example 2
```def _compute_delta(log_moments, eps):
"""Compute delta for given log_moments and eps.

Args:
log_moments: the log moments of privacy loss, in the form of pairs
of (moment_order, log_moment)
eps: the target epsilon.
Returns:
delta
"""
min_delta = 1.0
for moment_order, log_moment in log_moments:
if moment_order == 0:
continue
if math.isinf(log_moment) or math.isnan(log_moment):
sys.stderr.write("The %d-th order is inf or Nan\n" % moment_order)
continue
if log_moment < moment_order * eps:
min_delta = min(min_delta,
math.exp(log_moment - moment_order * eps))
return min_delta ```
Example 3
```def _compute_eps(log_moments, delta):
"""Compute epsilon for given log_moments and delta.

Args:
log_moments: the log moments of privacy loss, in the form of pairs
of (moment_order, log_moment)
delta: the target delta.
Returns:
epsilon
"""
min_eps = float("inf")
for moment_order, log_moment in log_moments:
if moment_order == 0:
continue
if math.isinf(log_moment) or math.isnan(log_moment):
sys.stderr.write("The %d-th order is inf or Nan\n" % moment_order)
continue
min_eps = min(min_eps, (log_moment - math.log(delta)) / moment_order)
return min_eps ```
Example 4
```def _get_numeric_feature_analysis_data(self, series, output):

logger.info("Checking series of type: %s (isM8=%s)" % (series.dtype, series.dtype == np.dtype('M8[ns]')))

if np.isinf(series).any():
raise ValueError("Numeric feature '%s' contains Infinity values" % name)

output['stats'] = {
'min': series.min(),
'average': series.mean(),
'median': series.median(),
'max': series.max(),
'p99': series.quantile(0.99),
'std': series.std()
}
output['nulls_count'] = series.isnull().sum()

return output ```
Example 5
```def test_float(self):
# offset for alignment test
for i in range(4):
assert_array_equal(self.f[i:] > 0, self.ef[i:])
assert_array_equal(self.f[i:] - 1 >= 0, self.ef[i:])
assert_array_equal(self.f[i:] == 0, ~self.ef[i:])
assert_array_equal(-self.f[i:] < 0, self.ef[i:])
assert_array_equal(-self.f[i:] + 1 <= 0, self.ef[i:])
r = self.f[i:] != 0
assert_array_equal(r, self.ef[i:])
r2 = self.f[i:] != np.zeros_like(self.f[i:])
r3 = 0 != self.f[i:]
assert_array_equal(r, r2)
assert_array_equal(r, r3)
# check bool == 0x1
assert_array_equal(r.view(np.int8), r.astype(np.int8))
assert_array_equal(r2.view(np.int8), r2.astype(np.int8))
assert_array_equal(r3.view(np.int8), r3.astype(np.int8))

# isnan on amd64 takes the same code path
assert_array_equal(np.isnan(self.nf[i:]), self.ef[i:])
assert_array_equal(np.isfinite(self.nf[i:]), ~self.ef[i:])
assert_array_equal(np.isfinite(self.inff[i:]), ~self.ef[i:])
assert_array_equal(np.isinf(self.inff[i:]), self.efnonan[i:])
assert_array_equal(np.signbit(self.signf[i:]), self.ef[i:]) ```
Example 6
```def test_double(self):
# offset for alignment test
for i in range(2):
assert_array_equal(self.d[i:] > 0, self.ed[i:])
assert_array_equal(self.d[i:] - 1 >= 0, self.ed[i:])
assert_array_equal(self.d[i:] == 0, ~self.ed[i:])
assert_array_equal(-self.d[i:] < 0, self.ed[i:])
assert_array_equal(-self.d[i:] + 1 <= 0, self.ed[i:])
r = self.d[i:] != 0
assert_array_equal(r, self.ed[i:])
r2 = self.d[i:] != np.zeros_like(self.d[i:])
r3 = 0 != self.d[i:]
assert_array_equal(r, r2)
assert_array_equal(r, r3)
# check bool == 0x1
assert_array_equal(r.view(np.int8), r.astype(np.int8))
assert_array_equal(r2.view(np.int8), r2.astype(np.int8))
assert_array_equal(r3.view(np.int8), r3.astype(np.int8))

# isnan on amd64 takes the same code path
assert_array_equal(np.isnan(self.nd[i:]), self.ed[i:])
assert_array_equal(np.isfinite(self.nd[i:]), ~self.ed[i:])
assert_array_equal(np.isfinite(self.infd[i:]), ~self.ed[i:])
assert_array_equal(np.isinf(self.infd[i:]), self.ednonan[i:])
assert_array_equal(np.signbit(self.signd[i:]), self.ed[i:]) ```
Example 7
```def test_zero_division(self):
with np.errstate(all="ignore"):
for t in [np.complex64, np.complex128]:
a = t(0.0)
b = t(1.0)
assert_(np.isinf(b/a))
b = t(complex(np.inf, np.inf))
assert_(np.isinf(b/a))
b = t(complex(np.inf, np.nan))
assert_(np.isinf(b/a))
b = t(complex(np.nan, np.inf))
assert_(np.isinf(b/a))
b = t(complex(np.nan, np.nan))
assert_(np.isnan(b/a))
b = t(0.)
assert_(np.isnan(b/a)) ```
Example 8
```def test_numpy_type_funcs(func):
# for func in [np.isfinite, np.isinf, np.isnan, np.signbit]:
# copy and paste from idx fixture as pytest doesn't support
# parameters and fixtures at the same time.
major_axis = Index(['foo', 'bar', 'baz', 'qux'])
minor_axis = Index(['one', 'two'])
major_codes = np.array([0, 0, 1, 2, 3, 3])
minor_codes = np.array([0, 1, 0, 1, 0, 1])
index_names = ['first', 'second']

idx = MultiIndex(
levels=[major_axis, minor_axis],
codes=[major_codes, minor_codes],
names=index_names,
verify_integrity=False
)

with pytest.raises(Exception):
func(idx) ```
Example 9
```def test_sum_inf(self):
s = Series(np.random.randn(10))
s2 = s.copy()

s[5:8] = np.inf
s2[5:8] = np.nan

assert np.isinf(s.sum())

arr = np.random.randn(100, 100).astype('f4')
arr[:, 2] = np.inf

with pd.option_context("mode.use_inf_as_na", True):
tm.assert_almost_equal(s.sum(), s2.sum())

res = nanops.nansum(arr, axis=1)
assert np.isinf(res).all() ```
Example 10
```def _get_viewpoint_estimation_labels(viewpoint_data, clss, num_classes):
"""Bounding-box regression targets are stored in a compact form in the
roidb.

This function expands those targets into the 4-of-4*K representation used
by the network (i.e. only one class has non-zero targets). The loss weights
are similarly expanded.

Returns:
view_target_data (ndarray): N x 3K blob of regression targets
view_loss_weights (ndarray): N x 3K blob of loss weights
"""
view_targets = np.zeros((clss.size, 3 * num_classes), dtype=np.float32)
view_loss_weights = np.zeros(view_targets.shape, dtype=np.float32)
inds = np.where( (clss > 0) & np.isfinite(viewpoint_data[:,0]) & np.isfinite(viewpoint_data[:,1]) & np.isfinite(viewpoint_data[:,2]) )[0]
for ind in inds:
cls = clss[ind]
start = 3 * cls
end = start + 3
view_targets[ind, start:end] = viewpoint_data[ind, :]
view_loss_weights[ind, start:end] = [1., 1., 1.]

assert not np.isinf(view_targets).any(), 'viewpoint undefined'
return view_targets, view_loss_weights ```
Example 11
```def _check_1d_arrays(a: ndarray, b: ndarray, kind: str, tol: float = 10 ** -4) -> bool:
if kind == 'O':
if not va.is_equal_1d_object(a, b):
raise AssertionError(f'The values of the columns are not equal')
return True
elif kind == 'f':
with np.errstate(invalid='ignore'):
criteria1 = np.abs(a - b) < tol
criteria2 = np.isnan(a) & np.isnan(b)
criteria3 = np.isinf(a) & np.isinf(b)
return (criteria1 | criteria2 | criteria3).all()
else:
try:
np.testing.assert_array_equal(a, b)
except AssertionError:
return False
return True ```
Example 12
```def map(self, data):
data = data[self.fieldName]
colors = np.empty((len(data), 4))
default = np.array(fn.colorTuple(self['Default'])) / 255.
colors[:] = default

for v in self.param('Values'):
c = np.array(fn.colorTuple(v.value())) / 255.
#scaled = np.clip((data-self['Min']) / (self['Max']-self['Min']), 0, 1)
#cmap = self.value()
#colors = cmap.map(scaled, mode='float')

#nanColor = self['NaN']
#nanColor = (nanColor.red()/255., nanColor.green()/255., nanColor.blue()/255., nanColor.alpha()/255.)

return colors ```
Example 13
```def testDtypeExecution(self):
a = ones((10, 20), dtype='f4', chunk_size=5)

c = truediv(a, 2, dtype='f8')

res = self.executor.execute_tensor(c, concat=True)[0]
self.assertEqual(res.dtype, np.float64)

c = truediv(a, 0, dtype='f8')
res = self.executor.execute_tensor(c, concat=True)[0]
self.assertTrue(np.isinf(res[0, 0]))

with self.assertRaises(FloatingPointError):
with np.errstate(divide='raise'):
c = truediv(a, 0, dtype='f8')
_ = self.executor.execute_tensor(c, concat=True)[0]  # noqa: F841 ```
Example 14
```def scale_neg_1_to_1_with_zero_mean_log_abs_max(v):
'''
!!! not working
'''
df = pd.DataFrame({'v':v,
'sign': (v > 0) * 2 - 1})
df['lg'] = np.log(np.abs(v)) / np.log(1.96)
df['exclude'] = (np.isinf(df.lg) | np.isneginf(df.lg))
for mask in [(df['sign'] == -1) & (df['exclude'] == False),
(df['sign'] == 1) & (df['exclude'] == False)]:
df['lg'] *= df['sign']
df['lg'] = df['lg'].fillna(0)
print(df[df['exclude']]['lg'].values)
#to_rescale = convention_df['lg'].reindex(v.index)
df['to_out'] =  scale_neg_1_to_1_with_zero_mean_abs_max(df['lg'])
print('right')
print(df.sort_values(by='lg').iloc[:5])
print(df.sort_values(by='lg').iloc[-5:])
print('to_out')
print(df.sort_values(by='to_out').iloc[:5])
print(df.sort_values(by='to_out').iloc[-5:])
print(len(df), len(df.dropna()))
return df['to_out'] ```
Example 15
```def calc_inv_vol_weights(returns):
"""
Calculates weights proportional to inverse volatility of each column.

Returns weights that are inversely proportional to the column's
volatility resulting in a set of portfolio weights where each position
has the same level of volatility.

Note, that assets with returns all equal to NaN or 0 are excluded from
the portfolio (their weight is set to NaN).

Returns:
Series {col_name: weight}
"""
# calc vols
vol = np.divide(1., np.std(returns, ddof=1))
vol[np.isinf(vol)] = np.NaN
volsum = vol.sum()
return np.divide(vol, volsum) ```
Example 16
```def _entropy(self, *args):
def integ(x):
val = self._pdf(x, *args)
return entr(val)

# upper limit is often inf, so suppress warnings when integrating
olderr = np.seterr(over='ignore')
np.seterr(**olderr)

if not np.isnan(h):
return h
else:
# try with different limits if integration problems
low, upp = self.ppf([1e-10, 1. - 1e-10], *args)
if np.isinf(self.b):
upper = upp
else:
upper = self.b
if np.isinf(self.a):
lower = low
else:
lower = self.a
Example 17
```def _to_np_float64(v):
if math.isnan(v) or math.isinf(v):
return np.inf
return np.float64(v)

######################
# FLOAT64 ARITHMETIC #
###################### ```
Example 18
```def compute_log_moment(q, sigma, steps, lmbd, verify=False, verbose=False):
"""Compute the log moment of Gaussian mechanism for given parameters.

Args:
q: the sampling ratio.
sigma: the noise sigma.
steps: the number of steps.
lmbd: the moment order.
verify: if False, only compute the symbolic version. If True, computes
both symbolic and numerical solutions and verifies the results match.
verbose: if True, print out debug information.
Returns:
the log moment with type np.float64, could be np.inf.
"""
moment = compute_a(sigma, q, lmbd, verbose=verbose)
if verify:
mp.dps = 50
moment_a_mp = compute_a_mp(sigma, q, lmbd, verbose=verbose)
moment_b_mp = compute_b_mp(sigma, q, lmbd, verbose=verbose)
np.testing.assert_allclose(moment, moment_a_mp, rtol=1e-10)
if not np.isinf(moment_a_mp):
# The following test fails for (1, np.inf)!
np.testing.assert_array_less(moment_b_mp, moment_a_mp)
if np.isinf(moment):
return np.inf
else:
return np.log(moment) * steps ```
Example 19
```def estimate_norm(datas):
if datas.shape[0] < 2:
return None, None, 0.0

mp = np.mean(datas, axis=0)
sp = np.cov(datas.transpose())

sign, logdet = np.linalg.slogdet(sp)
if np.isnan(logdet) or np.isinf(logdet):
return mp, sp, 0.0

ent = sign * logdet
return mp, sp, ent ```
Example 20
```def test_piecewise_with_parameters_json():
"""Test using parameters with piecewise link."""

model.run()

assert_allclose(model.nodes["demand1"].flow, 20) ```
Example 21
```def _acceptance(self, next_error):
"""Return probability of acceptance given an error."""
current_error = self.population.best().total_error
if np.isinf(current_error) or next_error < current_error:
return 1
else:
return math.exp(-(next_error - current_error) / self._get_temp()) ```
Example 22
```def normalize_features(mx):
"""Row-normalize sparse matrix"""
rowsum = np.array(mx.sum(1))
r_inv = np.power(rowsum, -1).flatten()
r_inv[np.isinf(r_inv)] = 0.
r_mat_inv = sp.diags(r_inv)
mx = r_mat_inv.dot(mx)
return mx ```
Example 23
```def tensorize(self, batch_x, batch_c):
atom_tensor = np.zeros((len(batch_x), self.num_atoms, self.get_num_features()))
posn_tensor = np.zeros((len(batch_x), self.num_atoms, self.num_atoms, 3))

for mol_idx, mol in enumerate(batch_x):
Chem.RemoveHs(mol)
mol_atoms = mol.GetNumAtoms()

# Atom features
atom_tensor[mol_idx, :mol_atoms, :] = self.get_atom_features(mol)

# Normalize adjacency matrix by D^(-1/2) * A_hat * D^(-1/2), Kipf et al. 2016
deg_inv_sqrt = np.power(degree, -0.5)
deg_inv_sqrt[np.isinf(deg_inv_sqrt)] = 0.
deg_inv_sqrt = np.diag(deg_inv_sqrt)

# Relative position matrix
for atom_idx in range(mol_atoms):
pos_c = batch_c[mol_idx][atom_idx]

for neighbor_idx in range(mol_atoms):
pos_n = batch_c[mol_idx][neighbor_idx]

# Direction should be Neighbor -> Center
n_to_c = [pos_c[0] - pos_n[0], pos_c[1] - pos_n[1], pos_c[2] - pos_n[2]]
posn_tensor[mol_idx, atom_idx, neighbor_idx, :] = n_to_c

Example 24
```def preprocess_features(features):
"""Row-normalize feature matrix and convert to tuple representation"""
rowsum = np.array(features.sum(1))
r_inv = np.power(rowsum, -1).flatten()
r_inv[np.isinf(r_inv)] = 0.
r_mat_inv = sp.diags(r_inv)
features = sp.coo_matrix(features)
features = r_mat_inv.dot(features)
return sparse_to_tuple(features) ```
Example 25
```def normalize_adj(adj):
d_inv_sqrt = np.power(rowsum, -0.5).flatten()
d_inv_sqrt[np.isinf(d_inv_sqrt)] = 0.
d_mat_inv_sqrt = sp.diags(d_inv_sqrt)
Example 26
```def test_masked(self):
mat = np.ma.fix_invalid(_ndat)
for f in [np.nanmin]:
res = f(mat, axis=1)
tgt = f(_ndat, axis=1)
assert_equal(res, tgt)
assert_(not np.isinf(mat).any()) ```
Example 27
```def test_goodvalues(self):
z = np.array((-1., 0., 1.))
res = np.isinf(z) == 0
assert_all(np.all(res, axis=0)) ```
Example 28
```def test_posinf(self):
```def test_posinf_scalar(self):
```def test_neginf(self):