Arredondando para um número arbitrário de dígitos significativos

Como você pode arredondar qualquer número (não apenas inteiros> 0) para N dígitos significativos?

Por exemplo, se eu quiser arredondar para três dígitos significativos, estou procurando uma fórmula que possa ter:

1.239.451 e retorno 1.240.000

12,1257 e retorno 12,1

0,0681 e retorno 0,0681

5 e retorno 5

Naturalmente, o algoritmo não deve ser codificado para lidar apenas com N de 3, embora isso fosse um começo.

Aqui está o mesmo código em Java sem o bug 12.100000000000001 que outras respostas têm

Também removi o código repetido, mudei powerpara um tipo inteiro para evitar problemas de flutuação quando n - dterminar e tornei o intermediário longo mais claro

O bug foi causado pela multiplicação de um grande número por um pequeno número. Em vez disso, divido dois números de tamanho semelhante.

EDIT
Corrigido mais bugs. Adicionada verificação de 0, pois resultaria em NaN. Fez a função funcionar realmente com números negativos (o código original não lida com números negativos porque um log de um número negativo é um número complexo)

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

Aqui está uma implementação de JavaScript curta e agradável:

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

RESUMO:

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

Portanto, você precisa encontrar a casa decimal do primeiro dígito diferente de zero, salvar os próximos N-1 dígitos e arredondar o enésimo dígito com base no resto.

Podemos usar o log para fazer o primeiro.

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

Portanto, para números> 0, calcule o teto do log. Para números <0, tome o chão do log.

Agora temos o dígito d: 7 no primeiro caso, 2 no segundo, -2 no terceiro.

Temos que arredondar o (d-N)décimo dígito. Algo como:

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

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

Em seguida, faça o arredondamento padrão:

roundedrest = (int)(roundedrest + 0.5);

E desfaça o pow.

roundednum = pow(roundedrest, -(power))

Onde a potência é a potência calculada acima.

Sobre a precisão: a resposta da pirólise está de fato mais próxima do resultado real. Mas observe que você não pode representar 12,1 exatamente em qualquer caso. Se você imprimir as respostas da seguinte forma:

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

As respostas são:

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

Então, use a resposta do Pyro!

Não é a implementação "curta e agradável" de JavaScript

Number(n).toPrecision(sig)

por exemplo

alert(Number(12345).toPrecision(3)

?

Desculpe, não estou sendo jocoso aqui, é só que usar a função "roundit" de Claudiu e .toPrecision em JavaScript me dá resultados diferentes, mas apenas no arredondamento do último dígito.

JavaScript:

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

.INTERNET

roundit(8.14301,4) == 8.144

A solução pirolística (muito boa!) Ainda tem um problema. O valor duplo máximo em Java é da ordem de 10 ^ 308, enquanto o valor mínimo é da ordem de 10 ^ -324. Portanto, você pode ter problemas ao aplicar a função roundToSignificantFiguresa algo que está dentro de algumas potências de dez de Double.MIN_VALUE. Por exemplo, quando você liga

roundToSignificantFigures(1.234E-310, 3);

então a variável powerterá o valor 3 - (-309) = 312. Consequentemente, a variável magnitudese tornará Infinity, e é tudo lixo a partir de então. Felizmente, esse não é um problema intransponível: é apenas o fator magnitude que está transbordando. O que importa mesmo é o produto num * magnitude , e isso não transborda. Uma maneira de resolver isso é dividir a multiplicação pelo fator magintudeem duas etapas:

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

Que tal esta solução java:

double roundToSignificantFigure (double num, int precision) {
 retornar novo BigDecimal (num)
            .round (novo MathContext (precisão, RoundingMode.HALF_EVEN))
            .doubleValue (); 
}

Aqui está uma versão modificada do JavaScript de Ates que lida com números negativos.

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

Isso veio 5 anos atrasado, mas vou compartilhar com outras pessoas que ainda têm o mesmo problema. Eu gosto porque é simples e sem cálculos no lado do código. Consulte Métodos integrados para exibição de figuras significativas para obter mais informações.

Isso se você quiser apenas imprimi-lo.

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

Se você quiser convertê-lo:

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

Aqui está um exemplo disso em ação:

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

JavaScript:

Number( my_number.toPrecision(3) );

A Numberfunção mudará a saída do formulário "8.143e+5"para "814300".

Você já tentou codificá-lo da maneira como faria à mão?

1. Converta o número em uma string
2. Começando no início da string, conte os dígitos - zeros à esquerda não são significativos, todo o resto é.
3. Quando você chegar ao "enésimo" dígito, dê uma olhada no próximo dígito e, se for 5 ou mais, arredonde para cima.
4. Substitua todos os dígitos finais por zeros.

[Corrigido, 26/10/2009]

Essencialmente, para N dígitos fracionários significativos :

• Multiplique o número por 10 ^N
• Some 0,5
• Trunque os dígitos da fração (ou seja, trunque o resultado em um inteiro)
• Divida por 10 ^N

Para N dígitos integrais significativos (não fracionários):

• Divida o número por 10 ^N
• Some 0,5
• Trunque os dígitos da fração (ou seja, trunque o resultado em um inteiro)
• Multiplique por 10 ^N

Você pode fazer isso em qualquer calculadora, por exemplo, que tenha um operador "INT" (truncamento de inteiro).

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

Aqui está o código da Pirolística (atualmente a melhor resposta) em Visual Basic.NET, caso alguém precise:

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

Este é um que eu criei em 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();

Eu precisava disso no Go, o que era um pouco complicado pela falta de biblioteca padrão do Go math.Round()(antes do go1.10). Então eu tive que agitar isso também. Aqui está a minha tradução da excelente resposta da Pirolística :

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

Você pode evitar fazer todos esses cálculos com potências de 10 etc. usando apenas FloatToStrF.

FloatToStrF permite que você (entre outras coisas) escolha a precisão (número de algarismos significativos) no valor de saída (que será uma string). Claro, você poderia então aplicar StrToFloat a isso para obter seu valor arredondado como um float.

Veja aqui:

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

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

Este código usa a função de formatação embutida que é transformada em uma função de arredondamento