我们从Python开源项目中，提取了以下43个代码示例，用于说明如何使用math.frexp()。
def lsum(iterable): "Full precision summation using long integers for intermediate values" # Transform (exactly) a float to m * 2 ** e where m and e are integers. # Adjust (tmant,texp) and (mant,exp) to make texp the common exponent. # Given a common exponent, the mantissas can be summed directly. tmant, texp = 0L, 0 for x in iterable: mant, exp = frexp(x) mant, exp = long(mant * 2.0 ** 53), exp-53 if texp > exp: tmant <<= texp - exp texp = exp else: mant <<= exp - texp tmant += mant return float(str(tmant)) * 2.0 ** texp
def dsum(iterable): "Full precision summation using Decimal objects for intermediate values" # Transform (exactly) a float to m * 2 ** e where m and e are integers. # Convert (mant, exp) to a Decimal and add to the cumulative sum. # If the precision is too small for exact conversion and addition, # then retry with a larger precision. total = Decimal(0) for x in iterable: mant, exp = frexp(x) mant, exp = int(mant * 2.0 ** 53), exp-53 while True: try: total += mant * Decimal(2) ** exp break except Inexact: getcontext().prec += 1 return float(total)
def get_min_level(self, value): """Minimum cell level for given value. Return the minimum level such that the metric is at most the given value, or ``s2sphere.CellId.MAX_LEVEL`` if there is no such level. For example, ``s2sphere.MAX_DIAG.get_min_level(0.1)`` returns the minimum level such that all cell diagonal lengths are 0.1 or smaller. The return value is always a valid level. :param value: Depending on whether this is used in one or two dimensions, this is an angle in radians or a solid angle in steradians. """ if value <= 0: return CellId.MAX_LEVEL m, x = math.frexp(value / self.deriv()) level = max(0, min(CellId.MAX_LEVEL, -((x - 1) >> (self.__dim - 1)))) assert level == CellId.MAX_LEVEL or self.get_value(level) <= value assert level == 0 or self.get_value(level - 1) > value return level
def get_max_level(self, value): """Maximum cell level for given value. Return the maximum level such that the metric is at least the given value, or zero if there is no such level. For example, ``s2sphere.MIN_WIDTH.get_max_level(0.1)`` returns the maximum level such that all cells have a minimum width of 0.1 or larger. The return value is always a valid level. :param value: Depending on whether this is used in one or two dimensions, this is an angle in radians or a solid angle in steradians. """ if value <= 0: return CellId.MAX_LEVEL m, x = math.frexp(self.deriv() / value) level = max(0, min(CellId.MAX_LEVEL, (x - 1) >> (self.__dim - 1))) assert level == 0 or self.get_value(level) >= value assert level == CellId.MAX_LEVEL or self.get_value(level + 1) < value return level
def from_float(x, prec=53, rnd=round_fast): """Create a raw mpf from a Python float, rounding if necessary. If prec >= 53, the result is guaranteed to represent exactly the same number as the input. If prec is not specified, use prec=53.""" # frexp only raises an exception for nan on some platforms if x != x: return fnan # in Python2.5 math.frexp gives an exception for float infinity # in Python2.6 it returns (float infinity, 0) try: m, e = math.frexp(x) except: if x == math_float_inf: return finf if x == -math_float_inf: return fninf return fnan if x == math_float_inf: return finf if x == -math_float_inf: return fninf return from_man_exp(int(m*(1<<53)), e-53, prec, rnd)
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, result, expected)) 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]))
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]))
def setf(self, value): """store /value/ into a binary format""" exponentbias = (2**self.components[1])/2 - 1 m,e = math.frexp(value) # extract components from value s = math.copysign(1.0, m) m = abs(m) # convert to integrals sf = 1 if s < 0 else 0 exponent = e + exponentbias - 1 m = m*2.0 - 1.0 # remove the implicit bit mantissa = int(m * (2**self.components[2])) # store components result = bitmap.zero result = bitmap.push( result, bitmap.new(sf,self.components[0]) ) result = bitmap.push( result, bitmap.new(exponent,self.components[1]) ) result = bitmap.push( result, bitmap.new(mantissa,self.components[2]) ) return self.__setvalue__( result[0] )
def _write_float(f, x): import math if x < 0: sign = 0x8000 x = x * -1 else: sign = 0 if x == 0: expon = 0 himant = 0 lomant = 0 else: fmant, expon = math.frexp(x) if expon > 16384 or fmant >= 1: # Infinity or NaN expon = sign|0x7FFF himant = 0 lomant = 0 else: # Finite expon = expon + 16382 if expon < 0: # denormalized fmant = math.ldexp(fmant, expon) expon = 0 expon = expon | sign fmant = math.ldexp(fmant, 32) fsmant = math.floor(fmant) himant = long(fsmant) fmant = math.ldexp(fmant - fsmant, 32) fsmant = math.floor(fmant) lomant = long(fsmant) _write_short(f, expon) _write_long(f, himant) _write_long(f, lomant)
def _write_float(f, x): import math if x < 0: sign = 0x8000 x = x * -1 else: sign = 0 if x == 0: expon = 0 himant = 0 lomant = 0 else: fmant, expon = math.frexp(x) if expon > 16384 or fmant >= 1 or fmant != fmant: # Infinity or NaN expon = sign|0x7FFF himant = 0 lomant = 0 else: # Finite expon = expon + 16382 if expon < 0: # denormalized fmant = math.ldexp(fmant, expon) expon = 0 expon = expon | sign fmant = math.ldexp(fmant, 32) fsmant = math.floor(fmant) himant = long(fsmant) fmant = math.ldexp(fmant - fsmant, 32) fsmant = math.floor(fmant) lomant = long(fsmant) _write_ushort(f, expon) _write_ulong(f, himant) _write_ulong(f, lomant)
def mag(ctx, z): if z: return ctx.frexp(abs(z))[1] return ctx.ninf
def _write_float(f, x): import math if x < 0: sign = 0x8000 x = x * -1 else: sign = 0 if x == 0: expon = 0 himant = 0 lomant = 0 else: fmant, expon = math.frexp(x) if expon > 16384 or fmant >= 1 or fmant != fmant: # Infinity or NaN expon = sign|0x7FFF himant = 0 lomant = 0 else: # Finite expon = expon + 16382 if expon < 0: # denormalized fmant = math.ldexp(fmant, expon) expon = 0 expon = expon | sign fmant = math.ldexp(fmant, 32) fsmant = math.floor(fmant) himant = int(fsmant) fmant = math.ldexp(fmant - fsmant, 32) fsmant = math.floor(fmant) lomant = int(fsmant) _write_ushort(f, expon) _write_ulong(f, himant) _write_ulong(f, lomant)
def _compute_len(param): mant, l = math.frexp(float(param)) bitmask = 1L << l if bitmask <= param: raise RuntimeError('(param, l) = %r' % ((param, l),)) while l: bitmask = bitmask >> 1 if param & bitmask: break l = l - 1 return l
def __init__(self, size, sample_rate=16000, band_number=12, window=[50, 8000]): self.size = 1 << math.frexp(size - 1)[1] self.sample_rate = float(sample_rate) self.resolution = self.sample_rate / self.size # (sample_rate/2) / (band/2) self.set_band(band_number, window) self.fft = FFT(self.size)
def Counter(rnum, wedge_density, inner_ring): wedge_count = int((2 * PI) * (inner_ring + (rnum * CORRIDOR)) // CORRIDOR) wedge_cap = int(fmod(wedge_count, wedge_density)) wedge_count -= wedge_cap wedge_level = (wedge_count / wedge_density) wedge_level2 = frexp(wedge_level) if wedge_level2[0] <> 0.5: wedge_count = wedge_density * (2 ** (wedge_level2[1] - 1)) return wedge_count
def log2(x): return math.frexp(x)[1] - 1
def frexp(node): return merge([node], math.frexp)
def deg2dms (dgs) : f, d = math.modf (dgs) f = abs (f) m = 60.0 * f f, m = math.modf (m) #print math.frexp (f), math.frexp (m) s = 60.0 * f dms = "%dd%02d'%09.6f\"" % (d, m, s) #print dms return dms # ### # # Convert from polar to rectangular coordinates
def bytes_for_humans(byte_count: int): # Get power of two directly from floating point exponent bits (mantissa) power_of_2 = frexp(byte_count)[1] - 1 binary_multiple = power_of_2 // 10 # If too big, represent in largest form if binary_multiple >= len(byte_names): binary_multiple = len(byte_names) - 1 # Gets the magnitude of the most significant multiple of 1024 impercise_magnitude = byte_count // (1 << (binary_multiple * 10)) # If less than 1024B, just return number of bytes if binary_multiple == 0: return str(impercise_magnitude) + ' B' return str(impercise_magnitude) + ' ' \ + byte_names[binary_multiple - 1] + 'B'
def SetFog(self,fog): projection = (fog.function >> 3) & 1 if projection: if fog.z_far == fog.z_near or fog.z_end == fog.z_start: A = 0 C = 0 else: A = (fog.z_far - fog.z_near)/(fog.z_end - fog.z_start) C = (fog.z_start - fog.z_near)/(fog.z_end - fog.z_start) b_shift = 0 b_magnitude = 0 else: if fog.z_far == fog.z_near or fog.z_end == fog.z_start: A = 0 B = 0.5 C = 0 else: A = fog.z_far*fog.z_near/((fog.z_far - fog.z_near)*(fog.z_end - fog.z_start)) B = fog.z_far/(fog.z_far - fog.z_near) C = fog.z_start/(fog.z_end - fog.z_start) if B > 1: b_shift = 1 + int(ceil(log(B,2))) elif 0 < B < 0.5: b_shift = 0 else: b_shift = 1 A /= 2**b_shift b_magnitude = int(2*(B/2**b_shift)*8388638) a_mantissa,a_exponent = frexp(A) self.fog_param0[0:11] = int(abs(a_mantissa)*2**12) & 0x7FF self.fog_param0[11:19] = a_exponent + 126 if A != 0 else 0 self.fog_param0[19] = a_mantissa < 0 self.fog_param1[0:24] = b_magnitude self.fog_param2[0:5] = b_shift c_mantissa,c_exponent = frexp(C) self.fog_param3[0:11] = int(abs(c_mantissa)*2**12) & 0x7FF self.fog_param3[11:19] = c_exponent + 126 if C != 0 else 0 self.fog_param3[19] = c_mantissa < 0 self.fog_param3[20:21] = projection self.fog_param3[21:24] = fog.function self.fog_color[0:8] = fog.color.b self.fog_color[8:16] = fog.color.g self.fog_color[16:24] = fog.color.r
def float_pack(x, size): """Convert a Python float x into a 64-bit unsigned integer with the same byte representation.""" if size == 8: MIN_EXP = -1021 # = sys.float_info.min_exp MAX_EXP = 1024 # = sys.float_info.max_exp MANT_DIG = 53 # = sys.float_info.mant_dig BITS = 64 elif size == 4: MIN_EXP = -125 # C's FLT_MIN_EXP MAX_EXP = 128 # FLT_MAX_EXP MANT_DIG = 24 # FLT_MANT_DIG BITS = 32 else: raise ValueError("invalid size value") sign = math.copysign(1.0, x) < 0.0 if math.isinf(x): mant = 0 exp = MAX_EXP - MIN_EXP + 2 elif math.isnan(x): mant = 1 << (MANT_DIG-2) # other values possible exp = MAX_EXP - MIN_EXP + 2 elif x == 0.0: mant = 0 exp = 0 else: m, e = math.frexp(abs(x)) # abs(x) == m * 2**e exp = e - (MIN_EXP - 1) if exp > 0: # Normal case. mant = round_to_nearest(m * (1 << MANT_DIG)) mant -= 1 << MANT_DIG - 1 else: # Subnormal case. if exp + MANT_DIG - 1 >= 0: mant = round_to_nearest(m * (1 << exp + MANT_DIG - 1)) else: mant = 0 exp = 0 # Special case: rounding produced a MANT_DIG-bit mantissa. assert 0 <= mant <= 1 << MANT_DIG - 1 if mant == 1 << MANT_DIG - 1: mant = 0 exp += 1 # Raise on overflow (in some circumstances, may want to return # infinity instead). if exp >= MAX_EXP - MIN_EXP + 2: raise OverflowError("float too large to pack in this format") # check constraints assert 0 <= mant < 1 << MANT_DIG - 1 assert 0 <= exp <= MAX_EXP - MIN_EXP + 2 assert 0 <= sign <= 1 return ((sign << BITS - 1) | (exp << MANT_DIG - 1)) | mant
