Zaokrąglanie do dowolnej liczby cyfr znaczących

Jak zaokrąglić dowolną liczbę (nie tylko liczby całkowite> 0) do N cyfr znaczących?

Na przykład, jeśli chcę zaokrąglić do trzech cyfr znaczących, szukam formuły, która mogłaby przyjąć:

1 239 451 i zwraca 1 240 000

12.1257 i powrót 12.1

.0681 i zwraca .0681

5 i wróć 5

Naturalnie algorytm nie powinien być zakodowany na stałe tak, aby obsługiwał tylko N z 3, chociaż byłby to początek.

Oto ten sam kod w Javie bez błędu 12.100000000000001, który mają inne odpowiedzi

Usunąłem również powtarzający się kod, zmieniłem powerna typ całkowity, aby zapobiec problemom związanym z pływaniem po n - dzakończeniu, i uczyniłem długi pośredni bardziej przejrzystym

Błąd był spowodowany pomnożeniem dużej liczby przez małą. Zamiast tego dzielę dwie liczby o podobnej wielkości.

EDYCJA
Naprawiono więcej błędów. Dodano czek na 0, ponieważ spowodowałoby to NaN. Sprawiono, że funkcja faktycznie działa z liczbami ujemnymi (oryginalny kod nie obsługuje liczb ujemnych, ponieważ dziennik liczb ujemnych jest liczbą zespoloną)

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;
}

Oto krótka i słodka implementacja 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

PODSUMOWANIE:

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);
}

Musisz więc znaleźć miejsce dziesiętne pierwszej niezerowej cyfry, a następnie zapisać następne N-1 cyfry, a następnie zaokrąglić N-tą cyfrę na podstawie reszty.

Możemy użyć dziennika, aby zrobić pierwszy.

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

Więc dla liczb> 0, weź górną część dziennika. W przypadku liczb <0 zajmij podłogę dziennika.

Teraz mamy cyfrę d: 7 w pierwszym przypadku, 2 w drugim, -2 w trzecim.

Musimy zaokrąglić tę (d-N)cyfrę. Coś jak:

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

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

Następnie wykonaj standardowe zaokrąglenie:

roundedrest = (int)(roundedrest + 0.5);

I cofnij pow.

roundednum = pow(roundedrest, -(power))

Gdzie moc to moc obliczona powyżej.

O dokładności: odpowiedź pirolisty jest rzeczywiście bliższa rzeczywistemu wynikowi. Ale pamiętaj, że w żadnym wypadku nie możesz dokładnie reprezentować 12.1. Jeśli wydrukujesz odpowiedzi w następujący sposób:

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

Odpowiedzi są następujące:

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

A więc użyj odpowiedzi Pyro!

Czy to nie „krótka i słodka” implementacja JavaScript

Number(n).toPrecision(sig)

na przykład

alert(Number(12345).toPrecision(3)

?

Przepraszam, nie żartuję, po prostu użycie funkcji „roundit” z Claudiu i .toPrecision w JavaScript daje mi różne wyniki, ale tylko w zaokrągleniu ostatniej cyfry.

JavaScript:

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

.NETTO

roundit(8.14301,4) == 8.144

Rozwiązanie pirolistyczne (bardzo ładne!) Wciąż zawiera problem. Maksymalna podwójna wartość w Javie jest rzędu 10 ^ 308, podczas gdy minimalna jest rzędu 10 ^ -324. Dlatego możesz wpaść w kłopoty, stosując funkcję roundToSignificantFiguresdo czegoś, co znajduje się w granicach kilku potęg dziesięciu Double.MIN_VALUE. Na przykład, kiedy dzwonisz

roundToSignificantFigures(1.234E-310, 3);

wtedy zmienna powerbędzie miała wartość 3 - (-309) = 312. W konsekwencji zmienna magnitudestanie się Infinityi odtąd wszystko będzie śmieciem. Na szczęście nie jest to problem nie do pokonania: to tylko czynnik, magnitude który przepełnia. Tak naprawdę liczy się produkt num * magnitude , który się nie przepełnia. Jednym ze sposobów rozwiązania tego problemu jest podzielenie mnożenia przez współczynnik magintudena dwa etapy:

 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;
}

Co powiesz na to rozwiązanie Java:

double roundToSsequantFigure (double num, int precyzyjność) {
 zwraca nowe BigDecimal (num)
            .round (nowy MathContext (precyzja, RoundingMode.HALF_EVEN))
            .doubleValue (); 
}

Oto zmodyfikowana wersja JavaScript firmy Ates, która obsługuje liczby ujemne.

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;
 }

Spóźniło się to 5 lat, ale podzielę się tym, aby inni nadal mieli ten sam problem. Podoba mi się to, ponieważ jest proste i nie ma obliczeń po stronie kodu. Aby uzyskać więcej informacji, zobacz Wbudowane metody wyświetlania liczb znaczących .

Dzieje się tak, jeśli chcesz go po prostu wydrukować.

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

To jest, jeśli chcesz go przekonwertować:

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

Oto przykład tego w akcji:

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

JavaScript:

Number( my_number.toPrecision(3) );

NumberFunkcja zmieni wyjście postaci "8.143e+5"do "814300".

Czy próbowałeś po prostu zakodować to tak, jak zrobiłbyś to ręcznie?

1. Zamień liczbę na ciąg
2. Zaczynając od początku ciągu, policz cyfry - wiodące zera nie są znaczące, wszystko inne jest.
3. Kiedy dojdziesz do „n-tej” cyfry, spójrz przed siebie na następną cyfrę i jeśli jest to 5 lub więcej, zaokrąglij w górę.
4. Zastąp wszystkie końcowe cyfry zerami.

[Poprawiono, 2009-10-26]

Zasadniczo dla N znaczących cyfr ułamkowych :

• Pomnóż liczbę przez 10 ^N
• Dodaj 0,5
• Obetnij cyfry ułamkowe (tj. Skróć wynik do liczby całkowitej)
• Podziel przez 10 ^N

Dla N znaczących cyfr całkowitych (nieułamkowych):

• Podziel liczbę przez 10 ^N
• Dodaj 0,5
• Obetnij cyfry ułamkowe (tj. Skróć wynik do liczby całkowitej)
• Pomnóż przez 10 ^N

Możesz to zrobić na dowolnym kalkulatorze, na przykład, który ma operator „INT” (obcięcie liczby całkowitej).

/**
 * 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);
}

Oto kod Pyrolistics (obecnie najlepsza odpowiedź) w Visual Basic.NET, gdyby ktoś go potrzebował:

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

Oto ten, który wymyśliłem w 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();

Potrzebowałem tego w Go, co było nieco skomplikowane przez brak standardowej biblioteki Go math.Round()(przed go1.10). Więc musiałem to też podnieść. Oto moje tłumaczenie doskonałej odpowiedzi Pyrolisticsa :

// 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
}

Możesz uniknąć wykonywania wszystkich tych obliczeń z potęgami 10 itd., Używając po prostu FloatToStrF.

FloatToStrF umożliwia (między innymi) wybranie dokładności (liczby cyfr znaczących) wartości wyjściowej (która będzie ciągiem znaków). Oczywiście możesz następnie zastosować do tego StrToFloat, aby uzyskać zaokrągloną wartość jako zmiennoprzecinkową.

Spójrz tutaj:

http://docs.embarcadero.com/products/rad_studio/delphiAndcpp2009/HelpUpdate2/EN/html/delphivclwin32/SysUtils_FloatToStrF@Extended@TFloatFormat@[email protected]

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

Ten kod używa wbudowanej funkcji formatowania, która została zamieniona na funkcję zaokrąglania