# Python math.isnan() Examples

The following are code examples for showing how to use math.isnan(). They are from open source Python projects. You can vote up the examples you like or vote down the ones you don't like.

Example 1
 Project: pyblish-win   Author: pyblish   File: fractions.py    GNU Lesser General Public License v3.0 7 votes
```def __eq__(a, b):
"""a == b"""
if isinstance(b, Rational):
return (a._numerator == b.numerator and
a._denominator == b.denominator)
if isinstance(b, numbers.Complex) and b.imag == 0:
b = b.real
if isinstance(b, float):
if math.isnan(b) or math.isinf(b):
# comparisons with an infinity or nan should behave in
# the same way for any finite a, so treat a as zero.
return 0.0 == b
else:
return a == a.from_float(b)
else:
# Since a doesn't know how to compare with b, let's give b
# a chance to compare itself with a.
return NotImplemented ```
Example 2
 Project: pyblish-win   Author: pyblish   File: fractions.py    GNU Lesser General Public License v3.0 6 votes
```def _richcmp(self, other, op):
"""Helper for comparison operators, for internal use only.

Implement comparison between a Rational instance `self`, and
either another Rational instance or a float `other`.  If
`other` is not a Rational instance or a float, return
NotImplemented. `op` should be one of the six standard
comparison operators.

"""
# convert other to a Rational instance where reasonable.
if isinstance(other, Rational):
return op(self._numerator * other.denominator,
self._denominator * other.numerator)
# comparisons with complex should raise a TypeError, for consistency
# with int<->complex, float<->complex, and complex<->complex comparisons.
if isinstance(other, complex):
raise TypeError("no ordering relation is defined for complex numbers")
if isinstance(other, float):
if math.isnan(other) or math.isinf(other):
return op(0.0, other)
else:
return op(self, self.from_float(other))
else:
return NotImplemented ```
Example 3
 Project: pyblish-win   Author: pyblish   File: test_float.py    GNU Lesser General Public License v3.0 6 votes
```def test_nan_from_str(self):
self.assertTrue(isnan(float("nan")))
self.assertTrue(isnan(float("+nan")))
self.assertTrue(isnan(float("-nan")))

self.assertEqual(repr(float("nan")), "nan")
self.assertEqual(repr(float("+nan")), "nan")
self.assertEqual(repr(float("-nan")), "nan")

self.assertEqual(repr(float("NAN")), "nan")
self.assertEqual(repr(float("+NAn")), "nan")
self.assertEqual(repr(float("-NaN")), "nan")

self.assertEqual(str(float("nan")), "nan")
self.assertEqual(str(float("+nan")), "nan")
self.assertEqual(str(float("-nan")), "nan")

self.assertRaises(ValueError, float, "nana")
self.assertRaises(ValueError, float, "+nana")
self.assertRaises(ValueError, float, "-nana")
self.assertRaises(ValueError, float, "na")
self.assertRaises(ValueError, float, "+na")
self.assertRaises(ValueError, float, "-na") ```
Example 4
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 6 votes
```def testFmod(self):
self.assertRaises(TypeError, math.fmod)
self.ftest('fmod(10,1)', math.fmod(10,1), 0)
self.ftest('fmod(10,0.5)', math.fmod(10,0.5), 0)
self.ftest('fmod(10,1.5)', math.fmod(10,1.5), 1)
self.ftest('fmod(-10,1)', math.fmod(-10,1), 0)
self.ftest('fmod(-10,0.5)', math.fmod(-10,0.5), 0)
self.ftest('fmod(-10,1.5)', math.fmod(-10,1.5), -1)
self.assertTrue(math.isnan(math.fmod(NAN, 1.)))
self.assertTrue(math.isnan(math.fmod(1., NAN)))
self.assertTrue(math.isnan(math.fmod(NAN, NAN)))
self.assertRaises(ValueError, math.fmod, 1., 0.)
self.assertRaises(ValueError, math.fmod, INF, 1.)
self.assertRaises(ValueError, math.fmod, NINF, 1.)
self.assertRaises(ValueError, math.fmod, INF, 0.)
self.assertEqual(math.fmod(3.0, INF), 3.0)
self.assertEqual(math.fmod(-3.0, INF), -3.0)
self.assertEqual(math.fmod(3.0, NINF), 3.0)
self.assertEqual(math.fmod(-3.0, NINF), -3.0)
self.assertEqual(math.fmod(0.0, 3.0), 0.0)
self.assertEqual(math.fmod(0.0, NINF), 0.0) ```
Example 5
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 6 votes
```def testFrexp(self):
self.assertRaises(TypeError, math.frexp)

def testfrexp(name, result, expected):
(mant, exp), (emant, eexp) = result, expected
if abs(mant-emant) > eps or exp != eexp:
self.fail('%s returned %r, expected %r'%\
(name, (mant, exp), (emant,eexp)))

testfrexp('frexp(-1)', math.frexp(-1), (-0.5, 1))
testfrexp('frexp(0)', math.frexp(0), (0, 0))
testfrexp('frexp(1)', math.frexp(1), (0.5, 1))
testfrexp('frexp(2)', math.frexp(2), (0.5, 2))

self.assertEqual(math.frexp(INF)[0], INF)
self.assertEqual(math.frexp(NINF)[0], NINF)
self.assertTrue(math.isnan(math.frexp(NAN)[0])) ```
Example 6
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 6 votes
```def testModf(self):
self.assertRaises(TypeError, math.modf)

def testmodf(name, result, expected):
(v1, v2), (e1, e2) = result, expected
if abs(v1-e1) > eps or abs(v2-e2):
self.fail('%s returned %r, expected %r'%\
(name, (v1,v2), (e1,e2)))

testmodf('modf(1.5)', math.modf(1.5), (0.5, 1.0))
testmodf('modf(-1.5)', math.modf(-1.5), (-0.5, -1.0))

self.assertEqual(math.modf(INF), (0.0, INF))
self.assertEqual(math.modf(NINF), (-0.0, NINF))

modf_nan = math.modf(NAN)
self.assertTrue(math.isnan(modf_nan[0]))
self.assertTrue(math.isnan(modf_nan[1])) ```
Example 7
 Project: programsynthesishunting   Author: flexgp   File: moo_ff.py    GNU General Public License v3.0 6 votes
```def __call__(self, ind):
"""
Note that math functions used in the solutions are imported from either
utilities.fitness.math_functions or called from numpy.

:param ind: An individual to be evaluated.
:return: The fitness of the evaluated individual.
"""

# the multi-objective fitness is defined as a list of values, each one
# representing the output of one objective function. The computation is
# made by the function multi_objc_eval, implemented by a subclass,
# according to the problem.
fitness = [ff(ind) for ff in self.fitness_functions]

if any([isnan(i) for i in fitness]):
# Check if any objective fitness value is NaN, if so set default
# fitness.
fitness = self.default_fitness

return fitness ```
Example 8
```def _compute_delta(self, 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 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 9
```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 10
```def GenerateBinomialTable(m):
"""Generate binomial table.

Args:
m: the size of the table.
Returns:
A two dimensional array T where T[i][j] = (i choose j),
for 0<= i, j <=m.
"""

table = numpy.zeros((m + 1, m + 1), dtype=numpy.float64)
for i in range(m + 1):
table[i, 0] = 1
for i in range(1, m + 1):
for j in range(1, m + 1):
v = table[i - 1, j] + table[i - 1, j -1]
assert not math.isnan(v) and not math.isinf(v)
table[i, j] = v
return tf.convert_to_tensor(table) ```
Example 11
```def backward(self, loss):
'''
Standard backward step with self.timer and debugger
Arguments
loss - the loss to perform loss.backward()
'''
self.timer.set()
loss.backward()
self.verbose('Error : grad norm is NaN @ step '+str(self.step))
else:
self.optimizer.step()
self.timer.cnt('bw')
Example 12
```def write_log(self, log_name, log_dict):
'''
Write log to TensorBoard
log_name  - <str> Name of tensorboard variable
log_value - <dict>/<array> Value of variable (e.g. dict of losses), passed if value = None
'''
if type(log_dict) is dict:
log_dict = {key: val for key, val in log_dict.items() if (
val is not None and not math.isnan(val))}
if log_dict is None:
pass
elif len(log_dict) > 0:
if 'align' in log_name or 'spec' in log_name:
img, form = log_dict
log_name, img, global_step=self.step, dataformats=form)
elif 'text' in log_name or 'hyp' in log_name:
else:
Example 13
 Project: Parallel.GAMIT   Author: demiangomez   File: pyPPP.py    GNU General Public License v3.0 6 votes
```def get_xyz(section):

x = re.findall(r'X\s\(m\)\s+(-?\d+\.\d+|[nN]a[nN]|\*+)\s+(-?\d+\.\d+|[nN]a[nN]|\*+)', section)[0][1]
y = re.findall(r'Y\s\(m\)\s+(-?\d+\.\d+|[nN]a[nN]|\*+)\s+(-?\d+\.\d+|[nN]a[nN]|\*+)', section)[0][1]
z = re.findall(r'Z\s\(m\)\s+(-?\d+\.\d+|[nN]a[nN]|\*+)\s+(-?\d+\.\d+|[nN]a[nN]|\*+)', section)[0][1]

if '*' not in x and '*' not in y and '*' not in z:
x = float(x)
y = float(y)
z = float(z)
else:
raise pyRunPPPExceptionNaN('One or more coordinate is NaN')

if isnan(x) or isnan(y) or isnan(z):
raise pyRunPPPExceptionNaN('One or more coordinate is NaN')

return x, y, z ```
Example 14
```def from_float(cls, f):
"""Converts a finite float to a rational number, exactly.

Beware that Fraction.from_float(0.3) != Fraction(3, 10).

"""
if isinstance(f, numbers.Integral):
return cls(f)
elif not isinstance(f, float):
raise TypeError("%s.from_float() only takes floats, not %r (%s)" %
(cls.__name__, f, type(f).__name__))
if math.isnan(f):
raise ValueError("Cannot convert %r to %s." % (f, cls.__name__))
if math.isinf(f):
raise OverflowError("Cannot convert %r to %s." % (f, cls.__name__))
return cls(*f.as_integer_ratio()) ```
Example 15
```def __eq__(a, b):
"""a == b"""
if isinstance(b, numbers.Rational):
return (a._numerator == b.numerator and
a._denominator == b.denominator)
if isinstance(b, numbers.Complex) and b.imag == 0:
b = b.real
if isinstance(b, float):
if math.isnan(b) or math.isinf(b):
# comparisons with an infinity or nan should behave in
# the same way for any finite a, so treat a as zero.
return 0.0 == b
else:
return a == a.from_float(b)
else:
# Since a doesn't know how to compare with b, let's give b
# a chance to compare itself with a.
return NotImplemented ```
Example 16
```def _richcmp(self, other, op):
"""Helper for comparison operators, for internal use only.

Implement comparison between a Rational instance `self`, and
either another Rational instance or a float `other`.  If
`other` is not a Rational instance or a float, return
NotImplemented. `op` should be one of the six standard
comparison operators.

"""
# convert other to a Rational instance where reasonable.
if isinstance(other, numbers.Rational):
return op(self._numerator * other.denominator,
self._denominator * other.numerator)
if isinstance(other, float):
if math.isnan(other) or math.isinf(other):
return op(0.0, other)
else:
return op(self, self.from_float(other))
else:
return NotImplemented ```
Example 17
```def _isnumber(string):
"""
>>> _isnumber("123.45")
True
>>> _isnumber("123")
True
>>> _isnumber("spam")
False
>>> _isnumber("123e45678")
False
>>> _isnumber("inf")
True
"""
if not _isconvertible(float, string):
return False
elif isinstance(string, (_text_type, _binary_type)) and (
math.isinf(float(string)) or math.isnan(float(string))):
return string.lower() in ['inf', '-inf', 'nan']
return True ```
Example 18
```def add_standard_date(metadata, datecols):
fills it using best available non-missing date in one of
several other columns'''

zeroes = np.zeros(rowcount, dtype = 'int16')

for col in datecols:

try:
except:
intdate = float('nan')

if not math.isnan(intdate) and intdate > 1:
break

Example 19
```def _ingest_summary(self):
# get date parameters.
yr = self._date[:4]
mn = self._date[4:6]
dy = self._date[6:]

self._logger.info("Getting ingest summary data for the day")

ingest_summary_cols = ["date","total"]
result_rows = []
df_filtered =  pd.DataFrame()

SELECT frame_time, COUNT(*) as total FROM {0}.{1}
WHERE y={2} AND m={3} AND d={4} AND unix_tstamp IS NOT NULL
AND frame_time IS NOT NULL AND frame_len IS NOT NULL
AND dns_qry_name IS NOT NULL AND ip_src IS NOT NULL
AND (dns_qry_class IS NOT NULL AND dns_qry_type IS NOT NULL
AND dns_qry_rcode IS NOT NULL ) GROUP BY frame_time;
""").format(self._db,self._table_name, yr, mn, dy)

df = pd.DataFrame(results)

# Forms a new dataframe splitting the minutes from the time column
df_new = pd.DataFrame([["{0}-{1}-{2} {3}:{4}".format(yr, mn, dy,\
val['frame_time'].replace("  "," ").split(" ")[3].split(":")[0].zfill(2),\
val['frame_time'].replace("  "," ").split(" ")[3].split(":")[1].zfill(2)),\
int(val['total']) if not math.isnan(val['total']) else 0 ] for key,val in df.iterrows()],columns = ingest_summary_cols)

#Groups the data by minute
sf = df_new.groupby(by=['date'])['total'].sum()
df_per_min = pd.DataFrame({'date':sf.index, 'total':sf.values})

df_final = df_filtered.append(df_per_min, ignore_index=True).to_records(False,False)

if len(df_final) > 0:
query_to_insert=("""
INSERT INTO {0}.dns_ingest_summary PARTITION (y={1}, m={2}, d={3}) VALUES {4};
""").format(self._db, yr, mn, dy, tuple(df_final))
impala.execute_query(query_to_insert) ```
Example 20
 Project: pyblish-win   Author: pyblish   File: decimal.py    GNU Lesser General Public License v3.0 5 votes
```def from_float(cls, f):
"""Converts a float to a decimal number, exactly.

Note that Decimal.from_float(0.1) is not the same as Decimal('0.1').
Since 0.1 is not exactly representable in binary floating point, the
value is stored as the nearest representable value which is
0x1.999999999999ap-4.  The exact equivalent of the value in decimal
is 0.1000000000000000055511151231257827021181583404541015625.

>>> Decimal.from_float(0.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
>>> Decimal.from_float(float('nan'))
Decimal('NaN')
>>> Decimal.from_float(float('inf'))
Decimal('Infinity')
>>> Decimal.from_float(-float('inf'))
Decimal('-Infinity')
>>> Decimal.from_float(-0.0)
Decimal('-0')

"""
if isinstance(f, (int, long)):        # handle integer inputs
return cls(f)
if _math.isinf(f) or _math.isnan(f):  # raises TypeError if not a float
return cls(repr(f))
if _math.copysign(1.0, f) == 1.0:
sign = 0
else:
sign = 1
n, d = abs(f).as_integer_ratio()
k = d.bit_length() - 1
result = _dec_from_triple(sign, str(n*5**k), -k)
if cls is Decimal:
return result
else:
return cls(result) ```
Example 21
 Project: pyblish-win   Author: pyblish   File: fractions.py    GNU Lesser General Public License v3.0 5 votes
```def from_float(cls, f):
"""Converts a finite float to a rational number, exactly.

Beware that Fraction.from_float(0.3) != Fraction(3, 10).

"""
if isinstance(f, numbers.Integral):
return cls(f)
elif not isinstance(f, float):
raise TypeError("%s.from_float() only takes floats, not %r (%s)" %
(cls.__name__, f, type(f).__name__))
if math.isnan(f) or math.isinf(f):
raise TypeError("Cannot convert %r to %s." % (f, cls.__name__))
return cls(*f.as_integer_ratio()) ```
Example 22
 Project: pyblish-win   Author: pyblish   File: test_float.py    GNU Lesser General Public License v3.0 5 votes
```def test_format_testfile(self):
with open(format_testfile) as testfile:
for line in open(format_testfile):
if line.startswith('--'):
continue
line = line.strip()
if not line:
continue

lhs, rhs = map(str.strip, line.split('->'))
fmt, arg = lhs.split()
arg = float(arg)
self.assertEqual(fmt % arg, rhs)
if not math.isnan(arg) and copysign(1.0, arg) > 0.0:
self.assertEqual(fmt % -arg, '-' + rhs) ```
Example 23
 Project: pyblish-win   Author: pyblish   File: test_float.py    GNU Lesser General Public License v3.0 5 votes
```def identical(self, x, y):
# check that floats x and y are identical, or that both
# are NaNs
if isnan(x) or isnan(y):
if isnan(x) == isnan(y):
return
elif x == y and (x != 0.0 or copysign(1.0, x) == copysign(1.0, y)):
return
self.fail('%r not identical to %r' % (x, y)) ```
Example 24
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testAcos(self):
self.assertRaises(TypeError, math.acos)
self.ftest('acos(-1)', math.acos(-1), math.pi)
self.ftest('acos(0)', math.acos(0), math.pi/2)
self.ftest('acos(1)', math.acos(1), 0)
self.assertRaises(ValueError, math.acos, INF)
self.assertRaises(ValueError, math.acos, NINF)
self.assertTrue(math.isnan(math.acos(NAN))) ```
Example 25
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testAcosh(self):
self.assertRaises(TypeError, math.acosh)
self.ftest('acosh(1)', math.acosh(1), 0)
self.ftest('acosh(2)', math.acosh(2), 1.3169578969248168)
self.assertRaises(ValueError, math.acosh, 0)
self.assertRaises(ValueError, math.acosh, -1)
self.assertEqual(math.acosh(INF), INF)
self.assertRaises(ValueError, math.acosh, NINF)
self.assertTrue(math.isnan(math.acosh(NAN))) ```
Example 26
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testAsin(self):
self.assertRaises(TypeError, math.asin)
self.ftest('asin(-1)', math.asin(-1), -math.pi/2)
self.ftest('asin(0)', math.asin(0), 0)
self.ftest('asin(1)', math.asin(1), math.pi/2)
self.assertRaises(ValueError, math.asin, INF)
self.assertRaises(ValueError, math.asin, NINF)
self.assertTrue(math.isnan(math.asin(NAN))) ```
Example 27
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testAtan(self):
self.assertRaises(TypeError, math.atan)
self.ftest('atan(-1)', math.atan(-1), -math.pi/4)
self.ftest('atan(0)', math.atan(0), 0)
self.ftest('atan(1)', math.atan(1), math.pi/4)
self.ftest('atan(inf)', math.atan(INF), math.pi/2)
self.ftest('atan(-inf)', math.atan(NINF), -math.pi/2)
self.assertTrue(math.isnan(math.atan(NAN))) ```
Example 28
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testAtanh(self):
self.assertRaises(TypeError, math.atan)
self.ftest('atanh(0)', math.atanh(0), 0)
self.ftest('atanh(0.5)', math.atanh(0.5), 0.54930614433405489)
self.ftest('atanh(-0.5)', math.atanh(-0.5), -0.54930614433405489)
self.assertRaises(ValueError, math.atanh, 1)
self.assertRaises(ValueError, math.atanh, -1)
self.assertRaises(ValueError, math.atanh, INF)
self.assertRaises(ValueError, math.atanh, NINF)
self.assertTrue(math.isnan(math.atanh(NAN))) ```
Example 29
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testCeil(self):
self.assertRaises(TypeError, math.ceil)
# These types will be int in py3k.
self.assertEqual(float, type(math.ceil(1)))
self.assertEqual(float, type(math.ceil(1L)))
self.assertEqual(float, type(math.ceil(1.0)))
self.ftest('ceil(0.5)', math.ceil(0.5), 1)
self.ftest('ceil(1.0)', math.ceil(1.0), 1)
self.ftest('ceil(1.5)', math.ceil(1.5), 2)
self.ftest('ceil(-0.5)', math.ceil(-0.5), 0)
self.ftest('ceil(-1.0)', math.ceil(-1.0), -1)
self.ftest('ceil(-1.5)', math.ceil(-1.5), -1)
self.assertEqual(math.ceil(INF), INF)
self.assertEqual(math.ceil(NINF), NINF)
self.assertTrue(math.isnan(math.ceil(NAN)))

class TestCeil(object):
def __float__(self):
return 41.3
class TestNoCeil(object):
pass
self.ftest('ceil(TestCeil())', math.ceil(TestCeil()), 42)
self.assertRaises(TypeError, math.ceil, TestNoCeil())

t = TestNoCeil()
t.__ceil__ = lambda *args: args
self.assertRaises(TypeError, math.ceil, t)
self.assertRaises(TypeError, math.ceil, t, 0) ```
Example 30
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testCopysign(self):
self.assertEqual(math.copysign(1, 42), 1.0)
self.assertEqual(math.copysign(0., 42), 0.0)
self.assertEqual(math.copysign(1., -42), -1.0)
self.assertEqual(math.copysign(3, 0.), 3.0)
self.assertEqual(math.copysign(4., -0.), -4.0)

self.assertRaises(TypeError, math.copysign)
# copysign should let us distinguish signs of zeros
self.assertEqual(math.copysign(1., 0.), 1.)
self.assertEqual(math.copysign(1., -0.), -1.)
self.assertEqual(math.copysign(INF, 0.), INF)
self.assertEqual(math.copysign(INF, -0.), NINF)
self.assertEqual(math.copysign(NINF, 0.), INF)
self.assertEqual(math.copysign(NINF, -0.), NINF)
# and of infinities
self.assertEqual(math.copysign(1., INF), 1.)
self.assertEqual(math.copysign(1., NINF), -1.)
self.assertEqual(math.copysign(INF, INF), INF)
self.assertEqual(math.copysign(INF, NINF), NINF)
self.assertEqual(math.copysign(NINF, INF), INF)
self.assertEqual(math.copysign(NINF, NINF), NINF)
self.assertTrue(math.isnan(math.copysign(NAN, 1.)))
self.assertTrue(math.isnan(math.copysign(NAN, INF)))
self.assertTrue(math.isnan(math.copysign(NAN, NINF)))
self.assertTrue(math.isnan(math.copysign(NAN, NAN)))
# copysign(INF, NAN) may be INF or it may be NINF, since
# we don't know whether the sign bit of NAN is set on any
# given platform.
self.assertTrue(math.isinf(math.copysign(INF, NAN)))
# similarly, copysign(2., NAN) could be 2. or -2.
self.assertEqual(abs(math.copysign(2., NAN)), 2.) ```
Example 31
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testCosh(self):
self.assertRaises(TypeError, math.cosh)
self.ftest('cosh(0)', math.cosh(0), 1)
self.ftest('cosh(2)-2*cosh(1)**2', math.cosh(2)-2*math.cosh(1)**2, -1) # Thanks to Lambert
self.assertEqual(math.cosh(INF), INF)
self.assertEqual(math.cosh(NINF), INF)
self.assertTrue(math.isnan(math.cosh(NAN))) ```
Example 32
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testExp(self):
self.assertRaises(TypeError, math.exp)
self.ftest('exp(-1)', math.exp(-1), 1/math.e)
self.ftest('exp(0)', math.exp(0), 1)
self.ftest('exp(1)', math.exp(1), math.e)
self.assertEqual(math.exp(INF), INF)
self.assertEqual(math.exp(NINF), 0.)
self.assertTrue(math.isnan(math.exp(NAN))) ```
Example 33
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testFloor(self):
self.assertRaises(TypeError, math.floor)
# These types will be int in py3k.
self.assertEqual(float, type(math.floor(1)))
self.assertEqual(float, type(math.floor(1L)))
self.assertEqual(float, type(math.floor(1.0)))
self.ftest('floor(0.5)', math.floor(0.5), 0)
self.ftest('floor(1.0)', math.floor(1.0), 1)
self.ftest('floor(1.5)', math.floor(1.5), 1)
self.ftest('floor(-0.5)', math.floor(-0.5), -1)
self.ftest('floor(-1.0)', math.floor(-1.0), -1)
self.ftest('floor(-1.5)', math.floor(-1.5), -2)
# pow() relies on floor() to check for integers
# This fails on some platforms - so check it here
self.ftest('floor(1.23e167)', math.floor(1.23e167), 1.23e167)
self.ftest('floor(-1.23e167)', math.floor(-1.23e167), -1.23e167)
self.assertEqual(math.ceil(INF), INF)
self.assertEqual(math.ceil(NINF), NINF)
self.assertTrue(math.isnan(math.floor(NAN)))

class TestFloor(object):
def __float__(self):
return 42.3
class TestNoFloor(object):
pass
self.ftest('floor(TestFloor())', math.floor(TestFloor()), 42)
self.assertRaises(TypeError, math.floor, TestNoFloor())

t = TestNoFloor()
t.__floor__ = lambda *args: args
self.assertRaises(TypeError, math.floor, t)
self.assertRaises(TypeError, math.floor, t, 0) ```
Example 34
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testLdexp(self):
self.assertRaises(TypeError, math.ldexp)
self.ftest('ldexp(0,1)', math.ldexp(0,1), 0)
self.ftest('ldexp(1,1)', math.ldexp(1,1), 2)
self.ftest('ldexp(1,-1)', math.ldexp(1,-1), 0.5)
self.ftest('ldexp(-1,1)', math.ldexp(-1,1), -2)
self.assertRaises(OverflowError, math.ldexp, 1., 1000000)
self.assertRaises(OverflowError, math.ldexp, -1., 1000000)
self.assertEqual(math.ldexp(1., -1000000), 0.)
self.assertEqual(math.ldexp(-1., -1000000), -0.)
self.assertEqual(math.ldexp(INF, 30), INF)
self.assertEqual(math.ldexp(NINF, -213), NINF)
self.assertTrue(math.isnan(math.ldexp(NAN, 0)))

# large second argument
for n in [10**5, 10L**5, 10**10, 10L**10, 10**20, 10**40]:
self.assertEqual(math.ldexp(INF, -n), INF)
self.assertEqual(math.ldexp(NINF, -n), NINF)
self.assertEqual(math.ldexp(1., -n), 0.)
self.assertEqual(math.ldexp(-1., -n), -0.)
self.assertEqual(math.ldexp(0., -n), 0.)
self.assertEqual(math.ldexp(-0., -n), -0.)
self.assertTrue(math.isnan(math.ldexp(NAN, -n)))

self.assertRaises(OverflowError, math.ldexp, 1., n)
self.assertRaises(OverflowError, math.ldexp, -1., n)
self.assertEqual(math.ldexp(0., n), 0.)
self.assertEqual(math.ldexp(-0., n), -0.)
self.assertEqual(math.ldexp(INF, n), INF)
self.assertEqual(math.ldexp(NINF, n), NINF)
self.assertTrue(math.isnan(math.ldexp(NAN, n))) ```
Example 35
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testLog(self):
self.assertRaises(TypeError, math.log)
self.ftest('log(1/e)', math.log(1/math.e), -1)
self.ftest('log(1)', math.log(1), 0)
self.ftest('log(e)', math.log(math.e), 1)
self.ftest('log(32,2)', math.log(32,2), 5)
self.ftest('log(10**40, 10)', math.log(10**40, 10), 40)
self.ftest('log(10**40, 10**20)', math.log(10**40, 10**20), 2)
self.assertEqual(math.log(INF), INF)
self.assertRaises(ValueError, math.log, NINF)
self.assertTrue(math.isnan(math.log(NAN)))
# Log values should match for int and long (issue #18739).
for n in range(1, 1000):
self.assertEqual(math.log(n), math.log(long(n))) ```
Example 36
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testLog1p(self):
self.assertRaises(TypeError, math.log1p)
self.ftest('log1p(1/e -1)', math.log1p(1/math.e-1), -1)
self.ftest('log1p(0)', math.log1p(0), 0)
self.ftest('log1p(e-1)', math.log1p(math.e-1), 1)
self.ftest('log1p(1)', math.log1p(1), math.log(2))
self.assertEqual(math.log1p(INF), INF)
self.assertRaises(ValueError, math.log1p, NINF)
self.assertTrue(math.isnan(math.log1p(NAN)))
n= 2**90
self.assertAlmostEqual(math.log1p(n), 62.383246250395075)
self.assertAlmostEqual(math.log1p(n), math.log1p(float(n))) ```
Example 37
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testLog10(self):
self.assertRaises(TypeError, math.log10)
self.ftest('log10(0.1)', math.log10(0.1), -1)
self.ftest('log10(1)', math.log10(1), 0)
self.ftest('log10(10)', math.log10(10), 1)
self.assertEqual(math.log(INF), INF)
self.assertRaises(ValueError, math.log10, NINF)
self.assertTrue(math.isnan(math.log10(NAN)))
# Log values should match for int and long (issue #18739).
for n in range(1, 1000):
self.assertEqual(math.log10(n), math.log10(long(n))) ```
Example 38
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testSinh(self):
self.assertRaises(TypeError, math.sinh)
self.ftest('sinh(0)', math.sinh(0), 0)
self.ftest('sinh(1)**2-cosh(1)**2', math.sinh(1)**2-math.cosh(1)**2, -1)
self.ftest('sinh(1)+sinh(-1)', math.sinh(1)+math.sinh(-1), 0)
self.assertEqual(math.sinh(INF), INF)
self.assertEqual(math.sinh(NINF), NINF)
self.assertTrue(math.isnan(math.sinh(NAN))) ```
Example 39
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testSqrt(self):
self.assertRaises(TypeError, math.sqrt)
self.ftest('sqrt(0)', math.sqrt(0), 0)
self.ftest('sqrt(1)', math.sqrt(1), 1)
self.ftest('sqrt(4)', math.sqrt(4), 2)
self.assertEqual(math.sqrt(INF), INF)
self.assertRaises(ValueError, math.sqrt, NINF)
self.assertTrue(math.isnan(math.sqrt(NAN))) ```
Example 40
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testTan(self):
self.assertRaises(TypeError, math.tan)
self.ftest('tan(0)', math.tan(0), 0)
self.ftest('tan(pi/4)', math.tan(math.pi/4), 1)
self.ftest('tan(-pi/4)', math.tan(-math.pi/4), -1)
try:
self.assertTrue(math.isnan(math.tan(INF)))
self.assertTrue(math.isnan(math.tan(NINF)))
except:
self.assertRaises(ValueError, math.tan, INF)
self.assertRaises(ValueError, math.tan, NINF)
self.assertTrue(math.isnan(math.tan(NAN))) ```
Example 41
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testTanh(self):
self.assertRaises(TypeError, math.tanh)
self.ftest('tanh(0)', math.tanh(0), 0)
self.ftest('tanh(1)+tanh(-1)', math.tanh(1)+math.tanh(-1), 0)
self.ftest('tanh(inf)', math.tanh(INF), 1)
self.ftest('tanh(-inf)', math.tanh(NINF), -1)
self.assertTrue(math.isnan(math.tanh(NAN)))
# check that tanh(-0.) == -0. on IEEE 754 systems
if float.__getformat__("double").startswith("IEEE"):
self.assertEqual(math.tanh(-0.), -0.)
self.assertEqual(math.copysign(1., math.tanh(-0.)),
math.copysign(1., -0.)) ```
Example 42
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 5 votes
```def testIsnan(self):
self.assertTrue(math.isnan(float("nan")))
self.assertTrue(math.isnan(float("inf")* 0.))
self.assertFalse(math.isnan(float("inf")))
self.assertFalse(math.isnan(0.))
self.assertFalse(math.isnan(1.)) ```
Example 43
 Project: pyblish-win   Author: pyblish   File: test_cmath.py    GNU Lesser General Public License v3.0 5 votes
```def test_phase(self):
self.assertAlmostEqual(phase(0), 0.)
self.assertAlmostEqual(phase(1.), 0.)
self.assertAlmostEqual(phase(-1.), pi)
self.assertAlmostEqual(phase(-1.+1E-300j), pi)
self.assertAlmostEqual(phase(-1.-1E-300j), -pi)
self.assertAlmostEqual(phase(1j), pi/2)
self.assertAlmostEqual(phase(-1j), -pi/2)

# zeros
self.assertEqual(phase(complex(0.0, 0.0)), 0.0)
self.assertEqual(phase(complex(0.0, -0.0)), -0.0)
self.assertEqual(phase(complex(-0.0, 0.0)), pi)
self.assertEqual(phase(complex(-0.0, -0.0)), -pi)

# infinities
self.assertAlmostEqual(phase(complex(-INF, -0.0)), -pi)
self.assertAlmostEqual(phase(complex(-INF, -2.3)), -pi)
self.assertAlmostEqual(phase(complex(-INF, -INF)), -0.75*pi)
self.assertAlmostEqual(phase(complex(-2.3, -INF)), -pi/2)
self.assertAlmostEqual(phase(complex(-0.0, -INF)), -pi/2)
self.assertAlmostEqual(phase(complex(0.0, -INF)), -pi/2)
self.assertAlmostEqual(phase(complex(2.3, -INF)), -pi/2)
self.assertAlmostEqual(phase(complex(INF, -INF)), -pi/4)
self.assertEqual(phase(complex(INF, -2.3)), -0.0)
self.assertEqual(phase(complex(INF, -0.0)), -0.0)
self.assertEqual(phase(complex(INF, 0.0)), 0.0)
self.assertEqual(phase(complex(INF, 2.3)), 0.0)
self.assertAlmostEqual(phase(complex(INF, INF)), pi/4)
self.assertAlmostEqual(phase(complex(2.3, INF)), pi/2)
self.assertAlmostEqual(phase(complex(0.0, INF)), pi/2)
self.assertAlmostEqual(phase(complex(-0.0, INF)), pi/2)
self.assertAlmostEqual(phase(complex(-2.3, INF)), pi/2)
self.assertAlmostEqual(phase(complex(-INF, INF)), 0.75*pi)
self.assertAlmostEqual(phase(complex(-INF, 2.3)), pi)
self.assertAlmostEqual(phase(complex(-INF, 0.0)), pi)

# real or imaginary part NaN
for z in complex_nans:
self.assertTrue(math.isnan(phase(z))) ```
Example 44
 Project: pyblish-win   Author: pyblish   File: test_cmath.py    GNU Lesser General Public License v3.0 5 votes
```def test_abs(self):
# zeros
for z in complex_zeros:
self.assertEqual(abs(z), 0.0)

# infinities
for z in complex_infinities:
self.assertEqual(abs(z), INF)

# real or imaginary part NaN
self.assertEqual(abs(complex(NAN, -INF)), INF)
self.assertTrue(math.isnan(abs(complex(NAN, -2.3))))
self.assertTrue(math.isnan(abs(complex(NAN, -0.0))))
self.assertTrue(math.isnan(abs(complex(NAN, 0.0))))
self.assertTrue(math.isnan(abs(complex(NAN, 2.3))))
self.assertEqual(abs(complex(NAN, INF)), INF)
self.assertEqual(abs(complex(-INF, NAN)), INF)
self.assertTrue(math.isnan(abs(complex(-2.3, NAN))))
self.assertTrue(math.isnan(abs(complex(-0.0, NAN))))
self.assertTrue(math.isnan(abs(complex(0.0, NAN))))
self.assertTrue(math.isnan(abs(complex(2.3, NAN))))
self.assertEqual(abs(complex(INF, NAN)), INF)
self.assertTrue(math.isnan(abs(complex(NAN, NAN))))

# result overflows
if float.__getformat__("double").startswith("IEEE"):
self.assertRaises(OverflowError, abs, complex(1.4e308, 1.4e308)) ```
Example 45
 Project: pyblish-win   Author: pyblish   File: test_cmath.py    GNU Lesser General Public License v3.0 5 votes
```def test_isnan(self):
self.assertFalse(cmath.isnan(1))
self.assertFalse(cmath.isnan(1j))
self.assertFalse(cmath.isnan(INF))
self.assertTrue(cmath.isnan(NAN))
self.assertTrue(cmath.isnan(complex(NAN, 0)))
self.assertTrue(cmath.isnan(complex(0, NAN)))
self.assertTrue(cmath.isnan(complex(NAN, NAN)))
self.assertTrue(cmath.isnan(complex(NAN, INF)))
self.assertTrue(cmath.isnan(complex(INF, NAN))) ```
Example 46
 Project: pyblish-win   Author: pyblish   File: test_decimal.py    GNU Lesser General Public License v3.0 5 votes
```def test_nan_to_float(self):
# Test conversions of decimal NANs to float.
# See http://bugs.python.org/issue15544
for s in ('nan', 'nan1234', '-nan', '-nan2468'):
f = float(Decimal(s))
self.assertTrue(math.isnan(f)) ```
Example 47
 Project: pyblish-win   Author: pyblish   File: test_complex.py    GNU Lesser General Public License v3.0 5 votes
```def test_truediv(self):
self.assertAlmostEqual(complex.__truediv__(2+0j, 1+1j), 1-1j)
self.assertRaises(ZeroDivisionError, complex.__truediv__, 1+1j, 0+0j)

for denom_real, denom_imag in [(0, NAN), (NAN, 0), (NAN, NAN)]:
z = complex(0, 0) / complex(denom_real, denom_imag)
self.assertTrue(isnan(z.real))
self.assertTrue(isnan(z.imag)) ```
Example 48
```def _format_value(v):
if isinstance(v, bool):
return 'true' if v else 'false'
if isinstance(v, int) or isinstance(v, long):
return unicode(v)
if isinstance(v, float):
if math.isnan(v) or math.isinf(v):
raise ValueError("{0} is not a valid TOML value".format(v))
else:
return repr(v)
elif isinstance(v, unicode) or isinstance(v, bytes):
return _escape_string(v)
elif isinstance(v, datetime.datetime):
offs = v.utcoffset()
offs = _total_seconds(offs) // 60 if offs is not None else 0

if offs == 0:
suffix = 'Z'
else:
if offs > 0:
suffix = '+'
else:
suffix = '-'
offs = -offs
suffix = '{0}{1:.02}{2:.02}'.format(suffix, offs // 60, offs % 60)

if v.microsecond:
return v.strftime('%Y-%m-%dT%H:%M:%S.%f') + suffix
else:
return v.strftime('%Y-%m-%dT%H:%M:%S') + suffix
elif isinstance(v, list):
return _format_list(v)
else:
raise RuntimeError(v) ```
Example 49
```def is_nan_or_inf(number):
return math.isnan(number) or math.isinf(number) ```
Example 50
```def _compute_eps(self, log_moments, delta):
min_eps = float("inf")
for moment_order, log_moment in log_moments:
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 51
```def _to_np_float64(v):
if math.isnan(v) or math.isinf(v):
return np.inf
return np.float64(v)

######################
# FLOAT64 ARITHMETIC #
###################### ```
Example 52
```def update(self, mean_var, count=1):
if math.isnan(mean_var):
mean_var = 1e6
print('Avgmeter getting Nan!')
self.now = mean_var
self.num += count

self.sum += mean_var * count
self.mean = float(self.sum) / self.num ```
Example 53
 Project: bigquerylayers   Author: smandaric   File: json_format.py    GNU General Public License v3.0 5 votes
```def _FieldToJsonObject(self, field, value):
"""Converts field value according to Proto3 JSON Specification."""
if field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_MESSAGE:
return self._MessageToJsonObject(value)
elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_ENUM:
if self.use_integers_for_enums:
return value
enum_value = field.enum_type.values_by_number.get(value, None)
if enum_value is not None:
return enum_value.name
else:
if field.file.syntax == 'proto3':
return value
raise SerializeToJsonError('Enum field contains an integer value '
'which can not mapped to an enum value.')
elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_STRING:
if field.type == descriptor.FieldDescriptor.TYPE_BYTES:
# Use base64 Data encoding for bytes
return base64.b64encode(value).decode('utf-8')
else:
return value
elif field.cpp_type == descriptor.FieldDescriptor.CPPTYPE_BOOL:
return bool(value)
elif field.cpp_type in _INT64_TYPES:
return str(value)
elif field.cpp_type in _FLOAT_TYPES:
if math.isinf(value):
if value < 0.0:
return _NEG_INFINITY
else:
return _INFINITY
if math.isnan(value):
return _NAN
return value ```
Example 54
 Project: bigquerylayers   Author: smandaric   File: json_format_test.py    GNU General Public License v3.0 5 votes
```def testNanFloat(self):
message = json_format_proto3_pb2.TestMessage()
message.float_value = float('nan')
text = '{\n  "floatValue": "NaN"\n}'
self.assertEqual(json_format.MessageToJson(message), text)
parsed_message = json_format_proto3_pb2.TestMessage()
json_format.Parse(text, parsed_message)
self.assertTrue(math.isnan(parsed_message.float_value)) ```
Example 55
 Project: SpikeyTree   Author: paula-tataru   File: wf.py    GNU General Public License v3.0 5 votes
```def write_data(output, tree, loci, samples):
'''simulate and write data to file'''
f = open(output, 'w')
tree_str = tree.to_str(True, False)
f.write(tree_str)
f.write(';\n')

leaves = list(tree.tree.get_leaves_identifiers())
full_samples = {}
for i,l in enumerate(leaves):
full_samples[l] = samples[i % len(samples)]
f.write('%d ' % full_samples[l])
f.write('\n')
f.write('\t'.join(leaves))
f.write('\n')

# all 0 or all 1 in data
lost = []
fixed = []
for l in leaves:
lost.append('0')
fixed.append('%d' % full_samples[l])
lost = '\t'.join(lost)
fixed = '\t'.join(fixed)

# simulate polymorphic loci
i = 0
while i < loci:
p0 = float('nan')
while math.isnan(p0):
p0 = nprand.beta(tree.shapes[0], tree.shapes[1])
res = sim_tree(tree.tree, p0)
counts = sim_sample(res, leaves, full_samples)
if counts != lost and counts != fixed:
f.write(counts)
f.write('\n')
f.flush()
i += 1
f.close() ```
Example 56
 Project: SpikeyTree   Author: paula-tataru   File: tree.py    GNU General Public License v3.0 5 votes
```def get_lk(self, tree, recalc=True):
self.p0 = tree.p0
self.states = len(self.p0)
self.data = tree.data
# the number of unique sites, plus the fake lost and fixed sites
self.sites = len(self.data[1]) + 2

if recalc:
self.U = {}
# calculate U's for inner nodes
tree.tree.dfs_traverse(self)
# finish off with the root
self.lk = self._calc_U(tree.tree)

# add the probability distribution at the root
self.lk_with_root = np.zeros(self.lk.shape)
for j in xrange(self.states):
self.lk_with_root[:, j] = self.lk[:, j] * tree.root_dist[j]
# polymorphism probability
poly_prob = (1 - np.sum(self.lk_with_root[-1, :])
- np.sum(self.lk_with_root[-2, :]))

logLK = 0
for i in xrange(len(self.data[1])):
s = np.sum(self.lk_with_root[i, :]) / poly_prob
if math.isnan(s) or s < 0:
err_msg = ('Found NaN/negative likelihood at site %d.\nTree: '
'%s\nLikeliood: %s'
% (i, tree.to_str(),
', '.join(map(str, self.lk_with_root[i, :]))))
raise Exception(err_msg)
if s == 0:
return -1e306
# use the multiplicity of the current site
logLK += self.data[1][i] * math.log(s)

return logLK ```
Example 57
```def all_close(s, t, tol=1e-8):
# Ignores inf and nan values...
return all(abs(a - b) < tol for a, b in zip(s, t)
if not isinf(a) and not isinf(b) and
not isnan(a) and not isnan(b)) ```
Example 58
 Project: Parallel.GAMIT   Author: demiangomez   File: pyPPP.py    GNU General Public License v3.0 5 votes
```def get_sigmas(section, kinematic):

if kinematic:

sx = re.findall(r'X\s\(m\)\s+-?\d+\.\d+\s+-?\d+\.\d+\s+(-?\d+\.\d+|[nN]a[nN]|\*+)', section)[0]
sy = re.findall(r'Y\s\(m\)\s+-?\d+\.\d+\s+-?\d+\.\d+\s+(-?\d+\.\d+|[nN]a[nN]|\*+)', section)[0]
sz = re.findall(r'Z\s\(m\)\s+-?\d+\.\d+\s+-?\d+\.\d+\s+(-?\d+\.\d+|[nN]a[nN]|\*+)', section)[0]

if '*' not in sx and '*' not in sy and '*' not in sz:
sx = float(sx)
sy = float(sy)
sz = float(sz)
sxy = 0.0
sxz = 0.0
syz = 0.0
else:
raise pyRunPPPExceptionNaN('One or more sigma is NaN')

else:
sx, sxy, sxz = re.findall(r'X\(m\)\s+(-?\d+\.\d+|[nN]a[nN]|\*+)\s+(-?\d+\.\d+|[nN]a[nN]|\*+)'
r'\s+(-?\d+\.\d+|[nN]a[nN]|\*+)', section)[0]
sy, syz      = re.findall(r'Y\(m\)\s+(-?\d+\.\d+|[nN]a[nN]|\*+)\s+(-?\d+\.\d+|[nN]a[nN]|\*+)', section)[0]
sz           = re.findall(r'Z\(m\)\s+(-?\d+\.\d+|[nN]a[nN]|\*+)', section)[0]

if '*' in sx or '*' in sy or '*' in sz or '*' in sxy or '*' in sxz or '*' in syz:
raise pyRunPPPExceptionNaN('Sigmas are NaN')
else:
sx = float(sx)
sy = float(sy)
sz = float(sz)
sxy = float(sxy)
sxz = float(sxz)
syz = float(syz)

if isnan(sx) or isnan(sy) or isnan(sz) or isnan(sxy) or isnan(sxz) or isnan(syz):
raise pyRunPPPExceptionNaN('Sigmas are NaN')

return sx, sy, sz, sxy, sxz, syz ```
Example 59
```def nan_is_none(v):
import math

try:
if math.isnan(v):
return None
else:
return v
except (ValueError, TypeError):
return v ```
Example 60
```def cql_encode_float(self, val):
"""
Encode floats using repr to preserve precision
"""
if math.isinf(val):
return 'Infinity' if val > 0 else '-Infinity'
elif math.isnan(val):
return 'NaN'
else:
return repr(val) ```
Example 61
```def test_special_float_cql_encoding(self):
"""
Test to insure that Infinity -Infinity and NaN are supported by the python driver.

@since 3.0.0
@jira_ticket PYTHON-282
@expected_result nan, inf and -inf can be inserted and selected correctly.

@test_category data_types
"""
s = self.session

s.execute("""
CREATE TABLE float_cql_encoding (
f float PRIMARY KEY,
d double
)""")
items = (float('nan'), float('inf'), float('-inf'))

def verify_insert_select(ins_statement, sel_statement):
execute_concurrent_with_args(s, ins_statement, ((f, f) for f in items))
for f in items:
row = s.execute(sel_statement, (f,))[0]
if math.isnan(f):
self.assertTrue(math.isnan(row.f))
self.assertTrue(math.isnan(row.d))
else:
self.assertEqual(row.f, f)
self.assertEqual(row.d, f)

# cql encoding
verify_insert_select('INSERT INTO float_cql_encoding (f, d) VALUES (%s, %s)',
'SELECT * FROM float_cql_encoding WHERE f=%s')

s.execute("TRUNCATE float_cql_encoding")

# prepared binding
verify_insert_select(s.prepare('INSERT INTO float_cql_encoding (f, d) VALUES (?, ?)'),
s.prepare('SELECT * FROM float_cql_encoding WHERE f=?')) ```
Example 62
 Project: ml-eeg   Author: pbrusco   File: visualizations.py    GNU General Public License v3.0 5 votes
```def _set_color(val):
if math.isnan(val):
color = "rgba(255, 255, 255, 1)"
elif val < 0.05:
color = "rgba(216, 246, 206, 0.5)"
elif val <= 0.1:
color = "rgba(242, 245, 169, 0.5)"
else:
color = "rgba(245, 169, 169, 0.3)"
return 'background-color: %s;' % color ```
Example 63
```def _get_sanitized_float(self, input_float):
"""Returns a sanitized float for BigQuery.

This method replaces INF and -INF with positive and negative numbers with
huge absolute values, and replaces NaN with None. It returns the same value
for all other values.
"""
if input_float == float('inf'):
return _INF_FLOAT_VALUE
elif input_float == float('-inf'):
return -_INF_FLOAT_VALUE
elif math.isnan(input_float):
return None
else:
return input_float ```
Example 64
```def from_float(cls, f):
"""Converts a float to a decimal number, exactly.

Note that Decimal.from_float(0.1) is not the same as Decimal('0.1').
Since 0.1 is not exactly representable in binary floating point, the
value is stored as the nearest representable value which is
0x1.999999999999ap-4.  The exact equivalent of the value in decimal
is 0.1000000000000000055511151231257827021181583404541015625.

>>> Decimal.from_float(0.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
>>> Decimal.from_float(float('nan'))
Decimal('NaN')
>>> Decimal.from_float(float('inf'))
Decimal('Infinity')
>>> Decimal.from_float(-float('inf'))
Decimal('-Infinity')
>>> Decimal.from_float(-0.0)
Decimal('-0')

"""
if isinstance(f, int):                # handle integer inputs
return cls(f)
if not isinstance(f, float):
raise TypeError("argument must be int or float.")
if _math.isinf(f) or _math.isnan(f):
return cls(repr(f))
if _math.copysign(1.0, f) == 1.0:
sign = 0
else:
sign = 1
n, d = abs(f).as_integer_ratio()
k = d.bit_length() - 1
result = _dec_from_triple(sign, str(n*5**k), -k)
if cls is Decimal:
return result
else:
return cls(result) ```
Example 65
```def isnan(v):
return v != v*1.0 or (v == 1.0 and v == 2.0) ```
Example 66
```def cell_color_map(self, args):
if self.cell_list_filepath:
cell_list_1 = list(set(self.cell_list))
self.cell_label_map = {}
for cell1 in cell_list_1:
self.cell_label_map[cell1] = []
for group_name in self.cell_group_names:
group_seen = []
cells_seen = []

for cell, group in list(set(zip(self.cell_groups_df['SampleID'].tolist(), self.cell_groups_df[group_name].tolist()))):
if cell not in cells_seen:
try:
if math.isnan(float(group)):
group = 'None'
except ValueError:
pass
self.cell_label_map[cell].append((self.color_dict_cells[str(group)][0] , self.color_dict_cells[str(group)][1] , group))
cells_seen.append(cell)
non_group_cells = [c for c in cell_list_1 if c not in cells_seen]
if non_group_cells != []:
for cell in non_group_cells:
group = 'None'
self.cell_label_map[cell].append(('w','8',str(group)))
else:
self.cell_label_map = False

#takes cell groups and creates dictionay 'label_map' that has attached color and marker ```
Example 67
```def gene_list_map(args, gene_list_file, gene_list, color_dict, exclude_list = []):
gene_df1 = pd.read_csv(open(os.path.join(os.path.dirname(args.filepath), gene_list_file),'rU'), sep=None, engine='python')
if exclude_list != []:
gene_df1 = gene_df1.ix[~gene_df1['GeneID'].isin(exclude_list)]
gene_df = gene_df1.copy()
gene_list_1 = [g for g in list(set(gene_df['GeneID'].tolist())) if g in gene_list]
if len(gene_df['GeneID']) == len(gene_df['GroupID']):
gene_label_map = {}
group_pos = 0
group_seen = ['xyz' for i in range(len(set(gene_df['GroupID'].tolist())))]
genes_seen = []
for gene, group in zip(gene_df['GeneID'].tolist(), gene_df['GroupID'].tolist()):
#if no GroupIDs are provided replace withe empty strings
try:
if math.isnan(float(group)):
group = ' '
except ValueError:
pass
if gene not in genes_seen:
if str(group) in group_seen:
pos = group_seen.index(str(group))
else:
group_seen[group_pos] = str(group)
pos = group_pos
group_pos += 1
gene_label_map[gene] = (color_dict[str(group)][0],color_dict[str(group)][1],str(group))
genes_seen.append(gene)
non_group_genes = [g for g in gene_list_1 if g not in genes_seen]
if non_group_genes != []:
all_color_list = list(colors.cnames.keys())
markers = ['o', 'v','D','*','x','h', 's','p','8','^','>','<', 'd','o', 'v','D','*','x','h', 's','p','8','^','>','<', 'd']
color_list = ['b', 'm', 'r', 'c', 'g', 'orange', 'darkslateblue']+all_color_list
for cell in non_group_genes:
gene_label_map[gene] = (color_list[group_pos+1],markers[group_pos+1],'No_ID')
else:
gene_label_map = False
return gene_list_1, gene_label_map

#this script calls qgraph R package using rpy2, for gene or cell qgraph gene or cell groups must be provided (either or both) ```
Example 68
```def is_missing(x):
return math.isnan(x) or math.isinf(x) or x is None ```
Example 69
```def sum(S):
"""
Return the sum of array elements treating missing (NaN) as zero.

To match JMP's behavior, check if all elements are missing in
which case missing is returned.
"""
if np.all(np.isnan(S)):
return np.nan
return np.nansum(S) ```
Example 70
 Project: razzy-spinner   Author: rafasashi   File: util.py    GNU General Public License v3.0 5 votes
```def check(self, classifier, train_toks):
cutoffs = self.cutoffs
self.iter += 1
if 'max_iter' in cutoffs and self.iter >= cutoffs['max_iter']:
return True # iteration cutoff.

new_ll = nltk.classify.util.log_likelihood(classifier, train_toks)
if math.isnan(new_ll):
return True

if 'min_ll' in cutoffs or 'min_lldelta' in cutoffs:
if 'min_ll' in cutoffs and new_ll >= cutoffs['min_ll']:
return True # log likelihood cutoff
if ('min_lldelta' in cutoffs and self.ll and
((new_ll - self.ll) <= abs(cutoffs['min_lldelta']))):
return True # log likelihood delta cutoff
self.ll = new_ll

if 'max_acc' in cutoffs or 'min_accdelta' in cutoffs:
new_acc = nltk.classify.util.log_likelihood(
classifier, train_toks)
if 'max_acc' in cutoffs and new_acc >= cutoffs['max_acc']:
return True # log likelihood cutoff
if ('min_accdelta' in cutoffs and self.acc and
((new_acc - self.acc) <= abs(cutoffs['min_accdelta']))):
return True # log likelihood delta cutoff
self.acc = new_acc

return False # no cutoff reached.

######################################################################
#{ Demos
###################################################################### ```
Example 71
 Project: EarlyWarning   Author: wjlei1990   File: utils.py    GNU General Public License v3.0 5 votes
```def _isnan(v):
if (isinstance(v, float) or isinstance(v, int)) and math.isnan(v):
return True
else:
return False ```
Example 72
```def _ingest_summary(self):
# get date parameters.
yr = self._date[:4]
mn = self._date[4:6]
dy = self._date[6:]

self._logger.info("Getting ingest summary data for the day")

ingest_summary_cols = ["date","total"]
result_rows = []
df_filtered =  pd.DataFrame()

# get ingest summary.

SELECT tryear, trmonth, trday, trhour, trminute, COUNT(*) as total
FROM {0}.{1} WHERE y={2} AND m={3} AND d={4}
AND unix_tstamp IS NOT NULL
AND sip IS NOT NULL
AND sport IS NOT NULL
AND dip IS NOT NULL
AND dport IS NOT NULL
AND ibyt IS NOT NULL
AND ipkt IS NOT NULL
AND tryear={2}
AND cast(treceived as timestamp) IS NOT NULL
GROUP BY tryear, trmonth, trday, trhour, trminute;
""").format(self._db,self._table_name, yr, mn, dy)

if results:
df_results = as_pandas(results)

#Forms a new dataframe splitting the minutes from the time column
df_new = pd.DataFrame([["{0}-{1}-{2} {3}:{4}".format(val['tryear'],val['trmonth'],val['trday'], val['trhour'], val['trminute']), int(val['total']) if not math.isnan(val['total']) else 0 ] for key,val in df_results.iterrows()],columns = ingest_summary_cols)
value_string = ''
#Groups the data by minute

sf = df_new.groupby(by=['date'])['total'].sum()
df_per_min = pd.DataFrame({'date':sf.index, 'total':sf.values})

df_final = df_filtered.append(df_per_min, ignore_index=True).to_records(False,False)
if len(df_final) > 0:
query_to_insert=("""
INSERT INTO {0}.flow_ingest_summary PARTITION (y={1}, m={2}, d={3}) VALUES {4};
""").format(self._db, yr, mn, dy, tuple(df_final))

impala.execute_query(query_to_insert)

else:
self._logger.info("No data found for the ingest summary") ```
Example 73
```def _ingest_summary(self):
# get date parameters.
yr = self._date[:4]
mn = self._date[4:6]
dy = self._date[6:]

self._logger.info("Getting ingest summary data for the day")

ingest_summary_cols = ["date","total"]
result_rows = []
df_filtered =  pd.DataFrame()

# get ingest summary.

SELECT p_date, p_time, COUNT(*) as total
FROM {0}.{1} WHERE y='{2}' AND m='{3}' AND d='{4}'
AND p_date IS NOT NULL AND p_time IS NOT NULL
AND clientip IS NOT NULL AND p_time != ''
AND host IS NOT NULL AND fulluri IS NOT NULL
GROUP BY p_date, p_time;
""").format(self._db,self._table_name, yr, mn, dy)

if results:
df_results = as_pandas(results)
#Forms a new dataframe splitting the minutes from the time column/
df_new = pd.DataFrame([["{0} {1}:{2}".format(val['p_date'], val['p_time'].split(":")[0].zfill(2), val['p_time'].split(":")[1].zfill(2)), int(val['total']) if not math.isnan(val['total']) else 0 ] for key,val in df_results.iterrows()],columns = ingest_summary_cols)
value_string = ''
#Groups the data by minute
sf = df_new.groupby(by=['date'])['total'].sum()
df_per_min = pd.DataFrame({'date':sf.index, 'total':sf.values})

df_final = df_filtered.append(df_per_min, ignore_index=True).to_records(False,False)
if len(df_final) > 0:
query_to_insert=("""
INSERT INTO {0}.proxy_ingest_summary PARTITION (y={1}, m={2}, d={3}) VALUES {4};
""").format(self._db, yr, mn, dy, tuple(df_final))

impala.execute_query(query_to_insert)

else:
self._logger.info("No data found for the ingest summary") ```
Example 74
 Project: pyblish-win   Author: pyblish   File: test_math.py    GNU Lesser General Public License v3.0 4 votes
```def testAtan2(self):
self.assertRaises(TypeError, math.atan2)
self.ftest('atan2(-1, 0)', math.atan2(-1, 0), -math.pi/2)
self.ftest('atan2(-1, 1)', math.atan2(-1, 1), -math.pi/4)
self.ftest('atan2(0, 1)', math.atan2(0, 1), 0)
self.ftest('atan2(1, 1)', math.atan2(1, 1), math.pi/4)
self.ftest('atan2(1, 0)', math.atan2(1, 0), math.pi/2)

# math.atan2(0, x)
self.ftest('atan2(0., -inf)', math.atan2(0., NINF), math.pi)
self.ftest('atan2(0., -2.3)', math.atan2(0., -2.3), math.pi)
self.ftest('atan2(0., -0.)', math.atan2(0., -0.), math.pi)
self.assertEqual(math.atan2(0., 0.), 0.)
self.assertEqual(math.atan2(0., 2.3), 0.)
self.assertEqual(math.atan2(0., INF), 0.)
self.assertTrue(math.isnan(math.atan2(0., NAN)))
# math.atan2(-0, x)
self.ftest('atan2(-0., -inf)', math.atan2(-0., NINF), -math.pi)
self.ftest('atan2(-0., -2.3)', math.atan2(-0., -2.3), -math.pi)
self.ftest('atan2(-0., -0.)', math.atan2(-0., -0.), -math.pi)
self.assertEqual(math.atan2(-0., 0.), -0.)
self.assertEqual(math.atan2(-0., 2.3), -0.)
self.assertEqual(math.atan2(-0., INF), -0.)
self.assertTrue(math.isnan(math.atan2(-0., NAN)))
# math.atan2(INF, x)
self.ftest('atan2(inf, -inf)', math.atan2(INF, NINF), math.pi*3/4)
self.ftest('atan2(inf, -2.3)', math.atan2(INF, -2.3), math.pi/2)
self.ftest('atan2(inf, -0.)', math.atan2(INF, -0.0), math.pi/2)
self.ftest('atan2(inf, 0.)', math.atan2(INF, 0.0), math.pi/2)
self.ftest('atan2(inf, 2.3)', math.atan2(INF, 2.3), math.pi/2)
self.ftest('atan2(inf, inf)', math.atan2(INF, INF), math.pi/4)
self.assertTrue(math.isnan(math.atan2(INF, NAN)))
# math.atan2(NINF, x)
self.ftest('atan2(-inf, -inf)', math.atan2(NINF, NINF), -math.pi*3/4)
self.ftest('atan2(-inf, -2.3)', math.atan2(NINF, -2.3), -math.pi/2)
self.ftest('atan2(-inf, -0.)', math.atan2(NINF, -0.0), -math.pi/2)
self.ftest('atan2(-inf, 0.)', math.atan2(NINF, 0.0), -math.pi/2)
self.ftest('atan2(-inf, 2.3)', math.atan2(NINF, 2.3), -math.pi/2)
self.ftest('atan2(-inf, inf)', math.atan2(NINF, INF), -math.pi/4)
self.assertTrue(math.isnan(math.atan2(NINF, NAN)))
# math.atan2(+finite, x)
self.ftest('atan2(2.3, -inf)', math.atan2(2.3, NINF), math.pi)
self.ftest('atan2(2.3, -0.)', math.atan2(2.3, -0.), math.pi/2)
self.ftest('atan2(2.3, 0.)', math.atan2(2.3, 0.), math.pi/2)
self.assertEqual(math.atan2(2.3, INF), 0.)
self.assertTrue(math.isnan(math.atan2(2.3, NAN)))
# math.atan2(-finite, x)
self.ftest('atan2(-2.3, -inf)', math.atan2(-2.3, NINF), -math.pi)
self.ftest('atan2(-2.3, -0.)', math.atan2(-2.3, -0.), -math.pi/2)
self.ftest('atan2(-2.3, 0.)', math.atan2(-2.3, 0.), -math.pi/2)
self.assertEqual(math.atan2(-2.3, INF), -0.)
self.assertTrue(math.isnan(math.atan2(-2.3, NAN)))
# math.atan2(NAN, x)
self.assertTrue(math.isnan(math.atan2(NAN, NINF)))
self.assertTrue(math.isnan(math.atan2(NAN, -2.3)))
self.assertTrue(math.isnan(math.atan2(NAN, -0.)))
self.assertTrue(math.isnan(math.atan2(NAN, 0.)))
self.assertTrue(math.isnan(math.atan2(NAN, 2.3)))
self.assertTrue(math.isnan(math.atan2(NAN, INF)))
self.assertTrue(math.isnan(math.atan2(NAN, NAN))) ```
Example 75
 Project: pyblish-win   Author: pyblish   File: test_cmath.py    GNU Lesser General Public License v3.0 4 votes
```def rAssertAlmostEqual(self, a, b, rel_err = 2e-15, abs_err = 5e-323,
msg=None):
"""Fail if the two floating-point numbers are not almost equal.

Determine whether floating-point values a and b are equal to within
a (small) rounding error.  The default values for rel_err and
abs_err are chosen to be suitable for platforms where a float is
represented by an IEEE 754 double.  They allow an error of between
9 and 19 ulps.
"""

# special values testing
if math.isnan(a):
if math.isnan(b):
return
self.fail(msg or '{!r} should be nan'.format(b))

if math.isinf(a):
if a == b:
return
self.fail(msg or 'finite result where infinity expected: '
'expected {!r}, got {!r}'.format(a, b))

# if both a and b are zero, check whether they have the same sign
# (in theory there are examples where it would be legitimate for a
# and b to have opposite signs; in practice these hardly ever
# occur).
if not a and not b:
if math.copysign(1., a) != math.copysign(1., b):
self.fail(msg or 'zero has wrong sign: expected {!r}, '
'got {!r}'.format(a, b))

# if a-b overflows, or b is infinite, return False.  Again, in
# theory there are examples where a is within a few ulps of the
# max representable float, and then b could legitimately be
# infinite.  In practice these examples are rare.
try:
absolute_error = abs(b-a)
except OverflowError:
pass
else:
# test passes if either the absolute error or the relative
# error is sufficiently small.  The defaults amount to an
# error of between 9 ulps and 19 ulps on an IEEE-754 compliant
# machine.
if absolute_error <= max(abs_err, rel_err * abs(a)):
return
self.fail(msg or
'{!r} and {!r} are not sufficiently close'.format(a, b)) ```
Example 76
 Project: smartformat   Author: what-studio   File: local.py    BSD 3-Clause "New" or "Revised" License 4 votes
```def format_field_by_match(self, value, match):
"""Formats a field by a Regex match of the format spec pattern."""
groups = match.groups()
fill, align, sign, sharp, zero, width, comma, prec, type_ = groups
if not comma and not prec and type_ not in list('fF%'):
return None
if math.isnan(value) or math.isinf(value):
return None
locale = self.numeric_locale
# Format number value.
prefix = get_prefix(sign)
if type_ == 'd':
if prec is not None:
raise ValueError('precision not allowed in '
'integer format specifier')
string = format_number(value, 0, prefix, locale)
elif type_ in 'fF%':
format_ = format_percent if type_ == '%' else format_number
string = format_(value, int(prec or DEFAULT_PREC), prefix, locale)
else:
# Don't handle otherwise.
return None
if not comma:
# Formatted number always contains group symbols.
# Remove the symbols if not required.
string = remove_group_symbols(string, locale)
if not (fill or align or zero or width):
return string
# Fix a layout.
spec = ''.join([fill or u'', align or u'>',
zero or u'', width or u''])
return format(string, spec)

# f = LocalFormatter('hi_IN')
# print(f.format(u'{0:^020,.5f}', 123456789.123456789))
# print(str.format(u'{0:^020,.5f}', 123456789.123456789))
# print(f.format(u'{0:^+020,.5f}', 123456789.123456789))
# print(str.format(u'{0:^+020,.5f}', 123456789.123456789))
# print(f.format(u'{0:^010,.5f}', float('inf')))
# print(str.format(u'{0:^010,.5f}', float('inf')))
# print(f.format(u'{0:.10%}', 123456))
# print(f.format(u'{0:,.10%}', 123456)) ```
Example 77
 Project: xia2   Author: xia2   File: CommonScaler.py    BSD 3-Clause "New" or "Revised" License 4 votes
```def _scale_finish_chunk_3_truncate(self):
for wavelength in self._scalr_scaled_refl_files:
hklin = self._scalr_scaled_refl_files[wavelength]

truncate = self._factory.Truncate()
truncate.set_hklin(hklin)

if self.get_scaler_anomalous():
truncate.set_anomalous(True)
else:
truncate.set_anomalous(False)

FileHandler.record_log_file(
"%s %s %s truncate"
% (self._scalr_pname, self._scalr_xname, wavelength),
truncate.get_log_file(),
)

hklout = os.path.join(
self.get_working_directory(), "%s_truncated.mtz" % wavelength
)

truncate.set_hklout(hklout)
truncate.truncate()

xmlout = truncate.get_xmlout()
if xmlout is not None:
FileHandler.record_xml_file(
"%s %s %s truncate"
% (self._scalr_pname, self._scalr_xname, wavelength),
xmlout,
)

Debug.write(
"%d absent reflections in %s removed"
% (truncate.get_nabsent(), wavelength)
)

b_factor = truncate.get_b_factor()
if math.isnan(b_factor):
b_factor = None

# record the b factor somewhere (hopefully) useful...

self._scalr_statistics[(self._scalr_pname, self._scalr_xname, wavelength)][
"Wilson B factor"
] = [b_factor]

# and record the reflection file..
self._scalr_scaled_refl_files[wavelength] = hklout ```
Example 78
```def gene_color_map(self, args):

if self.gene_list_filepath:
gene_df1 = pd.read_table(open(os.path.join(os.path.dirname(args.filepath), self.gene_list_filepath),'rU'), sep='\s+', engine='python')
if self.exclude_list != []:
gene_df = gene_df1.ix[~gene_df1['GeneID'].isin(self.exclude_list)]
else:
gene_df = gene_df1.copy()
gene_list_1 = [g for g in list(set(gene_df['GeneID'].tolist())) if g in self.gene_list]
if len(gene_df['GeneID']) == len(gene_df['GroupID']):
self.gene_label_map ={}
group_pos = 0
group_seen = ['xyz' for i in range(len(set(gene_df['GroupID'].tolist())))]
genes_seen = []
for gene, group in zip(gene_df['GeneID'].tolist(), gene_df['GroupID'].tolist()):
#if no GroupIDs are provided replace withe empty strings
try:
if math.isnan(float(group)):
group = ' '
except ValueError:
pass
if gene not in genes_seen:
if str(group) in group_seen:
pos = group_seen.index(str(group))
else:
group_seen[group_pos] = str(group)
pos = group_pos
group_pos += 1
try:
self.gene_label_map[gene] = (self.color_dict_genes[str(group)][0],self.color_dict_genes[str(group)][1],str(group))
except KeyError:
pass

genes_seen.append(gene)
non_group_genes = [g for g in gene_list_1 if g not in genes_seen]
if non_group_genes != []:
for cell in non_group_genes:
self.gene_label_map[gene] = (self.color_list[group_pos+1],self.markers[group_pos+1],'No_ID')
else:
self.gene_label_map = False
else:
self.gene_label_map = False ```
Example 79
```def from_float_26(f):
"""Converts a float to a decimal number, exactly.

Note that Decimal.from_float(0.1) is not the same as Decimal('0.1').
Since 0.1 is not exactly representable in binary floating point, the
value is stored as the nearest representable value which is
0x1.999999999999ap-4.  The exact equivalent of the value in decimal
is 0.1000000000000000055511151231257827021181583404541015625.

>>> Decimal.from_float(0.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
>>> Decimal.from_float(float('nan'))
Decimal('NaN')
>>> Decimal.from_float(float('inf'))
Decimal('Infinity')
>>> Decimal.from_float(-float('inf'))
Decimal('-Infinity')
>>> Decimal.from_float(-0.0)
Decimal('-0')

"""
import math as _math
from decimal import _dec_from_triple    # only available on Py2.6 and Py2.7 (not 3.3)

if isinstance(f, (int, long)):        # handle integer inputs
return Decimal(f)
if _math.isinf(f) or _math.isnan(f):  # raises TypeError if not a float
return Decimal(repr(f))
if _math.copysign(1.0, f) == 1.0:
sign = 0
else:
sign = 1
n, d = abs(f).as_integer_ratio()
# int.bit_length() method doesn't exist on Py2.6:
def bit_length(d):
if d != 0:
return len(bin(abs(d))) - 2
else:
return 0
k = bit_length(d) - 1
result = _dec_from_triple(sign, str(n*5**k), -k)
return result ```
Example 80
 Project: kivy-smoothie-host   Author: wolfmanjm   File: extruder_widget.py    GNU General Public License v3.0 4 votes
```def update_temp(self, temperatures):
''' called to update the temperature display'''
if self.temp_changed:
# This allows the setpoint to update on smoothie before using it to turn the heater on/off again
self.temp_changed = False
return

for type in temperatures:
temp, setpoint = temperatures[type]
self.ids.graph_view.update_temperature(type, temp, setpoint)

if type == 'bed':
if math.isinf(temp):
self.bed_dg.value = float('inf')
continue
self.bed_dg.value = temp

if not math.isnan(setpoint):
if setpoint > 0:
self.ids.set_bed_temp.text = str(setpoint)
self.bed_dg.setpoint_value = setpoint
else:
self.bed_dg.setpoint_value = float('nan')
if self.bed_switch.active:
self.bed_switch.active = False

elif type == 'hotend0' or type == 'hotend1':
if (self.ids.tool_t0.state == 'down' and type == 'hotend0') or (self.ids.tool_t1.state == 'down' and type == 'hotend1'):
if math.isinf(temp):
self.hotend_dg.value = float('inf')
continue
self.hotend_dg.value = temp

if not math.isnan(setpoint):
if setpoint > 0:
self.ids.set_hotend_temp.text = str(setpoint)
self.hotend_dg.setpoint_value = setpoint
else:
self.hotend_dg.setpoint_value = float('nan')
if self.hotend_switch.active:
self.hotend_switch.active = False
else:
self.hotend_dg.value = float('inf')

else:
Logger.error('Extruder: unknown temp type - ' + type) ```