Engineering notation in C#?

This may need refactoring:

private static string ToEngineeringNotation(this double d)
{
    double exponent = Math.Log10(Math.Abs(d));
    if (Math.Abs(d) >= 1)
    {
        switch ((int)Math.Floor(exponent))
        {
            case 0: case 1: case 2:
                return d.ToString();
            case 3: case 4: case 5:
                return (d / 1e3).ToString() + "k";
            case 6: case 7: case 8:
                return (d / 1e6).ToString() + "M";
            case 9: case 10: case 11:
                return (d / 1e9).ToString() + "G";
            case 12: case 13: case 14:
                return (d / 1e12).ToString() + "T";
            case 15: case 16: case 17:
                return (d / 1e15).ToString() + "P";
            case 18: case 19: case 20:
                return (d / 1e18).ToString() + "E";
            case 21: case 22: case 23:
                return (d / 1e21).ToString() + "Z";
            default:
                return (d / 1e24).ToString() + "Y";
        }
    }
    else if (Math.Abs(d) > 0)
    {
        switch ((int)Math.Floor(exponent))
        {
            case -1: case -2: case -3:
                return (d * 1e3).ToString() + "m";
            case -4: case -5: case -6:
                return (d * 1e6).ToString() + "μ";
            case -7: case -8: case -9:
                return (d * 1e9).ToString() + "n";
            case -10: case -11: case -12:
                return (d * 1e12).ToString() + "p";
            case -13: case -14: case -15:
                return (d * 1e15).ToString() + "f";
            case -16: case -17: case -18:
                return (d * 1e15).ToString() + "a";
            case -19: case -20: case -21:
                return (d * 1e15).ToString() + "z";
            default:
                return (d * 1e15).ToString() + "y";
        }
    }
    else
    {
        return "0";
    }
}

Here's a link to some Ruby code that does something similar, though it formats as dddem, where m, the exponent, is always a multiple of 3.

Transliteration to C#. Since I'm not familiar with the format I'm not sure this does exactly what you want. For example, 0.0015 formats as 2e-3. It would be reasonably trivial to substitute the Greek letters for the exponent using a case statement and UTF-8 or other encodings. The exercise is left to the reader.

public static class FormatExtensions
{
    public static string ToEngineering( this double value )
    {
        int exp = (int)(Math.Floor( Math.Log10( value ) / 3.0 ) * 3.0);
        double newValue = value * Math.Pow(10.0,-exp);
        if (newValue >= 1000.0) {
            newValue = newValue / 1000.0;
            exp = exp + 3;
        }
        return string.Format( "{0:##0}e{1}", newValue, exp);        
    }
}

Usage:

Console.WriteLine( ((double)15000).ToEngineering() );
double val = 15000;
Console.WriteLine( val.ToEngineering() );

Rather than subclassing, I'd take advantage of the fact that Double implements IFormattable and write an IFormatProvider that formats the number. Then I'd have code that looks similar to:

double d = 123.45;
Console.WriteLine(d.ToString(null, new MyCustomFormat()));

Combining two of the earlier answers and adding a unit (volt, etc.) gives nice tidy answers like 11000 volts as 11kV.

public static string ToEngineering(this double value, string unitName)
{
    int exp = (int)(Math.Floor(Math.Log10(value) / 3.0) * 3.0);
    double newValue = value * Math.Pow(10.0, -exp);
    if (newValue >= 1000.0)
    {
        newValue = newValue / 1000.0;
        exp = exp + 3;
    }
    var symbol = String.Empty;
    switch (exp)
    {
        case 3:
            symbol = "k";
            break;
        case 6:
            symbol = "M";
            break;
        case 9:
            symbol = "G";
            break;
        case 12:
            symbol = "T";
            break;
        case -3:
            symbol = "m";
            break;
        case -6:
            symbol = "μ";
            break;
        case -9:
            symbol = "n";
            break;
        case -12:
            symbol = "p";
            break;
        }

    return string.Format("{0:##0.000} {1}{2}", newValue, symbol, unitName);
}

Here is another version that handles negative and without rounding

public static string ToEngineering(this double value)
{
    var absValue = Math.Abs(value);
    var exp = absValue < 0.001 ? 0 : (int)(Math.Floor(Math.Log10(absValue) / 3.0) * 3.0);
    var newValue = value * Math.Pow(10.0, -exp);
    return $"{newValue}e{exp}";
}