L'arrondi à un nombre arbitraire de chiffres significatifs

Que pensez-vous de cette solution java:

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

Voici une version modifiée du JavaScript D'Ates qui traite les nombres négatifs.

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

c'est arrivé avec 5 ans de retard, mais je partagerai avec d'autres le même problème. Je l'aime parce que c'est simple et aucun calcul du côté du code. Voir méthodes intégrées pour afficher les chiffres significatifs pour plus d'information.

C'est si vous voulez juste l'imprimer.

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

C'est si vous voulez convertir:

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

voici un exemple en action:

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

avez-vous essayé de le coder comme vous le feriez à la main?

1. convertissez le nombre en chaîne de caractères
2. à partir du début du chaîne, le comte chiffres - zéros ne sont pas important, tout le reste est.
3. quand vous arrivez au chiffre "nth" , regardez en avant au prochain chiffre et si c'est 5 ou plus, le round up.
4. remplacer tous les chiffres de queue par des zéros.

[corrigé, 2009-10-26]

essentiellement, pour N significatif fractionnaire chiffres:

• multiplier le nombre par 10 ^N

" * Ajouter 0.5

• Tronquer les chiffres de la fraction (c.-à-d. tronquer le résultat en un entier)

* Diviser par 10 ^N

Pour N significatif intégrale (non-fractionnée) chiffres:

• divisez le nombre par 10 ^N

* Ajouter 0.5

• Tronquer les chiffres de la fraction (c.-à-d. tronquer le résultat en un entier)

* Multiplier par 10 ^N

vous pouvez faire cela sur n'importe quelle calculatrice, par exemple, qui a un "INT" (entier troncature) opérateur.

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

voici le code de Pyrolistical (TOP answer) dans Visual Basic.NET, si quelqu'un en a besoin:

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

la fonction Number modifiera la sortie de la forme "8.143e+5" en "814300" .

C'est celui que j'ai trouvé dans 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();

j'en avais besoin à Go, ce qui était un peu compliqué par le manque de math.Round() de la bibliothèque standard de Go (avant go1.10). J'ai donc eu à fouetter que trop. Voici ma traduction de excellente réponse de 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());
}

ce code utilise la fonction de formatage intégrée qui est transformée en une fonction d'arrondissement