Python math 模块，isnan() 实例源码
我们从Python开源项目中，提取了以下49个代码示例，用于说明如何使用math.isnan()。
def do_adfuller(path, srv, p_values):
filename = os.path.join(path, srv["filename"])
df = load_timeseries(filename, srv)
columns = []
for c in df.columns:
if (not df[c].isnull().all()) and df[c].var() != 0:
columns.append(c)
df = df[columns]
if len(columns) == 0: return []
for i, col in enumerate(df.columns):
serie = df[col].dropna()
if is_monotonic(serie):
serie = serie.diff()[1:]
for reg in p_values:
v = adfuller(serie, regression=reg)[1]
if math.isnan(v): # uncertain
p_values[reg].append(-0.1)
else:
p_values[reg].append(v)
return p_values
def draw(path, srv):
filename = os.path.join(path, srv["preprocessed_filename"])
df = pd.read_csv(filename, sep="\t", index_col='time', parse_dates=True)
bins = defaultdict(list)
for i, col in enumerate(df.columns):
serie = df[col].dropna()
if pd.algos.is_monotonic_float64(serie.values, False)[0]:
serie = serie.diff()[1:]
p_value = adfuller(serie, autolag='AIC')[1]
if math.isnan(p_value): continue
nearest = 0.05 * round(p_value/0.05)
bins[nearest].append(serie)
for bin, members in bins.items():
series = [serie.name for serie in members]
if len(members) <= 10:
columns = series
else:
columns = random.sample(series, 10)
subset = df[columns]
name = "%s_adf_confidence_%.2f.png" % (srv["name"], bin)
print(name)
axes = subset.plot(subplots=True)
plt.savefig(os.path.join(path, name))
plt.close("all")
def validate(self, val):
if not isinstance(val, numbers.Real):
raise ValidationError('expected real number, got %s' %
generic_type_name(val))
if not isinstance(val, float):
# This checks for the case where a number is passed in with a
# magnitude larger than supported by float64.
try:
val = float(val)
except OverflowError:
raise ValidationError('too large for float')
if math.isnan(val) or math.isinf(val):
raise ValidationError('%f values are not supported' % val)
if self.minimum is not None and val < self.minimum:
raise ValidationError('%f is not greater than %f' %
(val, self.minimum))
if self.maximum is not None and val > self.maximum:
raise ValidationError('%f is not less than %f' %
(val, self.maximum))
return val
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
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
def validate(self, val):
if not isinstance(val, numbers.Real):
raise ValidationError('expected real number, got %s' %
generic_type_name(val))
if not isinstance(val, float):
# This checks for the case where a number is passed in with a
# magnitude larger than supported by float64.
try:
val = float(val)
except OverflowError:
raise ValidationError('too large for float')
if math.isnan(val) or math.isinf(val):
raise ValidationError('%f values are not supported' % val)
if self.minimum is not None and val < self.minimum:
raise ValidationError('%f is not greater than %f' %
(val, self.minimum))
if self.maximum is not None and val > self.maximum:
raise ValidationError('%f is not less than %f' %
(val, self.maximum))
return val
def _modbusRead(self, key):
if self.PM_cacheEnabled is False:
# W/O cache
val = self.mb.readRegistersAndDecode(self.modbusmap[key][0],self.modbusmap[key][1],self.modbusmap[key][2])
else:
# with cache
val = self.mb.cachedRead(self.modbusmap[key][0], self.modbusmap[key][1], self.modbusmap[key][2])
log.debug('"%s" Modbus: (%s,%s,%s) = %s' % (key, self.modbusmap[key][0],
self.modbusmap[key][1], self.modbusmap[key][2], val))
if self.modbusmap[key][2].startswith("float"):
try:
if math.isnan(val):
log.debug("NaN regs %s => 0" % self.modbusmap[key][0])
val = 0
except TypeError:
val = 0
return val
def test_nan(self):
output = convert(
'table',
{
'format': 'csv',
'url': 'file://' + os.path.join('data', 'RadiomicsData.csv')
},
{'format': 'rows.json'}
)
data = json.loads(output['data'])
self.assertEqual(len(data['fields']), 454)
self.assertEqual(data['fields'][:3], [
'GLCM_autocorr', 'GLCM_clusProm', 'GLCM_clusShade'
])
self.assertEqual(len(data['rows']), 99)
for row in data['rows']:
for field in row:
if isinstance(row[field], float):
self.assertFalse(math.isnan(row[field]))
self.assertFalse(math.isinf(row[field]))
def csv_to_rows(input):
reader = get_csv_reader(input)
rows = [d for d in reader]
fields = reader.fieldnames
output = {'fields': fields, 'rows': rows}
# Attempt numeric conversion
for row in output['rows']:
for col in row:
try:
row[col] = int(row[col])
except Exception:
try:
orig = row[col]
row[col] = float(row[col])
# Disallow NaN, Inf, -Inf since this does not
# pass through JSON converters cleanly
if math.isnan(row[col]) or math.isinf(row[col]):
row[col] = orig
except Exception:
pass
return output
def update_qz(self, left = None, right = None):
if left == None:
left = 0
right = self.lc.n
for index in range(left, right):
#if index % 100 == 0:
# print index
# sys.stdout.flush()
qz_1 = np.log(self.theta)
qz_0 = np.log(1 - self.theta)
for (label, worker) in zip(*self.lc.crowd_labels[index]):
if label >=0 and worker in self.quv:
qz_1 += expectation_z(self.quv[worker][0], self.quv[worker][1], label)
qz_0 += expectation_z(self.quv[worker][2], self.quv[worker][3], label)
qz_1 = np.exp(qz_1)
qz_0 = np.exp(qz_0)
temp = qz_1 * 1.0 / (qz_0 + qz_1)
if not math.isnan(temp):
self.total_changes += np.abs(self.qz[index] - temp)
self.qz[index] = temp
def add(self, t, data, mindt):
# update previous timestamps based on downtime
if self.points and math.isnan(self.points[0][1]):
dt = time.time() - t - self.timeoff
self.timeoff = False
for i in range(len(self.points)):
point = self.points[i]
self.points[i] = point[0]-dt, point[1]
if not self.timeoff or self.timeoff < time.time() - t or self.timeoff > time.time() - t + 1:
self.timeoff = time.time() - t
elif self.points and t-self.points[0][0]<mindt:
return False
self.points.insert(0, (t, data))
return True
def tracevertexes(self, time, plot, gldrawtype):
# remove datapoints after the first one that is off the screen
for i in range(len(self.points)):
if self.points[i][0] < time - plot.disptime:
self.points = self.points[:i+1]
break
glBegin(gldrawtype)
for point in self.points:
if math.isnan(point[1]):
glEnd()
glBegin(gldrawtype)
else:
y = point[1] - self.offset
if self.directional:
if y >= 180:
y -= 360
elif y < - 180:
y += 360
glVertex2d(point[0]-time, y)
glEnd()
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
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
def test_floating_voint_ranges(self):
arr = np.array([[[0.0, 0.0, 0.0, 0.0],
[1.0, 1.0, 1.0, 1.0],
[1.5, 1.5, 1.5, 1.5],
[2.0, 2.0, 2.0, 2.0]]], dtype=float)
tile = Tile(arr, 'FLOAT', float('nan'))
rdd = BaseTestClass.pysc.parallelize([(self.projected_extent, tile)])
raster_rdd = RasterLayer.from_numpy_rdd(LayerType.SPATIAL, rdd)
value_map = {2.0: 5.0}
result = raster_rdd.reclassify(value_map, float,
ClassificationStrategy.LESS_THAN).to_numpy_rdd().first()[1].cells
expected = np.array([[[5.0, 5.0, 5.0, 5.0],
[5.0, 5.0, 5.0, 5.0],
[5.0, 5.0, 5.0, 5.0]]], dtype=float)
self.assertTrue((result[0, 2, ] == expected).all())
for x in result[0, 3, ]:
self.assertTrue(math.isnan(x))
def main(args):
num, den = args
try:
num, den = float(num), float(den)
except ValueError as e:
logging.error('Invalid input')
return INVALID_INPUT
if den == 0:
# this is a run-time error but not a type error
# can be considered a warning or an error based on use case
# written here as mere warning.
logging.warn('Invalid denominator input!')
return DIV_BY_ZERO_EXIT
if math.isnan(num) or math.isnan(den):
return INVALID_INPUT_NAN
if math.isinf(num) or math.isinf(den):
return INVALID_INPUT_INF
print('Answer: ' + str(num / den))
return 0
def process(self, **kwargs):
"""Process module."""
self._times = kwargs[self.key('dense_times')]
self._alpha = kwargs[self.key('alpha')]
self._beta = kwargs[self.key('beta')]
self._t_peak = kwargs[self.key('tpeak')]
self._lum_scale = kwargs[self.key('lumscale')]
self._rest_t_explosion = kwargs[self.key('resttexplosion')]
ts = [
np.inf
if self._rest_t_explosion > x else (x - self._rest_t_explosion)
for x in self._times
]
luminosities = [
self._lum_scale * (1.0 - np.exp(-t / self._t_peak)) **
self._alpha * (t / self._t_peak) ** (-self._beta) for t in ts
]
luminosities = [0.0 if isnan(x) else x for x in luminosities]
return {self.dense_key('luminosities'): luminosities}
def process(self, **kwargs):
"""Process module."""
self._times = kwargs[self.key('dense_times')]
self._mnickel = kwargs[self.key('fnickel')] * kwargs[
self.key('mejecta')]
self._rest_t_explosion = kwargs[self.key('resttexplosion')]
# From 1994ApJS...92..527N
ts = [
np.inf
if self._rest_t_explosion > x else (x - self._rest_t_explosion)
for x in self._times
]
luminosities = [
self._mnickel * (self.NI56_LUM * np.exp(-t / self.NI56_LIFE) +
self.CO56_LUM * np.exp(-t / self.CO56_LIFE))
for t in ts
]
luminosities = [0.0 if isnan(x) else x for x in luminosities]
return {self.dense_key('luminosities'): luminosities}
def calFinalResult(self, testSetNum):
self.loadResultFiles(testSetNum)
res = []
for key, value in self.actualDict.iteritems():
actual = value
if actual == 0:
print "record {} is 0, not included in final calculation".format(key)
continue
prediction = self.predictonDict[key]
temp = (actual - prediction)/float(actual)
if math.isnan(temp):
print temp
res.append(abs(temp))
res = np.array(res)
pd.DataFrame(res).to_csv('result.csv')
print "final result: {}".format(res.mean())
return np.mean(res)
def def_itemgetter(attr, default=0, _type=None):
# like operator.itemgetter but fills in missing keys with a default value
def keyfunc(item):
value = item.get(attr, default)
casted = cast(value, _type) if _type else value
try:
is_nan = isnan(casted)
except TypeError:
is_nan = False
return default if is_nan else casted
return keyfunc
# TODO: move this to meza.process.group
def test_iter_discrete_traces_nan(enum_discrete, trace_graph):
pyro.clear_param_store()
def model():
p = Variable(torch.Tensor([0.0, 0.5, 1.0]))
pyro.sample("z", dist.Bernoulli(p))
def guide():
p = pyro.param("p", Variable(torch.Tensor([0.0, 0.5, 1.0]), requires_grad=True))
pyro.sample("z", dist.Bernoulli(p))
Elbo = TraceGraph_ELBO if trace_graph else Trace_ELBO
elbo = Elbo(enum_discrete=enum_discrete)
with xfail_if_not_implemented():
loss = elbo.loss(model, guide)
assert isinstance(loss, float) and not math.isnan(loss), loss
loss = elbo.loss_and_grads(model, guide)
assert isinstance(loss, float) and not math.isnan(loss), loss
# A simple Gaussian mixture model, with no vectorization.
def testCalculateStats(self):
stats = results_pb2.Stats()
stats.true_positives = 12
stats.false_positives = 8
stats.false_negatives = 3
run_pipeline_lib.calculate_stats(stats)
self.assertAlmostEqual(.6, stats.precision)
self.assertAlmostEqual(.8, stats.recall)
self.assertAlmostEqual(.6857142857142856, stats.f_score)
stats = results_pb2.Stats()
run_pipeline_lib.calculate_stats(stats)
self.assertTrue(math.isnan(stats.precision))
self.assertTrue(math.isnan(stats.recall))
self.assertTrue(math.isnan(stats.f_score))
self.assertEqual(
'Precision has denominator of zero. Recall has denominator of zero. '
'f-score is NaN',
stats.error_message)
def testMacroStats(self):
macro_stats = run_pipeline_lib._MacroStats()
macro_stats.count = 50
macro_stats.precision_sum = 40
macro_stats.recall_sum = 45
stats = macro_stats.calculate_stats()
self.assertAlmostEqual(.8, stats.precision)
self.assertAlmostEqual(.9, stats.recall)
self.assertAlmostEqual(.8470588235294118, stats.f_score)
macro_stats = run_pipeline_lib._MacroStats()
stats = macro_stats.calculate_stats()
self.assertTrue(math.isnan(stats.precision))
self.assertTrue(math.isnan(stats.recall))
self.assertTrue(math.isnan(stats.f_score))
def calculate_stats(stats):
"""Calculate derived stats and put them into the given results_pb2.Stats."""
stats.error_message = ''
if stats.true_positives + stats.false_positives:
stats.precision = (float(stats.true_positives) /
(stats.true_positives + stats.false_positives))
else:
stats.precision = float('NaN')
stats.error_message += 'Precision has denominator of zero. '
if stats.true_positives + stats.false_negatives:
stats.recall = (float(stats.true_positives) /
(stats.true_positives + stats.false_negatives))
else:
stats.recall = float('NaN')
stats.error_message += 'Recall has denominator of zero. '
stats.f_score = hmean(stats.precision, stats.recall)
if math.isnan(stats.f_score):
stats.error_message += 'f-score is NaN'
return stats
def isConverged(self,iter):
from math import isnan
if isnan(self.loss):
print 'Loss = NaN or Infinity: current settings does not fit the recommender! Change the settings and try again!'
exit(-1)
measure = self.performance()
value = [item.strip()for item in measure]
#with open(self.algorName+' iteration.txt')
deltaLoss = (self.lastLoss-self.loss)
print '%s %s iteration %d: loss = %.4f, delta_loss = %.5f learning_Rate = %.5f %s %s' %(self.algorName,self.foldInfo,iter,self.loss,deltaLoss,self.lRate,measure[0][:11],measure[1][:12])
#check if converged
cond = abs(deltaLoss) < 1e-3
converged = cond
if not converged:
self.updateLearningRate(iter)
self.lastLoss = self.loss
shuffle(self.dao.trainingData)
return converged
def GetInfoFromTable(fitstable,indice):
'''read salvatore table and return info corresponding to the source at the place indice
Parameters
---------
fitstable : pyfits object : table to be browsed
indice : place of the source in the table
'''
data = fitstable[1].data[indice]
sourcename = data[0]
ra = data[1]
dec = data[2]
z = data[4]
if math.isnan(z):
z=0
hemisphere = data[6]
observation_type = data[8]
if hemisphere =='S':
hemisphere ='South'
if hemisphere =='N':
hemisphere ='North'
return sourcename,ra,dec,z,hemisphere,observation_type
def pearson(A, B):
# Pearson
coeff = 0.0
try:
coeff = scipy.stats.pearsonr(A, B)[0]
if math.isnan(coeff):
coeff = 0.0
except:
coeff = 0.0
return (coeff)
##
# Calculate the hamming weight of all values
# within the given array.
#
# @param A 1-D byte array
# @return Hamming weight
#
def maybe_create_close_position_transaction(self, asset, dt, data_portal):
if not self.positions.get(asset):
return None
amount = self.positions.get(asset).amount
price = data_portal.get_spot_value(
asset, 'price', dt, self.data_frequency)
# Get the last traded price if price is no longer available
if isnan(price):
price = self.positions.get(asset).last_sale_price
txn = Transaction(
asset=asset,
amount=(-1 * amount),
dt=dt,
price=price,
commission=0,
order_id=None,
)
return txn
def sync_last_sale_prices(self, dt, handle_non_market_minutes,
data_portal):
if not handle_non_market_minutes:
for asset, position in iteritems(self.positions):
last_sale_price = data_portal.get_spot_value(
asset, 'price', dt, self.data_frequency
)
if not np.isnan(last_sale_price):
position.last_sale_price = last_sale_price
else:
for asset, position in iteritems(self.positions):
last_sale_price = data_portal.get_adjusted_value(
asset,
'price',
data_portal.trading_calendar.previous_minute(dt),
dt,
self.data_frequency
)
if not np.isnan(last_sale_price):
position.last_sale_price = last_sale_price
def set_metric(self, key, value):
# This method sets a numeric tag value for the given key. It acts
# like `set_meta()` and it simply add a tag without further processing.
# FIXME[matt] we could push this check to serialization time as well.
# only permit types that are commonly serializable (don't use
# isinstance so that we convert unserializable types like numpy
# numbers)
if type(value) not in numeric_types:
try:
value = float(value)
except (ValueError, TypeError):
log.debug("ignoring not number metric %s:%s", key, value)
return
# don't allow nan or inf
if math.isnan(value) or math.isinf(value):
log.debug("ignoring not real metric %s:%s", key, value)
return
self.metrics[key] = value
def reccomandation(self, x):
""""""
y = np.array([[math.nan] * nombre_films()])
for key in self.films:
y[0][self.conv.renvoyer_index(key)] = self.films[key]
max_i = 0
n_max = 0
t = np.dot(x, self._theta.T)
print(t)
for i, el in enumerate(y[0]):
if np.isnan(el) and t[i, 0] > n_max:
print("film : ", self.conv.renvoyer_nom_index(i), "note :", n_max)
n_max = t[i, 0]
max_i = i
print(t)
print(self._theta)
return self.conv.renvoyer_nom_index(max_i)
def sous_ensemble():
"""Renvoie un sous_tableau sans nan en regardant les films les plus regardes et prend
les utlisateurs present
dans ces films"""
tableau = tableau_des_notes()
reduit = [(tableau[:,i][~np.isnan(tableau[:,i])], i) for i in range(9125)]
trie = sorted(reduit, reverse=True, key=lambda entree: len(entree[0]))
utilisateurs_ayant_vu_le_premier_film = [i for i, u in enumerate(tableau[: ,trie[0][1]]) \
if not math.isnan(u)]
utilisateurs_ayant_vu_les_film = [u for u in utilisateurs_ayant_vu_le_premier_film \
if a_vu_tout_les_films(u, trie, tableau)]
index_11_premiers_films = [trie[i][1] for i in range(11)]
tableau_concentre = [[note for i, note in enumerate(tableau[u]) if\
(i in index_11_premiers_films)] \
for u in utilisateurs_ayant_vu_les_film]
return tableau_concentre
def reccomandation(self, x):
""""""
y = np.array([[math.nan] * nombre_films()])
for key in self.films:
y[0][self.conv.renvoyer_index(key)] = self.films[key]
max_i = 0
n_max = 0
t = np.dot(x, self._theta.T)
print(t)
for i, el in enumerate(y[0]):
if np.isnan(el) and t[i, 0] > n_max:
print("film : ", self.conv.renvoyer_nom_index(i), "note :", n_max)
n_max = t[i, 0]
max_i = i
print(t)
print(self._theta)
return self.conv.renvoyer_nom_index(max_i)
def generate_data_fn2(rows, cnt, x_low, x_high, fn):
x_array = []
y_array = []
while (len(x_array) < rows):
args = []
for i in range(cnt):
args.append(np.random.uniform(x_low, x_high))
try:
y = fn(*args)
if not math.isnan(y):
x_array.append(args)
y_array.append(y)
except (ValueError, ZeroDivisionError):
pass
return np.array(x_array, dtype=np.float32), np.array(y_array, dtype=np.float32)
# Generate data for the ratio experiment
def runScript(query_dist,dm_dict,pears_ids):
best_pears=[]
#############################################################
#Calculate score for each pear in relation to the user query
#############################################################
if len(query_dist) > 0:
pears_scores={}
for pear_name,v in pears_ids.items():
scoreSIM = 0.0 #Initialise score for similarity
score=cosine_similarity(np.array(v),query_dist)
if not isnan(score):
pears_scores[pear_name]=score
print pear_name,score
best_pears=outputBestPears(pears_scores)
return best_pears
def getColorEntry(val, args):
if not args.colorized:
return ""
if not isinstance(val, float) or math.isnan(val):
return colors.ENDC
if (val < .20):
return colors.RED
elif (val < .40):
return colors.YELLOW
elif (val < .60):
return colors.BLUE
elif (val < .80):
return colors.CYAN
else:
return colors.GREEN
# Cityscapes files have a typical filename structure
# <city>_<sequenceNb>_<frameNb>_<type>[_<type2>].<ext>
# This class contains the individual elements as members
# For the sequence and frame number, the strings are returned, including leading zeros
def __init__(self, lower, upper=None, msg=None, **kwds):
lower, upper, msg = _normalize_deviation_args(lower, upper, msg)
normalize_numbers = lambda x: x if x else 0
def function(diff):
if not isinstance(diff, xDeviation):
return False
value = normalize_numbers(diff.value) # Closes over normalize_numbers().
required = normalize_numbers(diff.required)
if isnan(value) or isnan(required):
return False
if value != 0 and required == 0:
return False
percent = value / required if required else 0 # % error calc.
return lower <= percent <= upper # Closes over *lower* and *upper*.
function.__name__ = self.__class__.__name__
super(allow_percent_deviation, self).__init__(function, msg, **kwds)
#_prettify_deviation_signature(allow_percent_deviation.__init__)
def percent_deviation(self):
expected = self.expected
if isinstance(expected, float):
expected = Decimal.from_float(expected)
else:
expected = Decimal(expected if expected else 0)
deviation = self.deviation
if isinstance(deviation, float):
deviation = Decimal.from_float(deviation)
else:
deviation = Decimal(deviation if deviation else 0)
if isnan(expected) or isnan(deviation):
return Decimal('NaN')
return deviation / expected if expected else Decimal(0) # % error calc.
def _from_float(cls, f):
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
k = _bit_length(d) - 1
result = _dec_from_triple(sign, str(n*5**k), -k)
if cls is Decimal:
return result
else:
return cls(result)
def assertFloatIdentical(self, x, y):
"""Fail unless floats x and y are identical, in the sense that:
(1) both x and y are nans, or
(2) both x and y are infinities, with the same sign, or
(3) both x and y are zeros, with the same sign, or
(4) x and y are both finite and nonzero, and x == y
"""
msg = 'floats {!r} and {!r} are not identical'
if math.isnan(x) or math.isnan(y):
if math.isnan(x) and math.isnan(y):
return
elif x == y:
if x != 0.0:
return
# both zero; check that signs match
elif math.copysign(1.0, x) == math.copysign(1.0, y):
return
else:
msg += ': zeros have different signs'
self.fail(msg.format(x, y))
def testCeil(self):
self.assertRaises(TypeError, math.ceil)
self.assertEqual(int, type(math.ceil(0.5)))
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:
def __ceil__(self):
return 42
class TestNoCeil:
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)
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)
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, result, expected))
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]))
def assertFloatsAreIdentical(self, x, y):
"""assert that floats x and y are identical, in the sense that:
(1) both x and y are nans, or
(2) both x and y are infinities, with the same sign, or
(3) both x and y are zeros, with the same sign, or
(4) x and y are both finite and nonzero, and x == y
"""
msg = 'floats {!r} and {!r} are not identical'
if isnan(x) or isnan(y):
if isnan(x) and isnan(y):
return
elif x == y:
if x != 0.0:
return
# both zero; check that signs match
elif copysign(1.0, x) == copysign(1.0, y):
return
else:
msg += ': zeros have different signs'
self.fail(msg.format(x, y))
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:
enum_value = field.enum_type.values_by_number.get(value, None)
if enum_value is not None:
return enum_value.name
else:
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
def format_value(value, format_type):
if format_type == 'string':
return str(value)
value = value if not math.isnan(float(value)) else 0
if format_type == 'percent':
return '{:.1%}'.format(float(value))
elif format_type == 'integer':
return '{:,d}'.format(int(value))
elif format_type[0] == '%':
return format_type % float(value)
raise Exception('Invalid format type: %s' % format_type)
def json_sanitize(data):
# This really doesn't make me happy. How many cases we we have to test?
if (type(data) == float) or (type(data) == numpy.float64):
# Handle floats specially
if math.isnan(data):
return "NaN";
if (data == float("+Inf")):
return "inf"
if (data == float("-Inf")):
return "-inf"
return data
elif hasattr(data, 'iterkeys'):
# Dictionary case
new_data = {}
for k in data.keys():
new_data[k] = json_sanitize(data[k])
return new_data
elif hasattr(data, '__iter__'):
# Anything else that looks like a list. N
new_data = []
for d in data:
new_data.append(json_sanitize(d))
return new_data
elif hasattr(data, 'shape') and data.shape == ():
# Numpy 0-d array
return np.asscalar(data)
else:
return data
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)
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())