Java 给定两个双精度，如何确定它们的商是否精确？
给定两个Java 给定两个双精度，如何确定它们的商是否精确？,java,math,floating-point,ieee-754,Java,Math,Floating Point,Ieee 754,给定两个double值，p和q，我如何确定它们的商： double result = p / q; 根据p和q的二进制值是否是精确的结果 也就是说，result是否正好等于p和q的数学除法 显然，这对于某些值是正确的，例如1.0/2.0，而对于其他值，例如1.0/5.0，则是错误的，因此我正在寻找一种惯用且准确的方法来区分这些情况 看起来浮点模数p%q==0可能会起作用，但我不确定 您可以使用BigDecimal查看除法是否精确： private static boolean canDivid
doublepqdouble result = p / q;
pqresultpq1.0/2.01.0/5.0看起来浮点模数
p%q==0BigDecimalprivate static boolean canDivideExact(double p, double q) {
double r = p / q;
BigDecimal d = new BigDecimal(r);
return d.multiply(new BigDecimal(q)).compareTo(new BigDecimal(p)) == 0;
}
System.out.println(canDivideExact(1, 2)); //true
System.out.println(canDivideExact(1, 3)); //false
您可以使用
BigDecimalprivate static boolean canDivideExact(double p, double q) {
double r = p / q;
BigDecimal d = new BigDecimal(r);
return d.multiply(new BigDecimal(q)).compareTo(new BigDecimal(p)) == 0;
}
System.out.println(canDivideExact(1, 2)); //true
System.out.println(canDivideExact(1, 3)); //false
我认为您的
p%q==0pqp/q1.0%2.0==1.01.0/2.0==0.5如果你想继续使用Java，你要么使用assylia的基于
BigDecimalfetestexcept（FE_incexecpt）p%q==0pqp/q1.0%2.0==1.01.0/2.0==0.5如果你想继续使用Java，你要么使用assylia的基于
BigDecimalfetestexcept（FE_incexecpt）BigDecimalemmdoublexx=m2^emxxyx/yxy%frexpMath.getExponentfrexpMath.scalbx/yzyzxBigDecimalfloatdoublefloatimport math
def odd_part(x):
"""
Return an odd integer m (as a double) such that x can be written
in the form m * 2**e for some exponent e. The exponent e is not
returned.
"""
fraction, exponent = math.frexp(x)
# here fraction * 2**53 is guaranteed to be an integer, so we
# don't need to loop more than 53 times.
while fraction % 1.0 != 0.0: # or in Python, use the is_integer method.
fraction *= 2.0
return fraction
# Constant used in Veltkamp splitting.
C = float.fromhex('0x1.0000002000000p+27')
def split(x):
"""
Split a double x into pieces x_hi, x_lo, each
expressible with 26 bits of precision.
Algorithm due to Veltkamp.
Parameters
----------
x : float
Finite float, such that C*x does not overflow. Assumes IEEE 754
representation and arithmetic, with round-ties-to-even rounding
mode.
Returns
-------
l, h : float
l and h are both representable in 26 bits of precision, and
x = l + h.
"""
# Idea of proof: without loss of generality, we can reduce to the case
# where 0.5 < x < 1 (the case where x is a power of 2 is straightforward).
# Write rnd for the floating-point rounding operation, so p = rnd(Cx) and q
# = rnd(x-p).
#
# Now let e and f be the errors induced by the floating-point operations,
# so
# p = Cx + e
# q = x - p + f
#
# Then it's easy to show that:
#
# 2**26 < |Cx| < 2**28, so p is a multiple of 2**-26 and |e| <= 2**-26.
# 2**26 <= p - x <= 2**27, so q is a multiple of 2**-26 and |f| <= 2**-27.
# h = p + q is exactly representable, equal to x + f
# h <= 1, and h is a multiple of 2**-26, so h has precision <= 26.
# l = x - h is exactly representable, equal to f.
# |f| <= 2**-27, and f is a multiple of 2**-53, so f has precision <= 26.
p = C * x
q = x - p
h = p + q
l = x - h
return l, h
def exact_mult(x, y):
"""
Multiply floats x and y exactly, expressing the result as l + h,
where h is the closest float to x * y and l is the error.
Algorithm is due to Dekker.
Assumes that x and y are finite IEEE 754 binary64 floats.
May return inf or nan due to intermediate overflow.
May raise ValueError on underflow or near-underflow.
If both results are finite, then we have equality:
x * y = h + l
"""
# Write |x| = M * 2**e, y = |N| * 2**f, for some M and N with
# M, N <= 2**53 - 1. Then xy = M*N*2**(e+f). If e + f <= -1075
# then xy < (2**53 - 1)**2 * 2**-1075 < 2**-969 (1 - 2**-53),
# which is exactly representable.
# Hence the rounded value of |xy| is also < 2**-969.
# So if |xy| >= 2**-969, and |xy| isn't near overflow, it follows that x*y
# *can* be expressed as the sum of two doubles:
# If |xy| < 2**-969, we can't guarantee it, and we raise ValueError.
h = x * y
if abs(h) < 2**-969 and x != 0.0 and y != 0.0:
raise ValueError("Cannot guarantee exact result.")
xl, xh = split(x)
yl, yh = split(y)
return -h + xh * yh + xh * yl + xl * yh + xl * yl, h
def division_exact_method_1(x, y):
"""
Given nonzero finite not-too-large not-too-small floats x and y,
return True if x / y is exactly representable, else False.
"""
return odd_part(x) % odd_part(y) == 0
def division_exact_method_2(x, y):
"""
Given nonzero finite not-too-large not-too-small floats x and y,
return True if x / y is exactly representable, else False.
"""
z = x / y
low, high = exact_mult(y, z)
return high == x and low == 0
导入数学
def奇数_零件（x）：
"""
返回一个奇数整数m（作为双精度），以便可以写入x
对于某些指数e，其形式为m*2**e。指数e不是
返回。
"""
分数，指数=math.frexp（x）
#这里分数*2**53保证是整数，所以我们
#不需要循环超过53次。
而分数%1.0！=0.0:#或者在Python中，使用is_integer方法。
分数*=2.0
返回分数
#用于Veltkamp拆分的常数。
C=浮点.fromhex（'0x1.000000200000p+27'）
def拆分（x）：
"""
把一个双x分成几块x_嗨，x_