四舍五入到任意数量的有效数字
-
03-07-2019 - |
题
你怎么能圆 任何 数字(不仅仅是大于 0 的整数)到 N 个有效数字?
例如,如果我想四舍五入到三位有效数字,我正在寻找一个可以采用的公式:
1,239,451 并返回 1,240,000
12.1257并返回12.1
.0681 并返回 .0681
5 并返回 5
当然,该算法不应该被硬编码为仅处理 3 中的 N,尽管这只是一个开始。
解决方案
这是 Java 中的相同代码,没有其他答案的 12.100000000000001 bug
我还删除了重复的代码,更改了 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;
}
其他提示
这是一个简短而有趣的 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
概括:
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 1239451 = 6.09
log 12.1257 = 1.08
log 0.0681 = -1.16
因此,对于大于 0 的数字,取对数的 ceil。对于 < 0 的数字,取日志的底数。
现在我们有了数字 d
: :第一种情况为 7,第二种情况为 2,第三种情况为 -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))
其中power是上面计算的功率。
关于准确度:Pyrolistical的答案确实更接近真实结果。但请注意,在任何情况下都无法准确表示 12.1。如果您按如下方式打印答案:
System.out.println(new BigDecimal(n));
答案是:
Pyro's: 12.0999999999999996447286321199499070644378662109375
Mine: 12.10000000000000142108547152020037174224853515625
Printing 12.1 directly: 12.0999999999999996447286321199499070644378662109375
所以,使用 Pyro 的答案!
这不是“简短而甜蜜”的 JavaScript 实现吗?
Number(n).toPrecision(sig)
例如
alert(Number(12345).toPrecision(3)
?
抱歉,我不是在这里开玩笑,只是使用 Claudiu 的“roundit”函数和 JavaScript 中的 .toPrecision 给了我不同的结果,但仅限于最后一位数字的四舍五入。
JavaScript:
Number(8.14301).toPrecision(4) == 8.143
。网
roundit(8.14301,4) == 8.144
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;
}
这个java解决方案怎么样:
double roundToSignificantFigure(double num, int precision){ return new BigDecimal(num) .round(new MathContext(precision, RoundingMode.HALF_EVEN)) .doubleValue(); }
这是 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;
}
这件事晚了 5 年,但我会分享给仍然遇到同样问题的其他人。我喜欢它,因为它很简单,并且代码端没有计算。看 用于显示有效数字的内置方法 了解更多信息。
这是如果您只想打印出来的话。
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);
您是否尝试过像手工编写代码一样进行编码?
- 将数字转换为字符串
- 从 字符串,计数数字 - 前导零不是 重要的是,其他一切都是。
- 当你到达“第n个”数字时, 提前查看下一个数字,如果 它是 5 或更高,四舍五入。
- 将所有尾随数字替换为零。
[更正,2009-10-26]
本质上,对于 N 显着 分数 数字:
• 将数字乘以 10氮
• 添加 0.5
• 截断小数位(即将结果截断为整数)
• 除以10氮
对于 N 显着 不可缺少的 (非小数)数字:
• 将数字除以10氮
• 添加 0.5
• 截断小数位(即将结果截断为整数)
• 乘以10氮
您可以在任何计算器上执行此操作,例如,具有“INT”(整数截断)运算符的计算器。
/**
* 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);
}
这是 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
JavaScript:
Number( my_number.toPrecision(3) );
这 Number
函数将改变表单的输出 "8.143e+5"
到 "814300"
.
这是我在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
return new BigDecimal(value, new MathContext(significantFigures, RoundingMode.HALF_UP)).doubleValue();
我在 Go 中需要这个,由于 Go 标准库缺乏 math.Round()
(go1.10之前)。所以我也必须把它搞起来。这是我的翻译 Pyrolistical 的精彩答案:
// 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
}
public static double roundToSignificantDigits(double num, int n) {
return Double.parseDouble(new java.util.Formatter().format("%." + (n - 1) + "e", num).toString());
}
此代码使用内置格式化函数,该函数将转换为舍入函数