3

我需要使用 JavaScript 确定浮点数是否是另一个浮点数的倍数。

我已经阅读了一些关于浮点数的其他问题，并且了解到它们不能与模运算符 (%) 一起正常工作。我还读到您可以通过乘以 10/100/1000 等将浮点数转换为整数，但这并非在所有情况下都能正常工作。

例子：

var A = 25.13;
var B = .0001;

var Value = A*1e5;
var Step  = B*1e5;

// Is Value a multiple of Step?
if(0 === (Value % Step)) {
// Do something
}

在这种情况下，Value 是 Step 的倍数，它可以正常工作。但是关于：

var A = 2.2;
var B = .0001;

它应该是一个有效的倍数，但我们得到的是：

220000.00000000003 % 10 = 2.9103830456733704e-11

小数点后 11 位有错误的 3。我想我可以通过以下方式纠正四舍五入的问题toFixed()：

var Value = (A*1e5).toFixed(10);
var Step  = (B*1e5).toFixed(10);

但如果你这样做：

var A = 45436212356482;
var B = .0001;

你得到：

4543621235648200192.0000000000 % 10.0000000000=2

这是一个有效的倍数，但它认为它不是。

和：

var A = 45436212546522156.45621565421;
var B = .0001;

这不是一个有效的倍数，但它认为它是：

4.543621254652216e+21 % 10.0000000000=0

是否有一个聪明的技巧来确定一个浮点数是否是另一个浮点数的倍数？或者这是不可能的？

更新：

目标是将用户输入的数字（整数或小数）限制为一定的增量。

  • 如果 Increment 为 1，则用户可以输入 1、2、3、4 等。
  • 如果增量为 0.5，用户可以输入 0.5、1、1.5、2、2.5 等。
  • 如果增量为 .0002，用户可以输入 1,1.001,1.0004,1.0006，但不能输入 1.0001

从逻辑角度来看，给定值是或不是给定增量的有效倍数。

4

7 回答 7

4

鉴于您的最后两个示例，使用 4543621235648200192 等，您似乎想要接受 0.0001 的整数倍数并拒绝那些不是的数字，并且您不想使用 .0001 而是使用包含浮动的变量来执行此操作 -点值最接近 0.0001。

一般来说，这是不可能的。当您传递其他东西时，算法无法“知道” .0001 是有意的。

如果您对问题进行更多限制，则可能有解决方案。例如，有可能（也许不容易）回答这个问题：浮点值 X 是最接近 0.0001 的整数倍的浮点值吗？（换句话说，是否有一个整数 k 使得 .0001 乘以 k 并四舍五入到最接近的浮点值正好产生 X？）

因此，要获得解决方案，您需要进一步描述您的目标。您是否想要 Step 的任意值或仅某些值的解决方案？由于二进制浮点不能足够精确地表示 Step，您有其他方式来描述它吗？例如，它是否总是 0.0001 的倍数？您想要作为倍数接受的值是否始终是最接近精确数学倍数的二进制浮点数，还是可能有其他错误？

于 2012-09-14T18:05:26.097 回答
2

基本问题是 32 位浮点数不能正确表示所有实数。例如，如果用户输入 0.1，则浮点数的值为 0.099999994。

因此，如果您有 0.1 的增量，您无法判断他是否输入了 0.1（这将是有效的），或者他是否输入了 0.09999..（这将是无效的）。

我的建议是改用整数数据类型并将其视为定点数。这样您就不会失去精度，并且可以轻松检查多重性。

于 2012-09-14T19:45:38.030 回答
0

如果我错了，请纠正我，但解决方案如下：

function IsMultipleOf(a, b) {
   var result = a % b;
   return (result < 1e-3);
}

只回答了一半的问题。假设以下（使用python代码）：

dt = 2.4
>>> dt = 2.2999999999999998
t = 13 * dt
>>> t = 29.899999999999999
t % dt
>>> 8.8817841970012523e-16

在这种情况下，它会正常工作。现在假设：

dt = 1.4
>>> dt = 1.3999999999999999
t = 3 * dt
>>> t = 4.1999999999999993
t % dt
>>> 1.3999999999999995

由于舍入误差的作用使得t低于dt的下一个倍数，因此模的值更接近dt而不是 0。

解决此问题的一种可能方法是检查两种情况：

modt = t % dt
(abs(modt) <= tolerance) or (abs(dt - modt) <= tolerance)

根据这个答案tolerance = machine epsilon * abs(dt) / 2， 我期望在哪里，但是模运算以某种方式引入了比这更多的错误。看起来像：

tolerance = machine epsilon * max(abs(t), abs(dt)) / 2

处理这项工作，但这只是一个猜测。或者，

tolerance = 2 * machine epsilon * abs(dt)

似乎也可以正常工作。

于 2014-01-23T15:20:48.560 回答
0

以下适用于所有小数。

var result = Math.round( Math.round(number1 * 100000) % Math.round(number2 * 100000) ) / 100000;
于 2014-12-29T10:55:22.647 回答
0

这是您可以做到的一种方法：

function floatingPointAMultipleOfB(a, b) {
  const precision_a = getNumbersAfterDecimal(a)
  const precision_b = getNumbersAfterDecimal(b)

  if (precision_a > precision_b) return false;

  const int_a = Math.round(multBy10(a, precision_b))
  const int_b = Math.round(multBy10(b, precision_b))
  return int_a % int_b === 0
}


function getNumbersAfterDecimal(n) {
  const exponential = n.toString().split('e');
  if (exponential.length === 2) n = n.toFixed(Math.abs(exponential[1]))
  return (n.toString().split('.')[1] || []).length;
}

function multBy10(val, n) {
  if (n === 0) return val
  return multBy10(val, n-1) * 10
}
于 2018-10-17T16:40:27.050 回答
-2

由于您正在处理浮点数，因此最好的办法是确定“接近”的接近程度，并使用它：

function IsMultipleOf(a, b) {
   var result = a % b;
   return (result < 1e-3);
}
于 2012-09-14T17:41:07.350 回答
-2

我需要使用 JavaScript 确定浮点数是否是另一个浮点数的倍数。

如果我们假设浮点数用于逼近实数，那么根据定义，每个浮点数都是另一个数的倍数。当然，由于浮点数实际上是有理数的子集，所以当然有很多对浮点数没有共同的浮点除数。例如，尾数中具有不同素数系数的任何两个浮点数都没有公约数。指数的范围进一步限制了精确倍数的对。

但也许您不是在寻找具有任意乘法因子的数字，而是寻找具有整数除数的数字并测试结果是否低于所选阈值（通常称为 epsilon）。

例如函数式伪代码！

fmod :: float -> float -> float
fmod a b =
    b - a * floor( b / a )

EPSILON = 1e-5;
divides_to_integer :: float -> float -> boolean
divides_to_integer a b =
    fmod(a, b) < EPSILON

fmod 函数应该取自 JavaScript 数学库。

于 2012-09-14T17:48:16.677 回答