Formattazione di numeri con cifre significative in C#



vb net format percent (7)

Il seguente codice non soddisfa abbastanza le specifiche, poiché non tenta di arrotondare nulla alla sinistra del punto decimale. Ma è più semplice di qualsiasi altra cosa presentata qui (finora). Sono rimasto piuttosto sorpreso dal fatto che C # non abbia un metodo integrato per gestirlo.

static public string SignificantDigits(double d, int digits=10)
{
    int magnitude = (d == 0.0) ? 0 : (int)Math.Floor(Math.Log10(Math.Abs(d))) + 1;
    digits -= magnitude;
    if (digits < 0)
        digits = 0;
    string fmt = "f" + digits.ToString();
    return d.ToString(fmt);
}

Ho alcuni dati decimali che sto spingendo in un elenco di SharePoint in cui deve essere visualizzato. Mi piacerebbe limitare il numero di cifre significative visualizzate nei dati dei risultati in base alla mia conoscenza del calcolo specifico. A volte sarà 3, quindi 12345 diventerà 12300 e 0,012345 diventerà 0,0123. Occasionalmente sarà 4 o 5. C'è un modo conveniente per gestire questo?


Questo potrebbe fare il trucco:


double Input1 = 1234567;
string Result1 = Convert.ToDouble(String.Format("{0:G3}",Input1)).ToString("R0");

double Input2 = 0.012345;
string Result2 = Convert.ToDouble(String.Format("{0:G3}", Input2)).ToString("R6");

Cambiare il G3 in G4 produce comunque il risultato più strano. Sembra di arrotondare le cifre significative?


Per quanto mi ricordo, "cifre significative" indica il numero di cifre dopo il separatore di punti in modo che 3 cifre significative per 0,012345 siano 0,012 e non 0,0123, ma ciò non importa per la soluzione. Capisco anche che tu voglia "annullare" le ultime cifre in una certa misura se il numero è> 1. Scrivi che 12345 diventerebbe 12300 ma non sono sicuro che tu voglia 123456 diventare 1230000 o 123400? La mia soluzione fa l'ultimo. Invece di calcolare il fattore potresti naturalmente creare un piccolo array inizializzato se hai solo un paio di varianti.

private static string FormatToSignificantFigures(decimal number, int amount)
{
    if (number > 1)
    {
        int factor = Factor(amount);
        return ((int)(number/factor)*factor).ToString();
    }

    NumberFormatInfo nfi = new CultureInfo("en-US", false).NumberFormat;
    nfi.NumberDecimalDigits = amount;

    return(number.ToString("F", nfi));
}

private static int Factor(int x)
{
    return DoCalcFactor(10, x-1);
}

private static int DoCalcFactor(int x, int y)
{
    if (y == 1) return x;
    return 10*DoCalcFactor(x, y - 1);
}

Cordiali saluti Carsten


Vedi: RoundToSignificantFigures di "P Daddy".
Ho combinato il suo metodo con un altro che mi è piaciuto.

Arrotondare a cifre significative è molto più semplice in TSQL dove il metodo di arrotondamento si basa sulla posizione di arrotondamento, non sul numero di cifre decimali, come nel caso di .Net math.round. È possibile arrotondare un numero in TSQL a posizioni negative, che verrebbero arrotondate a numeri interi, quindi il ridimensionamento non è necessario.

Vedi anche questo altro thread . Il metodo pirolistico è buono.

La parte degli zeri finali del problema mi sembra più un'operazione di stringa, quindi ho incluso un metodo di estensione ToString () che riempirà gli zeri se necessario.

using System;
using System.Globalization;

public static class Precision
{
    // 2^-24
    public const float FLOAT_EPSILON = 0.0000000596046448f;

    // 2^-53
    public const double DOUBLE_EPSILON = 0.00000000000000011102230246251565d;

    public static bool AlmostEquals(this double a, double b, double epsilon = DOUBLE_EPSILON)
    {
        // ReSharper disable CompareOfFloatsByEqualityOperator
        if (a == b)
        {
            return true;
        }
        // ReSharper restore CompareOfFloatsByEqualityOperator

        return (System.Math.Abs(a - b) < epsilon);
    }

    public static bool AlmostEquals(this float a, float b, float epsilon = FLOAT_EPSILON)
    {
        // ReSharper disable CompareOfFloatsByEqualityOperator
        if (a == b)
        {
            return true;
        }
        // ReSharper restore CompareOfFloatsByEqualityOperator

        return (System.Math.Abs(a - b) < epsilon);
    }
}

public static class SignificantDigits
{
    public static double Round(this double value, int significantDigits)
    {
        int unneededRoundingPosition;
        return RoundSignificantDigits(value, significantDigits, out unneededRoundingPosition);
    }

    public static string ToString(this double value, int significantDigits)
    {
        // this method will round and then append zeros if needed.
        // i.e. if you round .002 to two significant figures, the resulting number should be .0020.

        var currentInfo = CultureInfo.CurrentCulture.NumberFormat;

        if (double.IsNaN(value))
        {
            return currentInfo.NaNSymbol;
        }

        if (double.IsPositiveInfinity(value))
        {
            return currentInfo.PositiveInfinitySymbol;
        }

        if (double.IsNegativeInfinity(value))
        {
            return currentInfo.NegativeInfinitySymbol;
        }

        int roundingPosition;
        var roundedValue = RoundSignificantDigits(value, significantDigits, out roundingPosition);

        // when rounding causes a cascading round affecting digits of greater significance, 
        // need to re-round to get a correct rounding position afterwards
        // this fixes a bug where rounding 9.96 to 2 figures yeilds 10.0 instead of 10
        RoundSignificantDigits(roundedValue, significantDigits, out roundingPosition);

        if (Math.Abs(roundingPosition) > 9)
        {
            // use exponential notation format
            // ReSharper disable FormatStringProblem
            return string.Format(currentInfo, "{0:E" + (significantDigits - 1) + "}", roundedValue);
            // ReSharper restore FormatStringProblem
        }

        // string.format is only needed with decimal numbers (whole numbers won't need to be padded with zeros to the right.)
        // ReSharper disable FormatStringProblem
        return roundingPosition > 0 ? string.Format(currentInfo, "{0:F" + roundingPosition + "}", roundedValue) : roundedValue.ToString(currentInfo);
        // ReSharper restore FormatStringProblem
    }

    private static double RoundSignificantDigits(double value, int significantDigits, out int roundingPosition)
    {
        // this method will return a rounded double value at a number of signifigant figures.
        // the sigFigures parameter must be between 0 and 15, exclusive.

        roundingPosition = 0;

        if (value.AlmostEquals(0d))
        {
            roundingPosition = significantDigits - 1;
            return 0d;
        }

        if (double.IsNaN(value))
        {
            return double.NaN;
        }

        if (double.IsPositiveInfinity(value))
        {
            return double.PositiveInfinity;
        }

        if (double.IsNegativeInfinity(value))
        {
            return double.NegativeInfinity;
        }

        if (significantDigits < 1 || significantDigits > 15)
        {
            throw new ArgumentOutOfRangeException("significantDigits", value, "The significantDigits argument must be between 1 and 15.");
        }

        // The resulting rounding position will be negative for rounding at whole numbers, and positive for decimal places.
        roundingPosition = significantDigits - 1 - (int)(Math.Floor(Math.Log10(Math.Abs(value))));

        // try to use a rounding position directly, if no scale is needed.
        // this is because the scale mutliplication after the rounding can introduce error, although 
        // this only happens when you're dealing with really tiny numbers, i.e 9.9e-14.
        if (roundingPosition > 0 && roundingPosition < 16)
        {
            return Math.Round(value, roundingPosition, MidpointRounding.AwayFromZero);
        }

        // Shouldn't get here unless we need to scale it.
        // Set the scaling value, for rounding whole numbers or decimals past 15 places
        var scale = Math.Pow(10, Math.Ceiling(Math.Log10(Math.Abs(value))));

        return Math.Round(value / scale, significantDigits, MidpointRounding.AwayFromZero) * scale;
    }
}

È possibile ottenere un elegante arrotondamento bit perfetto utilizzando il metodo GetBits su Decimal e sfruttando BigInteger per eseguire il mascheramento.

Alcuni programmi di utilità

    public static int CountDigits
        (BigInteger number) => ((int)BigInteger.Log10(number))+1;

    private static readonly BigInteger[] BigPowers10 
       = Enumerable.Range(0, 100)
                 .Select(v => BigInteger.Pow(10, v))
                 .ToArray();

La funzione principale

    public static decimal RoundToSignificantDigits
        (this decimal num,
         short n)
    {
        var bits = decimal.GetBits(num);
        var u0 = unchecked((uint)bits[0]);
        var u1 = unchecked((uint)bits[1]);
        var u2 = unchecked((uint)bits[2]);

        var i = new BigInteger(u0)
                + (new BigInteger(u1) << 32)
                + (new BigInteger(u2) << 64);

        var d = CountDigits(i);

        var delta = d - n;
        if (delta < 0)
            return num;

        var scale = BigPowers10[delta];
        var div = i/scale;
        var rem = i%scale;
        var up = rem > scale/2;
        if (up)
            div += 1;
        var shifted = div*scale;

        bits[0] =unchecked((int)(uint) (shifted & BigUnitMask));
        bits[1] =unchecked((int)(uint) (shifted>>32 & BigUnitMask));
        bits[2] =unchecked((int)(uint) (shifted>>64 & BigUnitMask));

        return new decimal(bits);
    }

test case 0

    public void RoundToSignificantDigits()
    {
        WMath.RoundToSignificantDigits(0.0012345m, 2).Should().Be(0.0012m);
        WMath.RoundToSignificantDigits(0.0012645m, 2).Should().Be(0.0013m);
        WMath.RoundToSignificantDigits(0.040000000000000008, 6).Should().Be(0.04);
        WMath.RoundToSignificantDigits(0.040000010000000008, 6).Should().Be(0.04);
        WMath.RoundToSignificantDigits(0.040000100000000008, 6).Should().Be(0.0400001);
        WMath.RoundToSignificantDigits(0.040000110000000008, 6).Should().Be(0.0400001);
        WMath.RoundToSignificantDigits(0.20000000000000004, 6).Should().Be(0.2);
        WMath.RoundToSignificantDigits(0.10000000000000002, 6).Should().Be(0.1);
        WMath.RoundToSignificantDigits(0.0, 6).Should().Be(0.0);

    }

test case 1

     public void RoundToSigFigShouldWork()
    {
        1.2m.RoundToSignificantDigits(1).Should().Be(1m);
        0.01235668m.RoundToSignificantDigits(3).Should().Be(0.0124m);
        0.01m.RoundToSignificantDigits(3).Should().Be(0.01m);

        1.23456789123456789123456789m.RoundToSignificantDigits(4)
                                     .Should().Be(1.235m);

        1.23456789123456789123456789m.RoundToSignificantDigits(16)
                                     .Should().Be(1.234567891234568m);

        1.23456789123456789123456789m.RoundToSignificantDigits(24)
                                     .Should().Be(1.23456789123456789123457m);

        1.23456789123456789123456789m.RoundToSignificantDigits(27)
                                     .Should().Be(1.23456789123456789123456789m);
    }

Ho una risposta in cortocircuito al calcolo di cifre significative di un numero. Ecco il codice e i risultati del test ...

using System;
using System.Collections.Generic;

namespace ConsoleApplicationRound
{
    class Program
    {
        static void Main(string[] args)
        {
            //char cDecimal = '.';    // for English cultures
            char cDecimal = ',';    // for German cultures
            List<double> l_dValue = new List<double>();
            ushort usSignificants = 5;

            l_dValue.Add(0);
            l_dValue.Add(0.000640589);
            l_dValue.Add(-0.000640589);
            l_dValue.Add(-123.405009);
            l_dValue.Add(123.405009);
            l_dValue.Add(-540);
            l_dValue.Add(540);
            l_dValue.Add(-540911);
            l_dValue.Add(540911);
            l_dValue.Add(-118.2);
            l_dValue.Add(118.2);
            l_dValue.Add(-118.18);
            l_dValue.Add(118.18);
            l_dValue.Add(-118.188);
            l_dValue.Add(118.188);

            foreach (double d in l_dValue)
            {
                Console.WriteLine("d = Maths.Round('" +
                    cDecimal + "', " + d + ", " + usSignificants +
                    ") = " + Maths.Round(
                    cDecimal, d, usSignificants));
            }

            Console.Read();
        }
    }
}

La classe Maths utilizzata è la seguente:

using System;
using System.Text;

namespace ConsoleApplicationRound
{
    class Maths
    {
        /// <summary>
        ///     The word "Window"
        /// </summary>
        private static String m_strZeros = "000000000000000000000000000000000";
        /// <summary>
        ///     The minus sign
        /// </summary>
        public const char m_cDASH = '-';

        /// <summary>
        ///     Determines the number of digits before the decimal point
        /// </summary>
        /// <param name="cDecimal">
        ///     Language-specific decimal separator
        /// </param>
        /// <param name="strValue">
        ///     Value to be scrutinised
        /// </param>
        /// <returns>
        ///     Nr. of digits before the decimal point
        /// </returns>
        private static ushort NrOfDigitsBeforeDecimal(char cDecimal, String strValue)
        {
            short sDecimalPosition = (short)strValue.IndexOf(cDecimal);
            ushort usSignificantDigits = 0;

            if (sDecimalPosition >= 0)
            {
                strValue = strValue.Substring(0, sDecimalPosition + 1);
            }

            for (ushort us = 0; us < strValue.Length; us++)
            {
                if (strValue[us] != m_cDASH) usSignificantDigits++;

                if (strValue[us] == cDecimal)
                {
                    usSignificantDigits--;
                    break;
                }
            }

            return usSignificantDigits;
        }

        /// <summary>
        ///     Rounds to a fixed number of significant digits
        /// </summary>
        /// <param name="d">
        ///     Number to be rounded
        /// </param>
        /// <param name="usSignificants">
        ///     Requested significant digits
        /// </param>
        /// <returns>
        ///     The rounded number
        /// </returns>
        public static String Round(char cDecimal,
            double d,
            ushort usSignificants)
        {
            StringBuilder value = new StringBuilder(Convert.ToString(d));

            short sDecimalPosition = (short)value.ToString().IndexOf(cDecimal);
            ushort usAfterDecimal = 0;
            ushort usDigitsBeforeDecimalPoint =
                NrOfDigitsBeforeDecimal(cDecimal, value.ToString());

            if (usDigitsBeforeDecimalPoint == 1)
            {
                usAfterDecimal = (d == 0)
                    ? usSignificants
                    : (ushort)(value.Length - sDecimalPosition - 2);
            }
            else
            {
                if (usSignificants >= usDigitsBeforeDecimalPoint)
                {
                    usAfterDecimal =
                        (ushort)(usSignificants - usDigitsBeforeDecimalPoint);
                }
                else
                {
                    double dPower = Math.Pow(10,
                        usDigitsBeforeDecimalPoint - usSignificants);

                    d = dPower*(long)(d/dPower);
                }
            }

            double dRounded = Math.Round(d, usAfterDecimal);
            StringBuilder result = new StringBuilder();

            result.Append(dRounded);
            ushort usDigits = (ushort)result.ToString().Replace(
                Convert.ToString(cDecimal), "").Replace(
                Convert.ToString(m_cDASH), "").Length;

            // Add lagging zeros, if necessary:
            if (usDigits < usSignificants)
            {
                if (usAfterDecimal != 0)
                {
                    if (result.ToString().IndexOf(cDecimal) == -1)
                    {
                        result.Append(cDecimal);
                    }

                    int i = (d == 0) ? 0 : Math.Min(0, usDigits - usSignificants);

                    result.Append(m_strZeros.Substring(0, usAfterDecimal + i));
                }
            }

            return result.ToString();
        }
    }
}

Qualche risposta con un codice più breve?


Ho trovato questo articolo facendo una rapida ricerca su di esso. Fondamentalmente questo si converte in una stringa e passa dai caratteri di quell'array uno alla volta, fino a raggiungere il massimo. significato. Funzionerà?





significant-digits