Início / coding / Perguntas / 79145932
Accepted
FluidMechanics Potential Flows
Asked: 2024-11-01 02:30:48 +0800 CST

Exemplo da utilidade do especificador de formato `G9` em C# para números de ponto flutuante de ida e volta?

  • 772

Estou tentando entender a utilidade prática do G9especificador de formato em C# ao lidar com números de ponto flutuante de ida e volta.

O livro C#12 em poucas palavras menciona que G9é útil evitar perda de precisão ao converter a floatpara a stringe de volta para a float(página 324). Mas não consigo encontrar um exemplo que mostre um caso em que G9a formatação tenha sucesso em preservar a igualdade, enquanto a formatação padrão falharia.

Por exemplo:

using System;

class Program
{
    static void Main()
    {
        float originalNumber = 0.1f;

        string defaultFormatted = originalNumber.ToString();

        float defaultRoundTrip = float.Parse(defaultFormatted);
        Console.WriteLine("Default Formatting:");
        Console.WriteLine("Original: " + originalNumber);
        Console.WriteLine("Formatted: " + defaultFormatted);
        Console.WriteLine("Round-trip Equal: " + (originalNumber == defaultRoundTrip));

        string g9Formatted = originalNumber.ToString("G9");

        float g9RoundTrip = float.Parse(g9Formatted);
        Console.WriteLine("\nG9 Formatting:");
        Console.WriteLine("Original: " + originalNumber);
        Console.WriteLine("Formatted: " + g9Formatted);
        Console.WriteLine("Round-trip Equal: " + (originalNumber == g9RoundTrip));
    }
}

Me dá

Default Formatting:
Original: 0.1
Formatted: 0.1
Round-trip Equal: True

G9 Formatting:
Original: 0.1
Formatted: 0.100000001
Round-trip Equal: True

Eu esperava algo do tipo:

Default Formatting:
Original: 0.1
Formatted: 0.100000000001
Round-trip Equal: False

G9 Formatting:
Original: 0.1
Formatted: 0.1
Round-trip Equal: True
c#

2 respostas

  1. Best Answer

    Suas observações estão corretas. Ligar Single.ToStringsem argumentos pode realmente fazer roundtrip no número.

    Da documentação de ToString(),

    O ToString()método formata um valor único no formato padrão ("G" ou geral) da cultura atual.

    A partir de strings de formato numérico padrão , diz-se que para float, "G" sozinho, sem nenhuma precisão, usará tanta precisão quanto necessária para fazer o arredondamento do número.

    Se o especificador de precisão for omitido ou zero, o tipo do número determinará a precisão padrão, conforme indicado na tabela a seguir.

    Tipo Numérico Precisão Padrão
    Single Menor número de dígitos que pode ser arredondado para representar o número (no .NET Framework, G7 é o padrão)

    Observe que ele diz que usará o G7 no .NET Framework , e é possivelmente por isso que o autor do livro fez essa observação sobre o uso do G9.

    Veja também esta resposta muito antiga que cita a documentação para Single.ToString(), que é diferente do que diz hoje.

    Por padrão, o valor de retorno contém apenas 7 dígitos de precisão, embora um máximo de 9 dígitos seja mantido internamente.

    Se você precisar de mais precisão, especifique o formato com a especificação de formato "G9", que sempre retorna 9 dígitos de precisão, ou "R", que retorna 7 dígitos se o número puder ser representado com essa precisão ou 9 dígitos se o número puder ser representado apenas com precisão máxima.

    Então esse propósito do "G9" foi realmente documentado.

    • 2

  2. Dica profissional: com o poder de computação moderno, você pode realmente testar facilmente todos os valores de float possíveis. Doubles ainda estão fora de alcance, infelizmente.

    Aqui está um código paralelo rápido e prático que roda em ~2 minutos na minha máquina.

    Com o formato G7, 67% dos valores possíveis não fazem round trip (era o padrão no .Net Framework). Com o G8, 1,5% não fazem round trip. Com o G9, não há erros (deveria ser o padrão atual). E esses valores são subestimados porque não me incomodei em contabilizar NaNs.

    using System.Diagnostics;
using System.Globalization;

var sw = Stopwatch.StartNew();

var totalErrors = 0L;
const string format = "G7";

Parallel.For(0, Environment.ProcessorCount, partition =>
{
    var localErrors = 0;

    // For and while loops are awkward around MaxValue so using
    // a do-while which checks for overflow after increment.
    uint i = (uint)partition;
    do
    {
        if (!CheckIndividual(i))
            ++localErrors;

        if (i % 10_000_000 == 0 && i != 0)
        {
            long processed = i + 1;
            var elapsed = sw.Elapsed;
            var remaining = (4294967296 - processed) * elapsed / processed;
            Console.WriteLine($"Inspected {i}, elapsed {elapsed}, remaining {remaining}");
        }

        i += (uint)Environment.ProcessorCount;
    } while (i >= (uint)Environment.ProcessorCount);

    _ = Interlocked.Add(ref totalErrors, localErrors);
});

Console.WriteLine($"Total errors: {totalErrors}");
Console.WriteLine($"Done after: {sw.Elapsed}");


static bool CheckIndividual(uint i)
{
    var f = BitConverter.UInt32BitsToSingle(i);

    // Ignoring NaNs and infinities.
    if (!float.IsFinite(f))
        return true;

    var s = f.ToString(format, CultureInfo.InvariantCulture);
    var f2 = float.Parse(s, CultureInfo.InvariantCulture);

    if (BitConverter.SingleToUInt32Bits(f2) != i)
    {
        //Console.WriteLine($"Failed to round trip {s} (0x{i:x8})");
        return false;
    }

    return true;
}
    • 1

relate perguntas