舍入到任意数量的有效数字

时间:2008-10-14 18:37:18

标签: algorithm rounding significant-digits

如何将任何号码(不只是整数> 0)舍入到N位有效数字?

例如,如果我想要舍入到三位有效数字,我正在寻找可能采用的公式:

1,239,451并返回1,240,000

12.1257并​​返回12.1

.0681并返回.0681

5并返回5

自然地,算法不应该被硬编码为仅处理3的N,尽管这将是一个开始。

18 个答案:

答案 0 :(得分:100)

这是Java中没有12.100000000000001错误的其他答案的相同代码

我还删除了重复的代码,将power更改为类型整数,以防止在n - d完成时浮动问题,并使长中间更清晰

错误是由一个较大的数字乘以一个小数字引起的。相反,我划分了两个相似大小的数字。

修改
修正了更多错误。添加了0的检查,因为它会导致NaN。使该函数实际上使用负数(原始代码不处理负数,因为负数的对数是一个复数)

public static double roundToSignificantFigures(double num, int n) {
    if(num == 0) {
        return 0;
    }

    final double d = Math.ceil(Math.log10(num < 0 ? -num: num));
    final int power = n - (int) d;

    final double magnitude = Math.pow(10, power);
    final long shifted = Math.round(num*magnitude);
    return shifted/magnitude;
}

答案 1 :(得分:15)

内容:

double roundit(double num, double N)
{
    double d = log10(num);
    double power;
    if (num > 0)
    {
        d = ceil(d);
        power = -(d-N);
    }
    else
    {
        d = floor(d); 
        power = -(d-N);
    }

    return (int)(num * pow(10.0, power) + 0.5) * pow(10.0, -power);
}

所以你需要找到第一个非零数字的小数位,然后保存下一个N-1个数字,然后根据其余数字围绕第N个数字。

我们可以使用log来做第一个。

log 1239451 = 6.09
log 12.1257 = 1.08
log 0.0681  = -1.16

所以对于数字&gt; 0,取日志的细胞。对于数字&lt; 0,登录日志。

现在我们在第一种情况下有数字d:7,在第二种情况下为2,在第3种情况下为-2。

我们必须围绕(d-N)位数。类似的东西:

double roundedrest = num * pow(10, -(d-N));

pow(1239451, -4) = 123.9451
pow(12.1257, 1)  = 121.257
pow(0.0681, 4)   = 681

然后做标准的舍入事情:

roundedrest = (int)(roundedrest + 0.5);

撤消战俘。

roundednum = pow(roundedrest, -(power))

权力是上面计算的权力。


关于准确性:Pyrolistical的答案确实更接近真实结果。但请注意,在任何情况下都不能完全代表12.1。如果您打印答案如下:

System.out.println(new BigDecimal(n));

答案是:

Pyro's: 12.0999999999999996447286321199499070644378662109375
Mine: 12.10000000000000142108547152020037174224853515625
Printing 12.1 directly: 12.0999999999999996447286321199499070644378662109375

所以,请使用Pyro的答案!

答案 2 :(得分:15)

这是一个简短而又甜蜜的JavaScript实现:

function sigFigs(n, sig) {
    var mult = Math.pow(10, sig - Math.floor(Math.log(n) / Math.LN10) - 1);
    return Math.round(n * mult) / mult;
}

alert(sigFigs(1234567, 3)); // Gives 1230000
alert(sigFigs(0.06805, 3)); // Gives 0.0681
alert(sigFigs(5, 3)); // Gives 5

答案 3 :(得分:10)

不是“短而甜蜜”的JavaScript实现

Number(n).toPrecision(sig)

e.g。

alert(Number(12345).toPrecision(3)

对不起,我在这里不是很滑稽,只是使用Claudiu的“roundit”函数和JavaScript中的.toPrecision给了我不同的结果,但只是在最后一位数的四舍五入。

JavaScript的:

Number(8.14301).toPrecision(4) == 8.143

.NET

roundit(8.14301,4) == 8.144

答案 4 :(得分:7)

Pyrolistical(非常好!)解决方案仍有问题。 Java中的最大double值大约为10 ^ 308,而最小值大约为10 ^ -324。因此,在将函数roundToSignificantFigures应用于Double.MIN_VALUE的十个幂的范围内时,您可能会遇到麻烦。例如,当您致电

roundToSignificantFigures(1.234E-310, 3);

然后变量power将具有值3 - (-309)= 312.因此,变量magnitude将变为Infinity,并且从那时起它就是垃圾。幸运的是,这不是一个不可逾越的问题:只有因子 magnitude溢出。真正重要的是产品 num * magnitude,并且不会溢出。解决这个问题的一种方法是将因子magintude乘以两个步骤:


 public static double roundToNumberOfSignificantDigits(double num, int n) {

    final double maxPowerOfTen = Math.floor(Math.log10(Double.MAX_VALUE));

    if(num == 0) {
        return 0;
    }

    final double d = Math.ceil(Math.log10(num < 0 ? -num: num));
    final int power = n - (int) d;

    double firstMagnitudeFactor = 1.0;
    double secondMagnitudeFactor = 1.0;
    if (power > maxPowerOfTen) {
        firstMagnitudeFactor = Math.pow(10.0, maxPowerOfTen);
        secondMagnitudeFactor = Math.pow(10.0, (double) power - maxPowerOfTen);
    } else {
        firstMagnitudeFactor = Math.pow(10.0, (double) power);
    }

    double toBeRounded = num * firstMagnitudeFactor;
    toBeRounded *= secondMagnitudeFactor;

    final long shifted = Math.round(toBeRounded);
    double rounded = ((double) shifted) / firstMagnitudeFactor;
    rounded /= secondMagnitudeFactor;
    return rounded;
}

答案 5 :(得分:6)

这个java解决方案怎么样:

double roundToSignificantFigure(double num, int precision){
 return new BigDecimal(num)
            .round(new MathContext(precision, RoundingMode.HALF_EVEN))
            .doubleValue(); 
}

答案 6 :(得分:3)

以下是处理负数的Ates'JavaScript的修改版本。

function sigFigs(n, sig) {
    if ( n === 0 )
        return 0
    var mult = Math.pow(10,
        sig - Math.floor(Math.log(n < 0 ? -n: n) / Math.LN10) - 1);
    return Math.round(n * mult) / mult;
 }

答案 7 :(得分:2)

这迟了5年,但我会分享其他人仍然有同样的问题。我喜欢它,因为它很简单,没有代码方面的计算。 有关详细信息,请参阅Built in methods for displaying Significant figures

如果您只是想将其打印出来。

public String toSignificantFiguresString(BigDecimal bd, int significantFigures){
    return String.format("%."+significantFigures+"G", bd);
}

如果你想转换它:

public BigDecimal toSignificantFigures(BigDecimal bd, int significantFigures){
    String s = String.format("%."+significantFigures+"G", bd);
    BigDecimal result = new BigDecimal(s);
    return result;
}

这是一个实际的例子:

BigDecimal bd = toSignificantFigures(BigDecimal.valueOf(0.0681), 2);

答案 8 :(得分:1)

您是否尝试过以手动方式编写代码?

  1. 将数字转换为字符串
  2. 从头开始 字符串,计数数字 - 前导零不是 重要的是,其他一切都是。
  3. 当你到达“第n”个数字时, 向前看下一个数字,如果 它是5或更高,向上。
  4. 用零替换所有尾随数字。

答案 9 :(得分:1)

的JavaScript:

Number( my_number.toPrecision(3) );

Number功能会将表单"8.143e+5"的输出更改为"814300"

答案 10 :(得分:1)

如果有人需要,可以使用Visual Basic.NET中的Pyrolistical(目前最常见的答案)代码:

Public Shared Function roundToSignificantDigits(ByVal num As Double, ByVal n As Integer) As Double
    If (num = 0) Then
        Return 0
    End If

    Dim d As Double = Math.Ceiling(Math.Log10(If(num < 0, -num, num)))
    Dim power As Integer = n - CInt(d)
    Dim magnitude As Double = Math.Pow(10, power)
    Dim shifted As Double = Math.Round(num * magnitude)
    Return shifted / magnitude
End Function

答案 11 :(得分:1)

/**
 * Set Significant Digits.
 * @param value value
 * @param digits digits
 * @return
 */
public static BigDecimal setSignificantDigits(BigDecimal value, int digits) {
    //# Start with the leftmost non-zero digit (e.g. the "1" in 1200, or the "2" in 0.0256).
    //# Keep n digits. Replace the rest with zeros.
    //# Round up by one if appropriate.
    int p = value.precision();
    int s = value.scale();
    if (p < digits) {
        value = value.setScale(s + digits - p); //, RoundingMode.HALF_UP
    }
    value = value.movePointRight(s).movePointLeft(p - digits).setScale(0, RoundingMode.HALF_UP)
        .movePointRight(p - digits).movePointLeft(s);
    s = (s > (p - digits)) ? (s - (p - digits)) : 0;
    return value.setScale(s);
}

答案 12 :(得分:1)

[更正,2009-10-26]

基本上,对于N个重要的小数数字:

•将数字乘以10 N
•添加0.5
•截断小数位(即,将结果截断为整数)
•除以10 N

对于N个重要积分(非小数)数字:

•将数字除以10 N
•添加0.5
•截断小数位(即,将结果截断为整数)
•乘以10 N

您可以在任何计算器上执行此操作,例如,具有“INT”(整数截断)运算符。

答案 13 :(得分:0)

这是我在VB中提出的:

Function SF(n As Double, SigFigs As Integer)
    Dim l As Integer = n.ToString.Length
    n = n / 10 ^ (l - SigFigs)
    n = Math.Round(n)
    n = n * 10 ^ (l - SigFigs)
    Return n
End Function

答案 14 :(得分:0)

return new BigDecimal(value, new MathContext(significantFigures, RoundingMode.HALF_UP)).doubleValue();

答案 15 :(得分:0)

我在Go中需要这个,Go标准库缺少math.Round()(在go1.10之前)有点复杂。所以我不得不鞭打它。这是我对Pyrolistical's excellent answer的翻译:

// TODO: replace in go1.10 with math.Round()
func round(x float64) float64 {
    return float64(int64(x + 0.5))
}

// SignificantDigits rounds a float64 to digits significant digits.
// Translated from Java at https://stackoverflow.com/a/1581007/1068283
func SignificantDigits(x float64, digits int) float64 {
    if x == 0 {
        return 0
    }

    power := digits - int(math.Ceil(math.Log10(math.Abs(x))))
    magnitude := math.Pow(10, float64(power))
    shifted := round(x * magnitude)
    return shifted / magnitude
}

答案 16 :(得分:0)

只需使用FloatToStrF,就可以避免以10等的幂进行所有这些计算。

FloatToStrF允许您(除其他外)在输出值(将是字符串)中选择精度(有效数字数量)。当然,然后可以将StrToFloat应用于此值,以将四舍五入后的值作为浮点数。

查看此处:

http://docs.embarcadero.com/products/rad_studio/delphiAndcpp2009/HelpUpdate2/EN/html/delphivclwin32/SysUtils_FloatToStrF@Extended@TFloatFormat@Integer@Integer.html

答案 17 :(得分:-1)

public static double roundToSignificantDigits(double num, int n) {
    return Double.parseDouble(new java.util.Formatter().format("%." + (n - 1) + "e", num).toString());
}

此代码使用内置格式化功能,该功能转为舍入功能