1415 lines
44 KiB
Python
1415 lines
44 KiB
Python
|
"""
|
||
|
|
Low-level functions for arbitrary-precision floating-point arithmetic.
|
||
|
|
"""
|
||
|
|
|
||
|
|
__docformat__ = 'plaintext'
|
||
|
|
|
||
|
|
import math
|
||
|
|
|
||
|
|
from bisect import bisect
|
||
|
|
|
||
|
|
import sys
|
||
|
|
|
||
|
|
# Importing random is slow
|
||
|
|
#from random import getrandbits
|
||
|
|
getrandbits = None
|
||
|
|
|
||
|
|
from .backend import (MPZ, MPZ_TYPE, MPZ_ZERO, MPZ_ONE, MPZ_TWO, MPZ_FIVE,
|
||
|
|
BACKEND, STRICT, HASH_MODULUS, HASH_BITS, gmpy, sage, sage_utils)
|
||
|
|
|
||
|
|
from .libintmath import (giant_steps,
|
||
|
|
trailtable, bctable, lshift, rshift, bitcount, trailing,
|
||
|
|
sqrt_fixed, numeral, isqrt, isqrt_fast, sqrtrem,
|
||
|
|
bin_to_radix)
|
||
|
|
|
||
|
|
# We don't pickle tuples directly for the following reasons:
|
||
|
|
# 1: pickle uses str() for ints, which is inefficient when they are large
|
||
|
|
# 2: pickle doesn't work for gmpy mpzs
|
||
|
|
# Both problems are solved by using hex()
|
||
|
|
|
||
|
|
if BACKEND == 'sage':
|
||
|
|
def to_pickable(x):
|
||
|
|
sign, man, exp, bc = x
|
||
|
|
return sign, hex(man), exp, bc
|
||
|
|
else:
|
||
|
|
def to_pickable(x):
|
||
|
|
sign, man, exp, bc = x
|
||
|
|
return sign, hex(man)[2:], exp, bc
|
||
|
|
|
||
|
|
def from_pickable(x):
|
||
|
|
sign, man, exp, bc = x
|
||
|
|
return (sign, MPZ(man, 16), exp, bc)
|
||
|
|
|
||
|
|
class ComplexResult(ValueError):
|
||
|
|
pass
|
||
|
|
|
||
|
|
try:
|
||
|
|
intern
|
||
|
|
except NameError:
|
||
|
|
intern = lambda x: x
|
||
|
|
|
||
|
|
# All supported rounding modes
|
||
|
|
round_nearest = intern('n')
|
||
|
|
round_floor = intern('f')
|
||
|
|
round_ceiling = intern('c')
|
||
|
|
round_up = intern('u')
|
||
|
|
round_down = intern('d')
|
||
|
|
round_fast = round_down
|
||
|
|
|
||
|
|
def prec_to_dps(n):
|
||
|
|
"""Return number of accurate decimals that can be represented
|
||
|
|
with a precision of n bits."""
|
||
|
|
return max(1, int(round(int(n)/3.3219280948873626)-1))
|
||
|
|
|
||
|
|
def dps_to_prec(n):
|
||
|
|
"""Return the number of bits required to represent n decimals
|
||
|
|
accurately."""
|
||
|
|
return max(1, int(round((int(n)+1)*3.3219280948873626)))
|
||
|
|
|
||
|
|
def repr_dps(n):
|
||
|
|
"""Return the number of decimal digits required to represent
|
||
|
|
a number with n-bit precision so that it can be uniquely
|
||
|
|
reconstructed from the representation."""
|
||
|
|
dps = prec_to_dps(n)
|
||
|
|
if dps == 15:
|
||
|
|
return 17
|
||
|
|
return dps + 3
|
||
|
|
|
||
|
|
#----------------------------------------------------------------------------#
|
||
|
|
# Some commonly needed float values #
|
||
|
|
#----------------------------------------------------------------------------#
|
||
|
|
|
||
|
|
# Regular number format:
|
||
|
|
# (-1)**sign * mantissa * 2**exponent, plus bitcount of mantissa
|
||
|
|
fzero = (0, MPZ_ZERO, 0, 0)
|
||
|
|
fnzero = (1, MPZ_ZERO, 0, 0)
|
||
|
|
fone = (0, MPZ_ONE, 0, 1)
|
||
|
|
fnone = (1, MPZ_ONE, 0, 1)
|
||
|
|
ftwo = (0, MPZ_ONE, 1, 1)
|
||
|
|
ften = (0, MPZ_FIVE, 1, 3)
|
||
|
|
fhalf = (0, MPZ_ONE, -1, 1)
|
||
|
|
|
||
|
|
# Arbitrary encoding for special numbers: zero mantissa, nonzero exponent
|
||
|
|
fnan = (0, MPZ_ZERO, -123, -1)
|
||
|
|
finf = (0, MPZ_ZERO, -456, -2)
|
||
|
|
fninf = (1, MPZ_ZERO, -789, -3)
|
||
|
|
|
||
|
|
# Was 1e1000; this is broken in Python 2.4
|
||
|
|
math_float_inf = 1e300 * 1e300
|
||
|
|
|
||
|
|
|
||
|
|
#----------------------------------------------------------------------------#
|
||
|
|
# Rounding #
|
||
|
|
#----------------------------------------------------------------------------#
|
||
|
|
|
||
|
|
# This function can be used to round a mantissa generally. However,
|
||
|
|
# we will try to do most rounding inline for efficiency.
|
||
|
|
def round_int(x, n, rnd):
|
||
|
|
if rnd == round_nearest:
|
||
|
|
if x >= 0:
|
||
|
|
t = x >> (n-1)
|
||
|
|
if t & 1 and ((t & 2) or (x & h_mask[n<300][n])):
|
||
|
|
return (t>>1)+1
|
||
|
|
else:
|
||
|
|
return t>>1
|
||
|
|
else:
|
||
|
|
return -round_int(-x, n, rnd)
|
||
|
|
if rnd == round_floor:
|
||
|
|
return x >> n
|
||
|
|
if rnd == round_ceiling:
|
||
|
|
return -((-x) >> n)
|
||
|
|
if rnd == round_down:
|
||
|
|
if x >= 0:
|
||
|
|
return x >> n
|
||
|
|
return -((-x) >> n)
|
||
|
|
if rnd == round_up:
|
||
|
|
if x >= 0:
|
||
|
|
return -((-x) >> n)
|
||
|
|
return x >> n
|
||
|
|
|
||
|
|
# These masks are used to pick out segments of numbers to determine
|
||
|
|
# which direction to round when rounding to nearest.
|
||
|
|
class h_mask_big:
|
||
|
|
def __getitem__(self, n):
|
||
|
|
return (MPZ_ONE<<(n-1))-1
|
||
|
|
|
||
|
|
h_mask_small = [0]+[((MPZ_ONE<<(_-1))-1) for _ in range(1, 300)]
|
||
|
|
h_mask = [h_mask_big(), h_mask_small]
|
||
|
|
|
||
|
|
# The >> operator rounds to floor. shifts_down[rnd][sign]
|
||
|
|
# tells whether this is the right direction to use, or if the
|
||
|
|
# number should be negated before shifting
|
||
|
|
shifts_down = {round_floor:(1,0), round_ceiling:(0,1),
|
||
|
|
round_down:(1,1), round_up:(0,0)}
|
||
|
|
|
||
|
|
|
||
|
|
#----------------------------------------------------------------------------#
|
||
|
|
# Normalization of raw mpfs #
|
||
|
|
#----------------------------------------------------------------------------#
|
||
|
|
|
||
|
|
# This function is called almost every time an mpf is created.
|
||
|
|
# It has been optimized accordingly.
|
||
|
|
|
||
|
|
def _normalize(sign, man, exp, bc, prec, rnd):
|
||
|
|
"""
|
||
|
|
Create a raw mpf tuple with value (-1)**sign * man * 2**exp and
|
||
|
|
normalized mantissa. The mantissa is rounded in the specified
|
||
|
|
direction if its size exceeds the precision. Trailing zero bits
|
||
|
|
are also stripped from the mantissa to ensure that the
|
||
|
|
representation is canonical.
|
||
|
|
|
||
|
|
Conditions on the input:
|
||
|
|
* The input must represent a regular (finite) number
|
||
|
|
* The sign bit must be 0 or 1
|
||
|
|
* The mantissa must be positive
|
||
|
|
* The exponent must be an integer
|
||
|
|
* The bitcount must be exact
|
||
|
|
|
||
|
|
If these conditions are not met, use from_man_exp, mpf_pos, or any
|
||
|
|
of the conversion functions to create normalized raw mpf tuples.
|
||
|
|
"""
|
||
|
|
if not man:
|
||
|
|
return fzero
|
||
|
|
# Cut mantissa down to size if larger than target precision
|
||
|
|
n = bc - prec
|
||
|
|
if n > 0:
|
||
|
|
if rnd == round_nearest:
|
||
|
|
t = man >> (n-1)
|
||
|
|
if t & 1 and ((t & 2) or (man & h_mask[n<300][n])):
|
||
|
|
man = (t>>1)+1
|
||
|
|
else:
|
||
|
|
man = t>>1
|
||
|
|
elif shifts_down[rnd][sign]:
|
||
|
|
man >>= n
|
||
|
|
else:
|
||
|
|
man = -((-man)>>n)
|
||
|
|
exp += n
|
||
|
|
bc = prec
|
||
|
|
# Strip trailing bits
|
||
|
|
if not man & 1:
|
||
|
|
t = trailtable[int(man & 255)]
|
||
|
|
if not t:
|
||
|
|
while not man & 255:
|
||
|
|
man >>= 8
|
||
|
|
exp += 8
|
||
|
|
bc -= 8
|
||
|
|
t = trailtable[int(man & 255)]
|
||
|
|
man >>= t
|
||
|
|
exp += t
|
||
|
|
bc -= t
|
||
|
|
# Bit count can be wrong if the input mantissa was 1 less than
|
||
|
|
# a power of 2 and got rounded up, thereby adding an extra bit.
|
||
|
|
# With trailing bits removed, all powers of two have mantissa 1,
|
||
|
|
# so this is easy to check for.
|
||
|
|
if man == 1:
|
||
|
|
bc = 1
|
||
|
|
return sign, man, exp, bc
|
||
|
|
|
||
|
|
def _normalize1(sign, man, exp, bc, prec, rnd):
|
||
|
|
"""same as normalize, but with the added condition that
|
||
|
|
man is odd or zero
|
||
|
|
"""
|
||
|
|
if not man:
|
||
|
|
return fzero
|
||
|
|
if bc <= prec:
|
||
|
|
return sign, man, exp, bc
|
||
|
|
n = bc - prec
|
||
|
|
if rnd == round_nearest:
|
||
|
|
t = man >> (n-1)
|
||
|
|
if t & 1 and ((t & 2) or (man & h_mask[n<300][n])):
|
||
|
|
man = (t>>1)+1
|
||
|
|
else:
|
||
|
|
man = t>>1
|
||
|
|
elif shifts_down[rnd][sign]:
|
||
|
|
man >>= n
|
||
|
|
else:
|
||
|
|
man = -((-man)>>n)
|
||
|
|
exp += n
|
||
|
|
bc = prec
|
||
|
|
# Strip trailing bits
|
||
|
|
if not man & 1:
|
||
|
|
t = trailtable[int(man & 255)]
|
||
|
|
if not t:
|
||
|
|
while not man & 255:
|
||
|
|
man >>= 8
|
||
|
|
exp += 8
|
||
|
|
bc -= 8
|
||
|
|
t = trailtable[int(man & 255)]
|
||
|
|
man >>= t
|
||
|
|
exp += t
|
||
|
|
bc -= t
|
||
|
|
# Bit count can be wrong if the input mantissa was 1 less than
|
||
|
|
# a power of 2 and got rounded up, thereby adding an extra bit.
|
||
|
|
# With trailing bits removed, all powers of two have mantissa 1,
|
||
|
|
# so this is easy to check for.
|
||
|
|
if man == 1:
|
||
|
|
bc = 1
|
||
|
|
return sign, man, exp, bc
|
||
|
|
|
||
|
|
try:
|
||
|
|
_exp_types = (int, long)
|
||
|
|
except NameError:
|
||
|
|
_exp_types = (int,)
|
||
|
|
|
||
|
|
def strict_normalize(sign, man, exp, bc, prec, rnd):
|
||
|
|
"""Additional checks on the components of an mpf. Enable tests by setting
|
||
|
|
the environment variable MPMATH_STRICT to Y."""
|
||
|
|
assert type(man) == MPZ_TYPE
|
||
|
|
assert type(bc) in _exp_types
|
||
|
|
assert type(exp) in _exp_types
|
||
|
|
assert bc == bitcount(man)
|
||
|
|
return _normalize(sign, man, exp, bc, prec, rnd)
|
||
|
|
|
||
|
|
def strict_normalize1(sign, man, exp, bc, prec, rnd):
|
||
|
|
"""Additional checks on the components of an mpf. Enable tests by setting
|
||
|
|
the environment variable MPMATH_STRICT to Y."""
|
||
|
|
assert type(man) == MPZ_TYPE
|
||
|
|
assert type(bc) in _exp_types
|
||
|
|
assert type(exp) in _exp_types
|
||
|
|
assert bc == bitcount(man)
|
||
|
|
assert (not man) or (man & 1)
|
||
|
|
return _normalize1(sign, man, exp, bc, prec, rnd)
|
||
|
|
|
||
|
|
if BACKEND == 'gmpy' and '_mpmath_normalize' in dir(gmpy):
|
||
|
|
_normalize = gmpy._mpmath_normalize
|
||
|
|
_normalize1 = gmpy._mpmath_normalize
|
||
|
|
|
||
|
|
if BACKEND == 'sage':
|
||
|
|
_normalize = _normalize1 = sage_utils.normalize
|
||
|
|
|
||
|
|
if STRICT:
|
||
|
|
normalize = strict_normalize
|
||
|
|
normalize1 = strict_normalize1
|
||
|
|
else:
|
||
|
|
normalize = _normalize
|
||
|
|
normalize1 = _normalize1
|
||
|
|
|
||
|
|
#----------------------------------------------------------------------------#
|
||
|
|
# Conversion functions #
|
||
|
|
#----------------------------------------------------------------------------#
|
||
|
|
|
||
|
|
def from_man_exp(man, exp, prec=None, rnd=round_fast):
|
||
|
|
"""Create raw mpf from (man, exp) pair. The mantissa may be signed.
|
||
|
|
If no precision is specified, the mantissa is stored exactly."""
|
||
|
|
man = MPZ(man)
|
||
|
|
sign = 0
|
||
|
|
if man < 0:
|
||
|
|
sign = 1
|
||
|
|
man = -man
|
||
|
|
if man < 1024:
|
||
|
|
bc = bctable[int(man)]
|
||
|
|
else:
|
||
|
|
bc = bitcount(man)
|
||
|
|
if not prec:
|
||
|
|
if not man:
|
||
|
|
return fzero
|
||
|
|
if not man & 1:
|
||
|
|
if man & 2:
|
||
|
|
return (sign, man >> 1, exp + 1, bc - 1)
|
||
|
|
t = trailtable[int(man & 255)]
|
||
|
|
if not t:
|
||
|
|
while not man & 255:
|
||
|
|
man >>= 8
|
||
|
|
exp += 8
|
||
|
|
bc -= 8
|
||
|
|
t = trailtable[int(man & 255)]
|
||
|
|
man >>= t
|
||
|
|
exp += t
|
||
|
|
bc -= t
|
||
|
|
return (sign, man, exp, bc)
|
||
|
|
return normalize(sign, man, exp, bc, prec, rnd)
|
||
|
|
|
||
|
|
int_cache = dict((n, from_man_exp(n, 0)) for n in range(-10, 257))
|
||
|
|
|
||
|
|
if BACKEND == 'gmpy' and '_mpmath_create' in dir(gmpy):
|
||
|
|
from_man_exp = gmpy._mpmath_create
|
||
|
|
|
||
|
|
if BACKEND == 'sage':
|
||
|
|
from_man_exp = sage_utils.from_man_exp
|
||
|
|
|
||
|
|
def from_int(n, prec=0, rnd=round_fast):
|
||
|
|
"""Create a raw mpf from an integer. If no precision is specified,
|
||
|
|
the mantissa is stored exactly."""
|
||
|
|
if not prec:
|
||
|
|
if n in int_cache:
|
||
|
|
return int_cache[n]
|
||
|
|
return from_man_exp(n, 0, prec, rnd)
|
||
|
|
|
||
|
|
def to_man_exp(s):
|
||
|
|
"""Return (man, exp) of a raw mpf. Raise an error if inf/nan."""
|
||
|
|
sign, man, exp, bc = s
|
||
|
|
if (not man) and exp:
|
||
|
|
raise ValueError("mantissa and exponent are undefined for %s" % man)
|
||
|
|
return man, exp
|
||
|
|
|
||
|
|
def to_int(s, rnd=None):
|
||
|
|
"""Convert a raw mpf to the nearest int. Rounding is done down by
|
||
|
|
default (same as int(float) in Python), but can be changed. If the
|
||
|
|
input is inf/nan, an exception is raised."""
|
||
|
|
sign, man, exp, bc = s
|
||
|
|
if (not man) and exp:
|
||
|
|
raise ValueError("cannot convert inf or nan to int")
|
||
|
|
if exp >= 0:
|
||
|
|
if sign:
|
||
|
|
return (-man) << exp
|
||
|
|
return man << exp
|
||
|
|
# Make default rounding fast
|
||
|
|
if not rnd:
|
||
|
|
if sign:
|
||
|
|
return -(man >> (-exp))
|
||
|
|
else:
|
||
|
|
return man >> (-exp)
|
||
|
|
if sign:
|
||
|
|
return round_int(-man, -exp, rnd)
|
||
|
|
else:
|
||
|
|
return round_int(man, -exp, rnd)
|
||
|
|
|
||
|
|
def mpf_round_int(s, rnd):
|
||
|
|
sign, man, exp, bc = s
|
||
|
|
if (not man) and exp:
|
||
|
|
return s
|
||
|
|
if exp >= 0:
|
||
|
|
return s
|
||
|
|
mag = exp+bc
|
||
|
|
if mag < 1:
|
||
|
|
if rnd == round_ceiling:
|
||
|
|
if sign: return fzero
|
||
|
|
else: return fone
|
||
|
|
elif rnd == round_floor:
|
||
|
|
if sign: return fnone
|
||
|
|
else: return fzero
|
||
|
|
elif rnd == round_nearest:
|
||
|
|
if mag < 0 or man == MPZ_ONE: return fzero
|
||
|
|
elif sign: return fnone
|
||
|
|
else: return fone
|
||
|
|
else:
|
||
|
|
raise NotImplementedError
|
||
|
|
return mpf_pos(s, min(bc, mag), rnd)
|
||
|
|
|
||
|
|
def mpf_floor(s, prec=0, rnd=round_fast):
|
||
|
|
v = mpf_round_int(s, round_floor)
|
||
|
|
if prec:
|
||
|
|
v = mpf_pos(v, prec, rnd)
|
||
|
|
return v
|
||
|
|
|
||
|
|
def mpf_ceil(s, prec=0, rnd=round_fast):
|
||
|
|
v = mpf_round_int(s, round_ceiling)
|
||
|
|
if prec:
|
||
|
|
v = mpf_pos(v, prec, rnd)
|
||
|
|
return v
|
||
|
|
|
||
|
|
def mpf_nint(s, prec=0, rnd=round_fast):
|
||
|
|
v = mpf_round_int(s, round_nearest)
|
||
|
|
if prec:
|
||
|
|
v = mpf_pos(v, prec, rnd)
|
||
|
|
return v
|
||
|
|
|
||
|
|
def mpf_frac(s, prec=0, rnd=round_fast):
|
||
|
|
return mpf_sub(s, mpf_floor(s), prec, rnd)
|
||
|
|
|
||
|
|
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 from_npfloat(x, prec=113, rnd=round_fast):
|
||
|
|
"""Create a raw mpf from a numpy float, rounding if necessary.
|
||
|
|
If prec >= 113, the result is guaranteed to represent exactly the
|
||
|
|
same number as the input. If prec is not specified, use prec=113."""
|
||
|
|
y = float(x)
|
||
|
|
if x == y: # ldexp overflows for float16
|
||
|
|
return from_float(y, prec, rnd)
|
||
|
|
import numpy as np
|
||
|
|
if np.isfinite(x):
|
||
|
|
m, e = np.frexp(x)
|
||
|
|
return from_man_exp(int(np.ldexp(m, 113)), int(e-113), prec, rnd)
|
||
|
|
if np.isposinf(x): return finf
|
||
|
|
if np.isneginf(x): return fninf
|
||
|
|
return fnan
|
||
|
|
|
||
|
|
def from_Decimal(x, prec=None, rnd=round_fast):
|
||
|
|
"""Create a raw mpf from a Decimal, rounding if necessary.
|
||
|
|
If prec is not specified, use the equivalent bit precision
|
||
|
|
of the number of significant digits in x."""
|
||
|
|
if x.is_nan(): return fnan
|
||
|
|
if x.is_infinite(): return fninf if x.is_signed() else finf
|
||
|
|
if prec is None:
|
||
|
|
prec = int(len(x.as_tuple()[1])*3.3219280948873626)
|
||
|
|
return from_str(str(x), prec, rnd)
|
||
|
|
|
||
|
|
def to_float(s, strict=False, rnd=round_fast):
|
||
|
|
"""
|
||
|
|
Convert a raw mpf to a Python float. The result is exact if the
|
||
|
|
bitcount of s is <= 53 and no underflow/overflow occurs.
|
||
|
|
|
||
|
|
If the number is too large or too small to represent as a regular
|
||
|
|
float, it will be converted to inf or 0.0. Setting strict=True
|
||
|
|
forces an OverflowError to be raised instead.
|
||
|
|
|
||
|
|
Warning: with a directed rounding mode, the correct nearest representable
|
||
|
|
floating-point number in the specified direction might not be computed
|
||
|
|
in case of overflow or (gradual) underflow.
|
||
|
|
"""
|
||
|
|
sign, man, exp, bc = s
|
||
|
|
if not man:
|
||
|
|
if s == fzero: return 0.0
|
||
|
|
if s == finf: return math_float_inf
|
||
|
|
if s == fninf: return -math_float_inf
|
||
|
|
return math_float_inf/math_float_inf
|
||
|
|
if bc > 53:
|
||
|
|
sign, man, exp, bc = normalize1(sign, man, exp, bc, 53, rnd)
|
||
|
|
if sign:
|
||
|
|
man = -man
|
||
|
|
try:
|
||
|
|
return math.ldexp(man, exp)
|
||
|
|
except OverflowError:
|
||
|
|
if strict:
|
||
|
|
raise
|
||
|
|
# Overflow to infinity
|
||
|
|
if exp + bc > 0:
|
||
|
|
if sign:
|
||
|
|
return -math_float_inf
|
||
|
|
else:
|
||
|
|
return math_float_inf
|
||
|
|
# Underflow to zero
|
||
|
|
return 0.0
|
||
|
|
|
||
|
|
def from_rational(p, q, prec, rnd=round_fast):
|
||
|
|
"""Create a raw mpf from a rational number p/q, round if
|
||
|
|
necessary."""
|
||
|
|
return mpf_div(from_int(p), from_int(q), prec, rnd)
|
||
|
|
|
||
|
|
def to_rational(s):
|
||
|
|
"""Convert a raw mpf to a rational number. Return integers (p, q)
|
||
|
|
such that s = p/q exactly."""
|
||
|
|
sign, man, exp, bc = s
|
||
|
|
if sign:
|
||
|
|
man = -man
|
||
|
|
if bc == -1:
|
||
|
|
raise ValueError("cannot convert %s to a rational number" % man)
|
||
|
|
if exp >= 0:
|
||
|
|
return man * (1<<exp), 1
|
||
|
|
else:
|
||
|
|
return man, 1<<(-exp)
|
||
|
|
|
||
|
|
def to_fixed(s, prec):
|
||
|
|
"""Convert a raw mpf to a fixed-point big integer"""
|
||
|
|
sign, man, exp, bc = s
|
||
|
|
offset = exp + prec
|
||
|
|
if sign:
|
||
|
|
if offset >= 0: return (-man) << offset
|
||
|
|
else: return (-man) >> (-offset)
|
||
|
|
else:
|
||
|
|
if offset >= 0: return man << offset
|
||
|
|
else: return man >> (-offset)
|
||
|
|
|
||
|
|
|
||
|
|
##############################################################################
|
||
|
|
##############################################################################
|
||
|
|
|
||
|
|
#----------------------------------------------------------------------------#
|
||
|
|
# Arithmetic operations, etc. #
|
||
|
|
#----------------------------------------------------------------------------#
|
||
|
|
|
||
|
|
def mpf_rand(prec):
|
||
|
|
"""Return a raw mpf chosen randomly from [0, 1), with prec bits
|
||
|
|
in the mantissa."""
|
||
|
|
global getrandbits
|
||
|
|
if not getrandbits:
|
||
|
|
import random
|
||
|
|
getrandbits = random.getrandbits
|
||
|
|
return from_man_exp(getrandbits(prec), -prec, prec, round_floor)
|
||
|
|
|
||
|
|
def mpf_eq(s, t):
|
||
|
|
"""Test equality of two raw mpfs. This is simply tuple comparison
|
||
|
|
unless either number is nan, in which case the result is False."""
|
||
|
|
if not s[1] or not t[1]:
|
||
|
|
if s == fnan or t == fnan:
|
||
|
|
return False
|
||
|
|
return s == t
|
||
|
|
|
||
|
|
def mpf_hash(s):
|
||
|
|
# Duplicate the new hash algorithm introduces in Python 3.2.
|
||
|
|
if sys.version_info >= (3, 2):
|
||
|
|
ssign, sman, sexp, sbc = s
|
||
|
|
|
||
|
|
# Handle special numbers
|
||
|
|
if not sman:
|
||
|
|
if s == fnan: return sys.hash_info.nan
|
||
|
|
if s == finf: return sys.hash_info.inf
|
||
|
|
if s == fninf: return -sys.hash_info.inf
|
||
|
|
h = sman % HASH_MODULUS
|
||
|
|
if sexp >= 0:
|
||
|
|
sexp = sexp % HASH_BITS
|
||
|
|
else:
|
||
|
|
sexp = HASH_BITS - 1 - ((-1 - sexp) % HASH_BITS)
|
||
|
|
h = (h << sexp) % HASH_MODULUS
|
||
|
|
if ssign: h = -h
|
||
|
|
if h == -1: h = -2
|
||
|
|
return int(h)
|
||
|
|
else:
|
||
|
|
try:
|
||
|
|
# Try to be compatible with hash values for floats and ints
|
||
|
|
return hash(to_float(s, strict=1))
|
||
|
|
except OverflowError:
|
||
|
|
# We must unfortunately sacrifice compatibility with ints here.
|
||
|
|
# We could do hash(man << exp) when the exponent is positive, but
|
||
|
|
# this would cause unreasonable inefficiency for large numbers.
|
||
|
|
return hash(s)
|
||
|
|
|
||
|
|
def mpf_cmp(s, t):
|
||
|
|
"""Compare the raw mpfs s and t. Return -1 if s < t, 0 if s == t,
|
||
|
|
and 1 if s > t. (Same convention as Python's cmp() function.)"""
|
||
|
|
|
||
|
|
# In principle, a comparison amounts to determining the sign of s-t.
|
||
|
|
# A full subtraction is relatively slow, however, so we first try to
|
||
|
|
# look at the components.
|
||
|
|
ssign, sman, sexp, sbc = s
|
||
|
|
tsign, tman, texp, tbc = t
|
||
|
|
|
||
|
|
# Handle zeros and special numbers
|
||
|
|
if not sman or not tman:
|
||
|
|
if s == fzero: return -mpf_sign(t)
|
||
|
|
if t == fzero: return mpf_sign(s)
|
||
|
|
if s == t: return 0
|
||
|
|
# Follow same convention as Python's cmp for float nan
|
||
|
|
if t == fnan: return 1
|
||
|
|
if s == finf: return 1
|
||
|
|
if t == fninf: return 1
|
||
|
|
return -1
|
||
|
|
# Different sides of zero
|
||
|
|
if ssign != tsign:
|
||
|
|
if not ssign: return 1
|
||
|
|
return -1
|
||
|
|
# This reduces to direct integer comparison
|
||
|
|
if sexp == texp:
|
||
|
|
if sman == tman:
|
||
|
|
return 0
|
||
|
|
if sman > tman:
|
||
|
|
if ssign: return -1
|
||
|
|
else: return 1
|
||
|
|
else:
|
||
|
|
if ssign: return 1
|
||
|
|
else: return -1
|
||
|
|
# Check position of the highest set bit in each number. If
|
||
|
|
# different, there is certainly an inequality.
|
||
|
|
a = sbc + sexp
|
||
|
|
b = tbc + texp
|
||
|
|
if ssign:
|
||
|
|
if a < b: return 1
|
||
|
|
if a > b: return -1
|
||
|
|
else:
|
||
|
|
if a < b: return -1
|
||
|
|
if a > b: return 1
|
||
|
|
|
||
|
|
# Both numbers have the same highest bit. Subtract to find
|
||
|
|
# how the lower bits compare.
|
||
|
|
delta = mpf_sub(s, t, 5, round_floor)
|
||
|
|
if delta[0]:
|
||
|
|
return -1
|
||
|
|
return 1
|
||
|
|
|
||
|
|
def mpf_lt(s, t):
|
||
|
|
if s == fnan or t == fnan:
|
||
|
|
return False
|
||
|
|
return mpf_cmp(s, t) < 0
|
||
|
|
|
||
|
|
def mpf_le(s, t):
|
||
|
|
if s == fnan or t == fnan:
|
||
|
|
return False
|
||
|
|
return mpf_cmp(s, t) <= 0
|
||
|
|
|
||
|
|
def mpf_gt(s, t):
|
||
|
|
if s == fnan or t == fnan:
|
||
|
|
return False
|
||
|
|
return mpf_cmp(s, t) > 0
|
||
|
|
|
||
|
|
def mpf_ge(s, t):
|
||
|
|
if s == fnan or t == fnan:
|
||
|
|
return False
|
||
|
|
return mpf_cmp(s, t) >= 0
|
||
|
|
|
||
|
|
def mpf_min_max(seq):
|
||
|
|
min = max = seq[0]
|
||
|
|
for x in seq[1:]:
|
||
|
|
if mpf_lt(x, min): min = x
|
||
|
|
if mpf_gt(x, max): max = x
|
||
|
|
return min, max
|
||
|
|
|
||
|
|
def mpf_pos(s, prec=0, rnd=round_fast):
|
||
|
|
"""Calculate 0+s for a raw mpf (i.e., just round s to the specified
|
||
|
|
precision)."""
|
||
|
|
if prec:
|
||
|
|
sign, man, exp, bc = s
|
||
|
|
if (not man) and exp:
|
||
|
|
return s
|
||
|
|
return normalize1(sign, man, exp, bc, prec, rnd)
|
||
|
|
return s
|
||
|
|
|
||
|
|
def mpf_neg(s, prec=None, rnd=round_fast):
|
||
|
|
"""Negate a raw mpf (return -s), rounding the result to the
|
||
|
|
specified precision. The prec argument can be omitted to do the
|
||
|
|
operation exactly."""
|
||
|
|
sign, man, exp, bc = s
|
||
|
|
if not man:
|
||
|
|
if exp:
|
||
|
|
if s == finf: return fninf
|
||
|
|
if s == fninf: return finf
|
||
|
|
return s
|
||
|
|
if not prec:
|
||
|
|
return (1-sign, man, exp, bc)
|
||
|
|
return normalize1(1-sign, man, exp, bc, prec, rnd)
|
||
|
|
|
||
|
|
def mpf_abs(s, prec=None, rnd=round_fast):
|
||
|
|
"""Return abs(s) of the raw mpf s, rounded to the specified
|
||
|
|
precision. The prec argument can be omitted to generate an
|
||
|
|
exact result."""
|
||
|
|
sign, man, exp, bc = s
|
||
|
|
if (not man) and exp:
|
||
|
|
if s == fninf:
|
||
|
|
return finf
|
||
|
|
return s
|
||
|
|
if not prec:
|
||
|
|
if sign:
|
||
|
|
return (0, man, exp, bc)
|
||
|
|
return s
|
||
|
|
return normalize1(0, man, exp, bc, prec, rnd)
|
||
|
|
|
||
|
|
def mpf_sign(s):
|
||
|
|
"""Return -1, 0, or 1 (as a Python int, not a raw mpf) depending on
|
||
|
|
whether s is negative, zero, or positive. (Nan is taken to give 0.)"""
|
||
|
|
sign, man, exp, bc = s
|
||
|
|
if not man:
|
||
|
|
if s == finf: return 1
|
||
|
|
if s == fninf: return -1
|
||
|
|
return 0
|
||
|
|
return (-1) ** sign
|
||
|
|
|
||
|
|
def mpf_add(s, t, prec=0, rnd=round_fast, _sub=0):
|
||
|
|
"""
|
||
|
|
Add the two raw mpf values s and t.
|
||
|
|
|
||
|
|
With prec=0, no rounding is performed. Note that this can
|
||
|
|
produce a very large mantissa (potentially too large to fit
|
||
|
|
in memory) if exponents are far apart.
|
||
|
|
"""
|
||
|
|
ssign, sman, sexp, sbc = s
|
||
|
|
tsign, tman, texp, tbc = t
|
||
|
|
tsign ^= _sub
|
||
|
|
# Standard case: two nonzero, regular numbers
|
||
|
|
if sman and tman:
|
||
|
|
offset = sexp - texp
|
||
|
|
if offset:
|
||
|
|
if offset > 0:
|
||
|
|
# Outside precision range; only need to perturb
|
||
|
|
if offset > 100 and prec:
|
||
|
|
delta = sbc + sexp - tbc - texp
|
||
|
|
if delta > prec + 4:
|
||
|
|
offset = prec + 4
|
||
|
|
sman <<= offset
|
||
|
|
if tsign == ssign: sman += 1
|
||
|
|
else: sman -= 1
|
||
|
|
return normalize1(ssign, sman, sexp-offset,
|
||
|
|
bitcount(sman), prec, rnd)
|
||
|
|
# Add
|
||
|
|
if ssign == tsign:
|
||
|
|
man = tman + (sman << offset)
|
||
|
|
# Subtract
|
||
|
|
else:
|
||
|
|
if ssign: man = tman - (sman << offset)
|
||
|
|
else: man = (sman << offset) - tman
|
||
|
|
if man >= 0:
|
||
|
|
ssign = 0
|
||
|
|
else:
|
||
|
|
man = -man
|
||
|
|
ssign = 1
|
||
|
|
bc = bitcount(man)
|
||
|
|
return normalize1(ssign, man, texp, bc, prec or bc, rnd)
|
||
|
|
elif offset < 0:
|
||
|
|
# Outside precision range; only need to perturb
|
||
|
|
if offset < -100 and prec:
|
||
|
|
delta = tbc + texp - sbc - sexp
|
||
|
|
if delta > prec + 4:
|
||
|
|
offset = prec + 4
|
||
|
|
tman <<= offset
|
||
|
|
if ssign == tsign: tman += 1
|
||
|
|
else: tman -= 1
|
||
|
|
return normalize1(tsign, tman, texp-offset,
|
||
|
|
bitcount(tman), prec, rnd)
|
||
|
|
# Add
|
||
|
|
if ssign == tsign:
|
||
|
|
man = sman + (tman << -offset)
|
||
|
|
# Subtract
|
||
|
|
else:
|
||
|
|
if tsign: man = sman - (tman << -offset)
|
||
|
|
else: man = (tman << -offset) - sman
|
||
|
|
if man >= 0:
|
||
|
|
ssign = 0
|
||
|
|
else:
|
||
|
|
man = -man
|
||
|
|
ssign = 1
|
||
|
|
bc = bitcount(man)
|
||
|
|
return normalize1(ssign, man, sexp, bc, prec or bc, rnd)
|
||
|
|
# Equal exponents; no shifting necessary
|
||
|
|
if ssign == tsign:
|
||
|
|
man = tman + sman
|
||
|
|
else:
|
||
|
|
if ssign: man = tman - sman
|
||
|
|
else: man = sman - tman
|
||
|
|
if man >= 0:
|
||
|
|
ssign = 0
|
||
|
|
else:
|
||
|
|
man = -man
|
||
|
|
ssign = 1
|
||
|
|
bc = bitcount(man)
|
||
|
|
return normalize(ssign, man, texp, bc, prec or bc, rnd)
|
||
|
|
# Handle zeros and special numbers
|
||
|
|
if _sub:
|
||
|
|
t = mpf_neg(t)
|
||
|
|
if not sman:
|
||
|
|
if sexp:
|
||
|
|
if s == t or tman or not texp:
|
||
|
|
return s
|
||
|
|
return fnan
|
||
|
|
if tman:
|
||
|
|
return normalize1(tsign, tman, texp, tbc, prec or tbc, rnd)
|
||
|
|
return t
|
||
|
|
if texp:
|
||
|
|
return t
|
||
|
|
if sman:
|
||
|
|
return normalize1(ssign, sman, sexp, sbc, prec or sbc, rnd)
|
||
|
|
return s
|
||
|
|
|
||
|
|
def mpf_sub(s, t, prec=0, rnd=round_fast):
|
||
|
|
"""Return the difference of two raw mpfs, s-t. This function is
|
||
|
|
simply a wrapper of mpf_add that changes the sign of t."""
|
||
|
|
return mpf_add(s, t, prec, rnd, 1)
|
||
|
|
|
||
|
|
def mpf_sum(xs, prec=0, rnd=round_fast, absolute=False):
|
||
|
|
"""
|
||
|
|
Sum a list of mpf values efficiently and accurately
|
||
|
|
(typically no temporary roundoff occurs). If prec=0,
|
||
|
|
the final result will not be rounded either.
|
||
|
|
|
||
|
|
There may be roundoff error or cancellation if extremely
|
||
|
|
large exponent differences occur.
|
||
|
|
|
||
|
|
With absolute=True, sums the absolute values.
|
||
|
|
"""
|
||
|
|
man = 0
|
||
|
|
exp = 0
|
||
|
|
max_extra_prec = prec*2 or 1000000 # XXX
|
||
|
|
special = None
|
||
|
|
for x in xs:
|
||
|
|
xsign, xman, xexp, xbc = x
|
||
|
|
if xman:
|
||
|
|
if xsign and not absolute:
|
||
|
|
xman = -xman
|
||
|
|
delta = xexp - exp
|
||
|
|
if xexp >= exp:
|
||
|
|
# x much larger than existing sum?
|
||
|
|
# first: quick test
|
||
|
|
if (delta > max_extra_prec) and \
|
||
|
|
((not man) or delta-bitcount(abs(man)) > max_extra_prec):
|
||
|
|
man = xman
|
||
|
|
exp = xexp
|
||
|
|
else:
|
||
|
|
man += (xman << delta)
|
||
|
|
else:
|
||
|
|
delta = -delta
|
||
|
|
# x much smaller than existing sum?
|
||
|
|
if delta-xbc > max_extra_prec:
|
||
|
|
if not man:
|
||
|
|
man, exp = xman, xexp
|
||
|
|
else:
|
||
|
|
man = (man << delta) + xman
|
||
|
|
exp = xexp
|
||
|
|
elif xexp:
|
||
|
|
if absolute:
|
||
|
|
x = mpf_abs(x)
|
||
|
|
special = mpf_add(special or fzero, x, 1)
|
||
|
|
# Will be inf or nan
|
||
|
|
if special:
|
||
|
|
return special
|
||
|
|
return from_man_exp(man, exp, prec, rnd)
|
||
|
|
|
||
|
|
def gmpy_mpf_mul(s, t, prec=0, rnd=round_fast):
|
||
|
|
"""Multiply two raw mpfs"""
|
||
|
|
ssign, sman, sexp, sbc = s
|
||
|
|
tsign, tman, texp, tbc = t
|
||
|
|
sign = ssign ^ tsign
|
||
|
|
man = sman*tman
|
||
|
|
if man:
|
||
|
|
bc = bitcount(man)
|
||
|
|
if prec:
|
||
|
|
return normalize1(sign, man, sexp+texp, bc, prec, rnd)
|
||
|
|
else:
|
||
|
|
return (sign, man, sexp+texp, bc)
|
||
|
|
s_special = (not sman) and sexp
|
||
|
|
t_special = (not tman) and texp
|
||
|
|
if not s_special and not t_special:
|
||
|
|
return fzero
|
||
|
|
if fnan in (s, t): return fnan
|
||
|
|
if (not tman) and texp: s, t = t, s
|
||
|
|
if t == fzero: return fnan
|
||
|
|
return {1:finf, -1:fninf}[mpf_sign(s) * mpf_sign(t)]
|
||
|
|
|
||
|
|
def gmpy_mpf_mul_int(s, n, prec, rnd=round_fast):
|
||
|
|
"""Multiply by a Python integer."""
|
||
|
|
sign, man, exp, bc = s
|
||
|
|
if not man:
|
||
|
|
return mpf_mul(s, from_int(n), prec, rnd)
|
||
|
|
if not n:
|
||
|
|
return fzero
|
||
|
|
if n < 0:
|
||
|
|
sign ^= 1
|
||
|
|
n = -n
|
||
|
|
man *= n
|
||
|
|
return normalize(sign, man, exp, bitcount(man), prec, rnd)
|
||
|
|
|
||
|
|
def python_mpf_mul(s, t, prec=0, rnd=round_fast):
|
||
|
|
"""Multiply two raw mpfs"""
|
||
|
|
ssign, sman, sexp, sbc = s
|
||
|
|
tsign, tman, texp, tbc = t
|
||
|
|
sign = ssign ^ tsign
|
||
|
|
man = sman*tman
|
||
|
|
if man:
|
||
|
|
bc = sbc + tbc - 1
|
||
|
|
bc += int(man>>bc)
|
||
|
|
if prec:
|
||
|
|
return normalize1(sign, man, sexp+texp, bc, prec, rnd)
|
||
|
|
else:
|
||
|
|
return (sign, man, sexp+texp, bc)
|
||
|
|
s_special = (not sman) and sexp
|
||
|
|
t_special = (not tman) and texp
|
||
|
|
if not s_special and not t_special:
|
||
|
|
return fzero
|
||
|
|
if fnan in (s, t): return fnan
|
||
|
|
if (not tman) and texp: s, t = t, s
|
||
|
|
if t == fzero: return fnan
|
||
|
|
return {1:finf, -1:fninf}[mpf_sign(s) * mpf_sign(t)]
|
||
|
|
|
||
|
|
def python_mpf_mul_int(s, n, prec, rnd=round_fast):
|
||
|
|
"""Multiply by a Python integer."""
|
||
|
|
sign, man, exp, bc = s
|
||
|
|
if not man:
|
||
|
|
return mpf_mul(s, from_int(n), prec, rnd)
|
||
|
|
if not n:
|
||
|
|
return fzero
|
||
|
|
if n < 0:
|
||
|
|
sign ^= 1
|
||
|
|
n = -n
|
||
|
|
man *= n
|
||
|
|
# Generally n will be small
|
||
|
|
if n < 1024:
|
||
|
|
bc += bctable[int(n)] - 1
|
||
|
|
else:
|
||
|
|
bc += bitcount(n) - 1
|
||
|
|
bc += int(man>>bc)
|
||
|
|
return normalize(sign, man, exp, bc, prec, rnd)
|
||
|
|
|
||
|
|
|
||
|
|
if BACKEND == 'gmpy':
|
||
|
|
mpf_mul = gmpy_mpf_mul
|
||
|
|
mpf_mul_int = gmpy_mpf_mul_int
|
||
|
|
else:
|
||
|
|
mpf_mul = python_mpf_mul
|
||
|
|
mpf_mul_int = python_mpf_mul_int
|
||
|
|
|
||
|
|
def mpf_shift(s, n):
|
||
|
|
"""Quickly multiply the raw mpf s by 2**n without rounding."""
|
||
|
|
sign, man, exp, bc = s
|
||
|
|
if not man:
|
||
|
|
return s
|
||
|
|
return sign, man, exp+n, bc
|
||
|
|
|
||
|
|
def mpf_frexp(x):
|
||
|
|
"""Convert x = y*2**n to (y, n) with abs(y) in [0.5, 1) if nonzero"""
|
||
|
|
sign, man, exp, bc = x
|
||
|
|
if not man:
|
||
|
|
if x == fzero:
|
||
|
|
return (fzero, 0)
|
||
|
|
else:
|
||
|
|
raise ValueError
|
||
|
|
return mpf_shift(x, -bc-exp), bc+exp
|
||
|
|
|
||
|
|
def mpf_div(s, t, prec, rnd=round_fast):
|
||
|
|
"""Floating-point division"""
|
||
|
|
ssign, sman, sexp, sbc = s
|
||
|
|
tsign, tman, texp, tbc = t
|
||
|
|
if not sman or not tman:
|
||
|
|
if s == fzero:
|
||
|
|
if t == fzero: raise ZeroDivisionError
|
||
|
|
if t == fnan: return fnan
|
||
|
|
return fzero
|
||
|
|
if t == fzero:
|
||
|
|
raise ZeroDivisionError
|
||
|
|
s_special = (not sman) and sexp
|
||
|
|
t_special = (not tman) and texp
|
||
|
|
if s_special and t_special:
|
||
|
|
return fnan
|
||
|
|
if s == fnan or t == fnan:
|
||
|
|
return fnan
|
||
|
|
if not t_special:
|
||
|
|
if t == fzero:
|
||
|
|
return fnan
|
||
|
|
return {1:finf, -1:fninf}[mpf_sign(s) * mpf_sign(t)]
|
||
|
|
return fzero
|
||
|
|
sign = ssign ^ tsign
|
||
|
|
if tman == 1:
|
||
|
|
return normalize1(sign, sman, sexp-texp, sbc, prec, rnd)
|
||
|
|
# Same strategy as for addition: if there is a remainder, perturb
|
||
|
|
# the result a few bits outside the precision range before rounding
|
||
|
|
extra = prec - sbc + tbc + 5
|
||
|
|
if extra < 5:
|
||
|
|
extra = 5
|
||
|
|
quot, rem = divmod(sman<<extra, tman)
|
||
|
|
if rem:
|
||
|
|
quot = (quot<<1) + 1
|
||
|
|
extra += 1
|
||
|
|
return normalize1(sign, quot, sexp-texp-extra, bitcount(quot), prec, rnd)
|
||
|
|
return normalize(sign, quot, sexp-texp-extra, bitcount(quot), prec, rnd)
|
||
|
|
|
||
|
|
def mpf_rdiv_int(n, t, prec, rnd=round_fast):
|
||
|
|
"""Floating-point division n/t with a Python integer as numerator"""
|
||
|
|
sign, man, exp, bc = t
|
||
|
|
if not n or not man:
|
||
|
|
return mpf_div(from_int(n), t, prec, rnd)
|
||
|
|
if n < 0:
|
||
|
|
sign ^= 1
|
||
|
|
n = -n
|
||
|
|
extra = prec + bc + 5
|
||
|
|
quot, rem = divmod(n<<extra, man)
|
||
|
|
if rem:
|
||
|
|
quot = (quot<<1) + 1
|
||
|
|
extra += 1
|
||
|
|
return normalize1(sign, quot, -exp-extra, bitcount(quot), prec, rnd)
|
||
|
|
return normalize(sign, quot, -exp-extra, bitcount(quot), prec, rnd)
|
||
|
|
|
||
|
|
def mpf_mod(s, t, prec, rnd=round_fast):
|
||
|
|
ssign, sman, sexp, sbc = s
|
||
|
|
tsign, tman, texp, tbc = t
|
||
|
|
if ((not sman) and sexp) or ((not tman) and texp):
|
||
|
|
return fnan
|
||
|
|
# Important special case: do nothing if t is larger
|
||
|
|
if ssign == tsign and texp > sexp+sbc:
|
||
|
|
return s
|
||
|
|
# Another important special case: this allows us to do e.g. x % 1.0
|
||
|
|
# to find the fractional part of x, and it will work when x is huge.
|
||
|
|
if tman == 1 and sexp > texp+tbc:
|
||
|
|
return fzero
|
||
|
|
base = min(sexp, texp)
|
||
|
|
sman = (-1)**ssign * sman
|
||
|
|
tman = (-1)**tsign * tman
|
||
|
|
man = (sman << (sexp-base)) % (tman << (texp-base))
|
||
|
|
if man >= 0:
|
||
|
|
sign = 0
|
||
|
|
else:
|
||
|
|
man = -man
|
||
|
|
sign = 1
|
||
|
|
return normalize(sign, man, base, bitcount(man), prec, rnd)
|
||
|
|
|
||
|
|
reciprocal_rnd = {
|
||
|
|
round_down : round_up,
|
||
|
|
round_up : round_down,
|
||
|
|
round_floor : round_ceiling,
|
||
|
|
round_ceiling : round_floor,
|
||
|
|
round_nearest : round_nearest
|
||
|
|
}
|
||
|
|
|
||
|
|
negative_rnd = {
|
||
|
|
round_down : round_down,
|
||
|
|
round_up : round_up,
|
||
|
|
round_floor : round_ceiling,
|
||
|
|
round_ceiling : round_floor,
|
||
|
|
round_nearest : round_nearest
|
||
|
|
}
|
||
|
|
|
||
|
|
def mpf_pow_int(s, n, prec, rnd=round_fast):
|
||
|
|
"""Compute s**n, where s is a raw mpf and n is a Python integer."""
|
||
|
|
sign, man, exp, bc = s
|
||
|
|
|
||
|
|
if (not man) and exp:
|
||
|
|
if s == finf:
|
||
|
|
if n > 0: return s
|
||
|
|
if n == 0: return fnan
|
||
|
|
return fzero
|
||
|
|
if s == fninf:
|
||
|
|
if n > 0: return [finf, fninf][n & 1]
|
||
|
|
if n == 0: return fnan
|
||
|
|
return fzero
|
||
|
|
return fnan
|
||
|
|
|
||
|
|
n = int(n)
|
||
|
|
if n == 0: return fone
|
||
|
|
if n == 1: return mpf_pos(s, prec, rnd)
|
||
|
|
if n == 2:
|
||
|
|
_, man, exp, bc = s
|
||
|
|
if not man:
|
||
|
|
return fzero
|
||
|
|
man = man*man
|
||
|
|
if man == 1:
|
||
|
|
return (0, MPZ_ONE, exp+exp, 1)
|
||
|
|
bc = bc + bc - 2
|
||
|
|
bc += bctable[int(man>>bc)]
|
||
|
|
return normalize1(0, man, exp+exp, bc, prec, rnd)
|
||
|
|
if n == -1: return mpf_div(fone, s, prec, rnd)
|
||
|
|
if n < 0:
|
||
|
|
inverse = mpf_pow_int(s, -n, prec+5, reciprocal_rnd[rnd])
|
||
|
|
return mpf_div(fone, inverse, prec, rnd)
|
||
|
|
|
||
|
|
result_sign = sign & n
|
||
|
|
|
||
|
|
# Use exact integer power when the exact mantissa is small
|
||
|
|
if man == 1:
|
||
|
|
return (result_sign, MPZ_ONE, exp*n, 1)
|
||
|
|
if bc*n < 1000:
|
||
|
|
man **= n
|
||
|
|
return normalize1(result_sign, man, exp*n, bitcount(man), prec, rnd)
|
||
|
|
|
||
|
|
# Use directed rounding all the way through to maintain rigorous
|
||
|
|
# bounds for interval arithmetic
|
||
|
|
rounds_down = (rnd == round_nearest) or \
|
||
|
|
shifts_down[rnd][result_sign]
|
||
|
|
|
||
|
|
# Now we perform binary exponentiation. Need to estimate precision
|
||
|
|
# to avoid rounding errors from temporary operations. Roughly log_2(n)
|
||
|
|
# operations are performed.
|
||
|
|
workprec = prec + 4*bitcount(n) + 4
|
||
|
|
_, pm, pe, pbc = fone
|
||
|
|
while 1:
|
||
|
|
if n & 1:
|
||
|
|
pm = pm*man
|
||
|
|
pe = pe+exp
|
||
|
|
pbc += bc - 2
|
||
|
|
pbc = pbc + bctable[int(pm >> pbc)]
|
||
|
|
if pbc > workprec:
|
||
|
|
if rounds_down:
|
||
|
|
pm = pm >> (pbc-workprec)
|
||
|
|
else:
|
||
|
|
pm = -((-pm) >> (pbc-workprec))
|
||
|
|
pe += pbc - workprec
|
||
|
|
pbc = workprec
|
||
|
|
n -= 1
|
||
|
|
if not n:
|
||
|
|
break
|
||
|
|
man = man*man
|
||
|
|
exp = exp+exp
|
||
|
|
bc = bc + bc - 2
|
||
|
|
bc = bc + bctable[int(man >> bc)]
|
||
|
|
if bc > workprec:
|
||
|
|
if rounds_down:
|
||
|
|
man = man >> (bc-workprec)
|
||
|
|
else:
|
||
|
|
man = -((-man) >> (bc-workprec))
|
||
|
|
exp += bc - workprec
|
||
|
|
bc = workprec
|
||
|
|
n = n // 2
|
||
|
|
|
||
|
|
return normalize(result_sign, pm, pe, pbc, prec, rnd)
|
||
|
|
|
||
|
|
|
||
|
|
def mpf_perturb(x, eps_sign, prec, rnd):
|
||
|
|
"""
|
||
|
|
For nonzero x, calculate x + eps with directed rounding, where
|
||
|
|
eps < prec relatively and eps has the given sign (0 for
|
||
|
|
positive, 1 for negative).
|
||
|
|
|
||
|
|
With rounding to nearest, this is taken to simply normalize
|
||
|
|
x to the given precision.
|
||
|
|
"""
|
||
|
|
if rnd == round_nearest:
|
||
|
|
return mpf_pos(x, prec, rnd)
|
||
|
|
sign, man, exp, bc = x
|
||
|
|
eps = (eps_sign, MPZ_ONE, exp+bc-prec-1, 1)
|
||
|
|
if sign:
|
||
|
|
away = (rnd in (round_down, round_ceiling)) ^ eps_sign
|
||
|
|
else:
|
||
|
|
away = (rnd in (round_up, round_ceiling)) ^ eps_sign
|
||
|
|
if away:
|
||
|
|
return mpf_add(x, eps, prec, rnd)
|
||
|
|
else:
|
||
|
|
return mpf_pos(x, prec, rnd)
|
||
|
|
|
||
|
|
|
||
|
|
#----------------------------------------------------------------------------#
|
||
|
|
# Radix conversion #
|
||
|
|
#----------------------------------------------------------------------------#
|
||
|
|
|
||
|
|
def to_digits_exp(s, dps):
|
||
|
|
"""Helper function for representing the floating-point number s as
|
||
|
|
a decimal with dps digits. Returns (sign, string, exponent) where
|
||
|
|
sign is '' or '-', string is the digit string, and exponent is
|
||
|
|
the decimal exponent as an int.
|
||
|
|
|
||
|
|
If inexact, the decimal representation is rounded toward zero."""
|
||
|
|
|
||
|
|
# Extract sign first so it doesn't mess up the string digit count
|
||
|
|
if s[0]:
|
||
|
|
sign = '-'
|
||
|
|
s = mpf_neg(s)
|
||
|
|
else:
|
||
|
|
sign = ''
|
||
|
|
_sign, man, exp, bc = s
|
||
|
|
|
||
|
|
if not man:
|
||
|
|
return '', '0', 0
|
||
|
|
|
||
|
|
bitprec = int(dps * math.log(10,2)) + 10
|
||
|
|
|
||
|
|
# Cut down to size
|
||
|
|
# TODO: account for precision when doing this
|
||
|
|
exp_from_1 = exp + bc
|
||
|
|
if abs(exp_from_1) > 3500:
|
||
|
|
from .libelefun import mpf_ln2, mpf_ln10
|
||
|
|
# Set b = int(exp * log(2)/log(10))
|
||
|
|
# If exp is huge, we must use high-precision arithmetic to
|
||
|
|
# find the nearest power of ten
|
||
|
|
expprec = bitcount(abs(exp)) + 5
|
||
|
|
tmp = from_int(exp)
|
||
|
|
tmp = mpf_mul(tmp, mpf_ln2(expprec))
|
||
|
|
tmp = mpf_div(tmp, mpf_ln10(expprec), expprec)
|
||
|
|
b = to_int(tmp)
|
||
|
|
s = mpf_div(s, mpf_pow_int(ften, b, bitprec), bitprec)
|
||
|
|
_sign, man, exp, bc = s
|
||
|
|
exponent = b
|
||
|
|
else:
|
||
|
|
exponent = 0
|
||
|
|
|
||
|
|
# First, calculate mantissa digits by converting to a binary
|
||
|
|
# fixed-point number and then converting that number to
|
||
|
|
# a decimal fixed-point number.
|
||
|
|
fixprec = max(bitprec - exp - bc, 0)
|
||
|
|
fixdps = int(fixprec / math.log(10,2) + 0.5)
|
||
|
|
sf = to_fixed(s, fixprec)
|
||
|
|
sd = bin_to_radix(sf, fixprec, 10, fixdps)
|
||
|
|
digits = numeral(sd, base=10, size=dps)
|
||
|
|
|
||
|
|
exponent += len(digits) - fixdps - 1
|
||
|
|
return sign, digits, exponent
|
||
|
|
|
||
|
|
def to_str(s, dps, strip_zeros=True, min_fixed=None, max_fixed=None,
|
||
|
|
show_zero_exponent=False):
|
||
|
|
"""
|
||
|
|
Convert a raw mpf to a decimal floating-point literal with at
|
||
|
|
most `dps` decimal digits in the mantissa (not counting extra zeros
|
||
|
|
that may be inserted for visual purposes).
|
||
|
|
|
||
|
|
The number will be printed in fixed-point format if the position
|
||
|
|
of the leading digit is strictly between min_fixed
|
||
|
|
(default = min(-dps/3,-5)) and max_fixed (default = dps).
|
||
|
|
|
||
|
|
To force fixed-point format always, set min_fixed = -inf,
|
||
|
|
max_fixed = +inf. To force floating-point format, set
|
||
|
|
min_fixed >= max_fixed.
|
||
|
|
|
||
|
|
The literal is formatted so that it can be parsed back to a number
|
||
|
|
by to_str, float() or Decimal().
|
||
|
|
"""
|
||
|
|
|
||
|
|
# Special numbers
|
||
|
|
if not s[1]:
|
||
|
|
if s == fzero:
|
||
|
|
if dps: t = '0.0'
|
||
|
|
else: t = '.0'
|
||
|
|
if show_zero_exponent:
|
||
|
|
t += 'e+0'
|
||
|
|
return t
|
||
|
|
if s == finf: return '+inf'
|
||
|
|
if s == fninf: return '-inf'
|
||
|
|
if s == fnan: return 'nan'
|
||
|
|
raise ValueError
|
||
|
|
|
||
|
|
if min_fixed is None: min_fixed = min(-(dps//3), -5)
|
||
|
|
if max_fixed is None: max_fixed = dps
|
||
|
|
|
||
|
|
# to_digits_exp rounds to floor.
|
||
|
|
# This sometimes kills some instances of "...00001"
|
||
|
|
sign, digits, exponent = to_digits_exp(s, dps+3)
|
||
|
|
|
||
|
|
# No digits: show only .0; round exponent to nearest
|
||
|
|
if not dps:
|
||
|
|
if digits[0] in '56789':
|
||
|
|
exponent += 1
|
||
|
|
digits = ".0"
|
||
|
|
|
||
|
|
else:
|
||
|
|
# Rounding up kills some instances of "...99999"
|
||
|
|
if len(digits) > dps and digits[dps] in '56789':
|
||
|
|
digits = digits[:dps]
|
||
|
|
i = dps - 1
|
||
|
|
while i >= 0 and digits[i] == '9':
|
||
|
|
i -= 1
|
||
|
|
if i >= 0:
|
||
|
|
digits = digits[:i] + str(int(digits[i]) + 1) + '0' * (dps - i - 1)
|
||
|
|
else:
|
||
|
|
digits = '1' + '0' * (dps - 1)
|
||
|
|
exponent += 1
|
||
|
|
else:
|
||
|
|
digits = digits[:dps]
|
||
|
|
|
||
|
|
# Prettify numbers close to unit magnitude
|
||
|
|
if min_fixed < exponent < max_fixed:
|
||
|
|
if exponent < 0:
|
||
|
|
digits = ("0"*int(-exponent)) + digits
|
||
|
|
split = 1
|
||
|
|
else:
|
||
|
|
split = exponent + 1
|
||
|
|
if split > dps:
|
||
|
|
digits += "0"*(split-dps)
|
||
|
|
exponent = 0
|
||
|
|
else:
|
||
|
|
split = 1
|
||
|
|
|
||
|
|
digits = (digits[:split] + "." + digits[split:])
|
||
|
|
|
||
|
|
if strip_zeros:
|
||
|
|
# Clean up trailing zeros
|
||
|
|
digits = digits.rstrip('0')
|
||
|
|
if digits[-1] == ".":
|
||
|
|
digits += "0"
|
||
|
|
|
||
|
|
if exponent == 0 and dps and not show_zero_exponent: return sign + digits
|
||
|
|
if exponent >= 0: return sign + digits + "e+" + str(exponent)
|
||
|
|
if exponent < 0: return sign + digits + "e" + str(exponent)
|
||
|
|
|
||
|
|
def str_to_man_exp(x, base=10):
|
||
|
|
"""Helper function for from_str."""
|
||
|
|
x = x.lower().rstrip('l')
|
||
|
|
# Verify that the input is a valid float literal
|
||
|
|
float(x)
|
||
|
|
# Split into mantissa, exponent
|
||
|
|
parts = x.split('e')
|
||
|
|
if len(parts) == 1:
|
||
|
|
exp = 0
|
||
|
|
else: # == 2
|
||
|
|
x = parts[0]
|
||
|
|
exp = int(parts[1])
|
||
|
|
# Look for radix point in mantissa
|
||
|
|
parts = x.split('.')
|
||
|
|
if len(parts) == 2:
|
||
|
|
a, b = parts[0], parts[1].rstrip('0')
|
||
|
|
exp -= len(b)
|
||
|
|
x = a + b
|
||
|
|
x = MPZ(int(x, base))
|
||
|
|
return x, exp
|
||
|
|
|
||
|
|
special_str = {'inf':finf, '+inf':finf, '-inf':fninf, 'nan':fnan}
|
||
|
|
|
||
|
|
def from_str(x, prec, rnd=round_fast):
|
||
|
|
"""Create a raw mpf from a decimal literal, rounding in the
|
||
|
|
specified direction if the input number cannot be represented
|
||
|
|
exactly as a binary floating-point number with the given number of
|
||
|
|
bits. The literal syntax accepted is the same as for Python
|
||
|
|
floats.
|
||
|
|
|
||
|
|
TODO: the rounding does not work properly for large exponents.
|
||
|
|
"""
|
||
|
|
x = x.lower().strip()
|
||
|
|
if x in special_str:
|
||
|
|
return special_str[x]
|
||
|
|
|
||
|
|
if '/' in x:
|
||
|
|
p, q = x.split('/')
|
||
|
|
p, q = p.rstrip('l'), q.rstrip('l')
|
||
|
|
return from_rational(int(p), int(q), prec, rnd)
|
||
|
|
|
||
|
|
man, exp = str_to_man_exp(x, base=10)
|
||
|
|
|
||
|
|
# XXX: appropriate cutoffs & track direction
|
||
|
|
# note no factors of 5
|
||
|
|
if abs(exp) > 400:
|
||
|
|
s = from_int(man, prec+10)
|
||
|
|
s = mpf_mul(s, mpf_pow_int(ften, exp, prec+10), prec, rnd)
|
||
|
|
else:
|
||
|
|
if exp >= 0:
|
||
|
|
s = from_int(man * 10**exp, prec, rnd)
|
||
|
|
else:
|
||
|
|
s = from_rational(man, 10**-exp, prec, rnd)
|
||
|
|
return s
|
||
|
|
|
||
|
|
# Binary string conversion. These are currently mainly used for debugging
|
||
|
|
# and could use some improvement in the future
|
||
|
|
|
||
|
|
def from_bstr(x):
|
||
|
|
man, exp = str_to_man_exp(x, base=2)
|
||
|
|
man = MPZ(man)
|
||
|
|
sign = 0
|
||
|
|
if man < 0:
|
||
|
|
man = -man
|
||
|
|
sign = 1
|
||
|
|
bc = bitcount(man)
|
||
|
|
return normalize(sign, man, exp, bc, bc, round_floor)
|
||
|
|
|
||
|
|
def to_bstr(x):
|
||
|
|
sign, man, exp, bc = x
|
||
|
|
return ['','-'][sign] + numeral(man, size=bitcount(man), base=2) + ("e%i" % exp)
|
||
|
|
|
||
|
|
|
||
|
|
#----------------------------------------------------------------------------#
|
||
|
|
# Square roots #
|
||
|
|
#----------------------------------------------------------------------------#
|
||
|
|
|
||
|
|
|
||
|
|
def mpf_sqrt(s, prec, rnd=round_fast):
|
||
|
|
"""
|
||
|
|
Compute the square root of a nonnegative mpf value. The
|
||
|
|
result is correctly rounded.
|
||
|
|
"""
|
||
|
|
sign, man, exp, bc = s
|
||
|
|
if sign:
|
||
|
|
raise ComplexResult("square root of a negative number")
|
||
|
|
if not man:
|
||
|
|
return s
|
||
|
|
if exp & 1:
|
||
|
|
exp -= 1
|
||
|
|
man <<= 1
|
||
|
|
bc += 1
|
||
|
|
elif man == 1:
|
||
|
|
return normalize1(sign, man, exp//2, bc, prec, rnd)
|
||
|
|
shift = max(4, 2*prec-bc+4)
|
||
|
|
shift += shift & 1
|
||
|
|
if rnd in 'fd':
|
||
|
|
man = isqrt(man<<shift)
|
||
|
|
else:
|
||
|
|
man, rem = sqrtrem(man<<shift)
|
||
|
|
# Perturb up
|
||
|
|
if rem:
|
||
|
|
man = (man<<1)+1
|
||
|
|
shift += 2
|
||
|
|
return from_man_exp(man, (exp-shift)//2, prec, rnd)
|
||
|
|
|
||
|
|
def mpf_hypot(x, y, prec, rnd=round_fast):
|
||
|
|
"""Compute the Euclidean norm sqrt(x**2 + y**2) of two raw mpfs
|
||
|
|
x and y."""
|
||
|
|
if y == fzero: return mpf_abs(x, prec, rnd)
|
||
|
|
if x == fzero: return mpf_abs(y, prec, rnd)
|
||
|
|
hypot2 = mpf_add(mpf_mul(x,x), mpf_mul(y,y), prec+4)
|
||
|
|
return mpf_sqrt(hypot2, prec, rnd)
|
||
|
|
|
||
|
|
|
||
|
|
if BACKEND == 'sage':
|
||
|
|
try:
|
||
|
|
import sage.libs.mpmath.ext_libmp as ext_lib
|
||
|
|
mpf_add = ext_lib.mpf_add
|
||
|
|
mpf_sub = ext_lib.mpf_sub
|
||
|
|
mpf_mul = ext_lib.mpf_mul
|
||
|
|
mpf_div = ext_lib.mpf_div
|
||
|
|
mpf_sqrt = ext_lib.mpf_sqrt
|
||
|
|
except ImportError:
|
||
|
|
pass
|