Làm thế nào bạn có thể làm tròn bất kỳ số nào (không chỉ số nguyên> 0) thành N chữ số có nghĩa?
Ví dụ: nếu tôi muốn làm tròn thành ba chữ số có nghĩa, tôi đang tìm một công thức có thể lấy:
1.239.451 và trả lại 1.240.000
12.1257 và trả về 12.1
.0681 và trả về .0681
5 và trả về 5
Đương nhiên, thuật toán không nên được mã hóa cứng để chỉ xử lý N trong 3, mặc dù đó sẽ là một bước khởi đầu.
Câu trả lời:
Đây là mã tương tự trong Java mà không có lỗi 12.100000000000001 các câu trả lời khác có
Tôi cũng đã xóa mã lặp lại, thay đổi powerthành kiểu số nguyên để tránh các vấn đề nổi khi n - dhoàn tất và làm rõ ràng hơn trung gian dài
Lỗi là do nhân một số lớn với một số nhỏ. Thay vào đó tôi chia hai số có kích thước tương tự nhau.
EDIT
Sửa nhiều lỗi hơn. Đã thêm kiểm tra cho 0 vì nó sẽ dẫn đến NaN. Đã làm cho hàm thực sự hoạt động với các số âm (Mã ban đầu không xử lý các số âm vì nhật ký của một số âm là một số phức)
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;
}
Đây là một triển khai JavaScript ngắn gọn và thú vị:
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
n==0:)
Math.log(n) / Math.LN10hơn là Math.log10(n)?
Math.floor(x) == Math.ceil(x) - 1? Bởi vì nó không phải xlà một số nguyên. Tôi nghĩ đối số thứ hai của powhàm nên là sig - Math.ceil(Math.log(n) / Math.LN10)(hoặc chỉ sử dụng Math.log10)
TÓM LƯỢC:
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);
}
Vì vậy, bạn cần tìm vị trí thập phân của chữ số khác 0 đầu tiên, sau đó lưu N-1 chữ số tiếp theo, sau đó làm tròn chữ số thứ N dựa trên phần còn lại.
Chúng ta có thể sử dụng nhật ký để làm việc đầu tiên.
log 1239451 = 6.09
log 12.1257 = 1.08
log 0.0681 = -1.16
Vì vậy, đối với các số> 0, hãy lấy điểm cuối của nhật ký. Đối với các số <0, lấy tầng của nhật ký.
Bây giờ chúng ta có chữ số d: 7 trong trường hợp đầu tiên, 2 trong trường hợp thứ 2, -2 trong trường hợp thứ 3.
Chúng ta phải làm tròn (d-N)chữ số thứ. Cái gì đó như:
double roundedrest = num * pow(10, -(d-N));
pow(1239451, -4) = 123.9451
pow(12.1257, 1) = 121.257
pow(0.0681, 4) = 681
Sau đó, thực hiện điều làm tròn tiêu chuẩn:
roundedrest = (int)(roundedrest + 0.5);
Và hoàn tác các pow.
roundednum = pow(roundedrest, -(power))
Công suất là công suất được tính ở trên.
Về độ chính xác: Câu trả lời của Pyrolistical thực sự gần với kết quả thực hơn. Nhưng lưu ý rằng bạn không thể đại diện chính xác 12.1 trong mọi trường hợp. Nếu bạn in câu trả lời như sau:
System.out.println(new BigDecimal(n));
Câu trả lời là:
Pyro's: 12.0999999999999996447286321199499070644378662109375
Mine: 12.10000000000000142108547152020037174224853515625
Printing 12.1 directly: 12.0999999999999996447286321199499070644378662109375
Vì vậy, hãy sử dụng câu trả lời của Pyro!
Không phải là triển khai JavaScript "ngắn và hấp dẫn"
Number(n).toPrecision(sig)
ví dụ
alert(Number(12345).toPrecision(3)
?
Xin lỗi, tôi không quá lo lắng ở đây, chỉ là việc sử dụng hàm "roundit" từ Claudiu và .toPre precision trong JavaScript mang lại cho tôi các kết quả khác nhau nhưng chỉ làm tròn chữ số cuối cùng.
JavaScript:
Number(8.14301).toPrecision(4) == 8.143
.MẠNG LƯỚI
roundit(8.14301,4) == 8.144
Number(814301).toPrecision(4) == "8.143e+5". Nói chung không phải những gì bạn muốn nếu bạn đang hiển thị điều này cho người dùng.
Giải pháp (rất hay!) Của Pyrolistical vẫn có vấn đề. Giá trị nhân đôi lớn nhất trong Java có thứ tự là 10 ^ 308, trong khi giá trị nhỏ nhất có thứ tự là 10 ^ -324. Do đó, bạn có thể gặp rắc rối khi áp dụng hàm roundToSignificantFigurescho một thứ gì đó nằm trong phạm vi một vài quyền hạn của mười Double.MIN_VALUE. Ví dụ, khi bạn gọi
roundToSignificantFigures(1.234E-310, 3);
thì biến powersẽ có giá trị 3 - (-309) = 312. Do đó, biến magnitudesẽ trở thành Infinity, và tất cả đều là rác từ đó trở đi. May mắn thay, đây không phải là một vấn đề không thể vượt qua: nó chỉ là yếu tố magnitude tràn ra. Điều thực sự quan trọng là sản phẩm num * magnitude và điều đó không bị tràn. Một cách để giải quyết vấn đề này là chia phép nhân với thừa số magintudethành hai bước:
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;
}
Làm thế nào về giải pháp java này:
double roundToSignificantFigure (double num, int precision) {
trả về BigDecimal mới (num)
.round (MathContext mới (precision, RoundingMode.HALF_EVEN))
.doubleValue ();
}
Đây là phiên bản JavaScript được sửa đổi của Ates để xử lý các số âm.
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;
}
Điều này đến muộn 5 năm, nhưng mặc dù tôi sẽ chia sẻ cho những người khác vẫn gặp vấn đề tương tự. Tôi thích nó vì nó đơn giản và không có tính toán về mặt mã. Xem Các phương pháp tích hợp để hiển thị các số liệu quan trọng để biết thêm thông tin.
Đây là nếu bạn chỉ muốn in nó ra.
public String toSignificantFiguresString(BigDecimal bd, int significantFigures){
return String.format("%."+significantFigures+"G", bd);
}
Đây là nếu bạn muốn chuyển đổi nó:
public BigDecimal toSignificantFigures(BigDecimal bd, int significantFigures){
String s = String.format("%."+significantFigures+"G", bd);
BigDecimal result = new BigDecimal(s);
return result;
}
Đây là một ví dụ về nó trong hoạt động:
BigDecimal bd = toSignificantFigures(BigDecimal.valueOf(0.0681), 2);
Bạn đã thử mã hóa nó theo cách bạn làm bằng tay chưa?
[Đã sửa, 2009-10-26]
Về cơ bản, đối với N chữ số phân số có nghĩa :
• Nhân một số với 10 N
• Cộng 0,5
• Cắt ngắn các chữ số của phân số (tức là cắt bớt kết quả thành một số nguyên)
• Chia cho 10 N
Đối với N chữ số tích phân có nghĩa (không phải phân số):
• Chia số cho 10 N
• Cộng 0,5
• Cắt ngắn các chữ số của phân số (tức là cắt bớt kết quả thành một số nguyên)
• Nhân với 10 N
Bạn có thể thực hiện việc này trên bất kỳ máy tính nào, chẳng hạn, có toán tử "INT" (cắt bớt số nguyên).
/**
* 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);
}
Đây là mã của Pyrolistical (câu trả lời hàng đầu hiện nay) trong Visual Basic.NET, nếu bất kỳ ai cần nó:
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
return new BigDecimal(value, new MathContext(significantFigures, RoundingMode.HALF_UP)).doubleValue();
Tôi cần điều này trong Go, điều này hơi phức tạp do thư viện tiêu chuẩn Go thiếu math.Round()(trước go1.10). Vì vậy, tôi cũng phải đánh nó lên. Đây là bản dịch của tôi về câu trả lời xuất sắc của 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
}
Bạn có thể tránh thực hiện tất cả các phép tính này với lũy thừa 10, v.v. bằng cách sử dụng FloatToStrF.
FloatToStrF cho phép bạn (trong số những thứ khác) chọn độ chính xác (số lượng các số liệu quan trọng) trong giá trị đầu ra (sẽ là một chuỗi). Tất nhiên, sau đó bạn có thể áp dụng StrToFloat vào điều này để nhận giá trị làm tròn của bạn dưới dạng một float.
Xem tại đây:
public static double roundToSignificantDigits(double num, int n) {
return Double.parseDouble(new java.util.Formatter().format("%." + (n - 1) + "e", num).toString());
}
Mã này sử dụng hàm định dạng có sẵn được chuyển sang hàm làm tròn