How to round System.Decimal in .Net to a number of significant figures

Question

I have a System.Decimal number

0.00123456789

and I wish to round to 3 significant figures. I expect

0.00123

with the behaviour to be a roundi

Answer 1

in example:

decimal a = 1.9999M;
decimal b = Math.Round(a, 2); //returns 2

Answer 2

SqlDecimal has fast methods to calculate and adjust precision.

public static decimal RoundToSignificantFigures(decimal num, int n)
{
    SqlDecimal value = New SqlDecimal(num);
    if (value.Precision > num){
        int digits = num - (value.Precision - value.Scale);
        value = SqlDecimal.Round(value, digits);
        value = SqlDecimal.AdjustScale(value, (digits>0 ? digits : 0) - dstValue.Scale, True);
    }
    return value.Value;
}

Answer 3

try this ... decimalVar.ToString ("#.##");

Answer 4

You can try this... But I don't guarantee anything... Written and tested in 20 minutes and based on Pyrolistical's code from https://stackoverflow.com/a/1581007/613130 There is a big difference in that he uses a long for the shifted variable (because a double has a precision of 15-16 digits, while a long has 18-19, so a long is enough), while I use a decimal (because decimal has a precision of 28-29 digits).

public static decimal RoundToSignificantFigures(decimal num, int n)
{
    if (num == 0)
    {
        return 0;
    }

    // We are only looking for the next power of 10... 
    // The double conversion could impact in some corner cases,
    // but I'm not able to construct them...
    int d = (int)Math.Ceiling(Math.Log10((double)Math.Abs(num)));
    int power = n - d;

    // Same here, Math.Pow(10, *) is an integer number
    decimal magnitude = (decimal)Math.Pow(10, power);

    // I'm using the MidpointRounding.AwayFromZero . I'm not sure
    // having a MidpointRounding.ToEven would be useful (is Banker's
    // rounding used for significant figures?)
    decimal shifted = Math.Round(num * magnitude, 0, MidpointRounding.AwayFromZero);
    decimal ret = shifted / magnitude;

    return ret;
}

If you don't trust the (int)Math.Ceiling(Math.Log10((double) you could use this:

private static readonly decimal[] Pows = Enumerable.Range(-28, 57)
    .Select(p => (decimal)Math.Pow(10, p))
    .ToArray();

public static int Log10Ceiling(decimal num)
{
    int log10 = Array.BinarySearch(Pows, num);
    return (log10 >= 0 ? log10 : ~log10) - 28;
}

I have written it in another 20 minutes (and yes, I have tested all the Math.Pow((double), p) for all the values -28 - +28). It seems to work, and it's only 20% slower than the C# formula based on doubles). It's based on a static array of pows and a BinarySearch. Luckily the BinarySearch already "suggests" the next element when it can't find one :-), so the Ceiling is for free.