TestDecimal2.cs | C# Online Compiler

TestDecimal2.cs by tmori3y2@gmail.com

using System;
using System.Runtime.InteropServices;
					
public static class Program
{
	public static void Main()
	{
		(5000000000000000.5).ToBinaryStringDump("5000000000000000.5");
		//(5000000000000000.5m).ToBinaryString().Dump();
		(5000000000000000.5m).ToDouble().ToBinaryStringDump("5000000000000000.5m");
		(5.0/10.0).ToBinaryStringDump("5.0/10.0");
	}

	public static double ToDouble(this decimal value)
	{
		return (double)value;
	}
	
	public static void Dump(this string value)
	{
		Console.WriteLine(value);
	}

	public static void Dump(this decimal value)
	{
		Console.WriteLine("{0:G28}", value);
	}
	
	public static void Dump(this double value)
	{
		Console.WriteLine("{0:G17}", value);
	}
}
					
public static class BinaryStringHelper
{	
	public static string ToBinaryString(this uint value)
	{
		return unchecked(((int)value).ToBinaryString());
	}
	
	public static string ToBinaryString(this uint value, int digits)
	{
		return unchecked(((int)value).ToBinaryString(digits));
	}
	
	public static string ToBinaryString(this int value)
	{
		return Convert.ToString(value, 2).SetPadding(32);
	}
	
	public static string ToBinaryString(this int value, int digits)
	{
		return Convert.ToString(value, 2).SetPadding(digits);
	}
	
	public static string ToBinaryString(this ulong value)
	{
		return unchecked(((long)value).ToBinaryString());
	}
	
	public static string ToBinaryString(this ulong value, int digits)
	{
		return unchecked(((long)value).ToBinaryString(digits));
	}
	
	public static string ToBinaryString(this long value)
	{
		return Convert.ToString(value, 2).SetPadding(64);
	}
	
	public static string ToBinaryString(this long value, int digits)
	{
		return Convert.ToString(value, 2).SetPadding(digits);
	}
	
	public static string ToBinaryString(this double value)
	{
		return new UnionDouble { Value = value }.QWord.ToBinaryString();
	}
	
	public static string ToBinaryString(this double value, int digits)
	{
		return new UnionDouble { Value = value }.QWord.ToBinaryString(digits);
	}
	
	public static void ToBinaryStringDump(this double value, string title)
	{
		new UnionDouble { Value = value }.Dump(title);
	}
	
	public static void ToBinaryStringDumpEx(this double value, string title)
	{
		new UnionDouble { Value = value }.DumpEx(title);
	}
	
	public static void ToBinaryStringFormat(this double value, string format)
	{
		value.ToBinaryStringDump(value.ToString(format));
	}
	
	public static void ToBinaryStringFormatEx(this double value, string format)
	{
		value.ToBinaryStringDumpEx(value.ToString(format));
	}
	
	public static string SetPadding(this string binaryString, int digits)
	{
		// adds lost digits.
		int length = binaryString.Length;
		//if (digits > length) return binaryString.Insert(0, new string('0', digits - length));
		if (digits > 0) return binaryString.PadLeft(digits, '0');
		
		return binaryString;
	}
	
	public static string SetSeparator(this string binaryString, string separator, int[] digitsList)
	{
		// adds lost digits.
		var result = binaryString;
		int length = result.Length;
		
		if (digitsList.Length > 0)
		{
			// digitsList: from lsb to msb
			foreach (var digits in digitsList)
			{
				var position = length - digits;
				if (position > 0) result = result.Insert(position, separator);
			}
		}
		
		return result;
	}
}


[StructLayout(LayoutKind.Explicit)]
public struct UnionDouble
{
    [FieldOffset(0)]
    public double Value;

    [FieldOffset(0)]
    public ulong QWord;
	
	public byte Sign { get { return unchecked((byte)(QWord >> 63)); } }

	public ushort ExponentBits { get { return unchecked((ushort)(QWord << 1 >> 53)); } }
		
	public ulong SignificantBits { get { return unchecked((ulong)(QWord << 12 >> 12)); } }
	
	public string BinaryString { get { return QWord.ToBinaryString(); } }
	
	public string BinaryPattern { get { return BinaryString.SetSeparator("_", new int[] { 52, 63 }); } }

	public int Exponent2
	{
		get
		{
			return (ExponentBits - 1023);
		}
	}

	public int Exponent10
	{
		get
		{
			double e10 = Math.Log10(Math.Abs(Value));
			return (Exponent2 > 0) ? (int)Math.Ceiling(e10) : (int)Math.Floor(e10); 
		}
	}
	
    public void Dump(string title)
	{
		string binary = string.Empty;
		ulong significantBits = SignificantBits; 
		int e = Exponent2;
		int e10 = Exponent10;
		
		switch(ExponentBits)
		{
		case 0x00:
			binary += significantBits.ToBinaryString(53).SetSeparator(".", new int[] { 52 });
			if (significantBits != 0)
			{
				string formatString  = (Sign == 0) ? "{0, -20}: {1} = (-1)^{2} * 2^(-1022) * {3} =  {4, -18:E16}" :
										    		 "{0, -20}: {1} = (-1)^{2} * 2^(-1022) * {3} = {4, -18:E16}";
				string.Format(formatString, title, BinaryPattern, Sign, binary, Value).Dump();
			}
			else
			{
				string formatString  = "{0, -20}: {1} = (-1)^{2} * 2^(-1022) * {3} =  {4, -18:E16}";
				string.Format(formatString, title, BinaryPattern, Sign, binary, Value).Dump();
			}
			break;
		case 0xFF:
			string.Format("{0, -20}: {1} = {2}", title, BinaryPattern, Value).Dump();
			break;
		default:
			binary += (significantBits | 0x10000000000000).ToBinaryString(53).SetSeparator(".", new int[] { 52 });
			if (-15 <= e10 && e10 < 0)
			{
				string formattedValue = string.Format(string.Concat("{0:G", 16 - e10, "}"), Value);
				string formatString  = (Sign == 0) ? "{0, -20}: {1} = (-1)^{2} * 2^({3, 4}) * {4} =  {5}" :
													 "{0, -20}: {1} = (-1)^{2} * 2^({3, 4}) * {4} = {5}";
				string.Format(formatString, title, BinaryPattern, Sign, e, binary, formattedValue).Dump();
			}
			else if (0 <= e10 && e10 < 16)
			{
				string formattedValue = string.Format(string.Concat("{0:G", e10, "}"), Value);
				string formatString  = (Sign == 0) ? "{0, -20}: {1} = (-1)^{2} * 2^({3, 4}) * {4} =  {5}" :
													 "{0, -20}: {1} = (-1)^{2} * 2^({3, 4}) * {4} = {5}";
				string.Format(formatString, title, BinaryPattern, Sign, e, binary, formattedValue).Dump();
			}
			else
			{
				string formatString  = "{0, -20}: {1} = (-1)^{2} * 2^({3, 4}) * {4} = {5, 16:E8}";
				string.Format(formatString, title, BinaryPattern, Sign, e, binary, Value).Dump();
			}
			break;
		}
	}
	
    public void DumpEx(string title)
	{
		string binary = string.Empty;
		ulong significantBits = SignificantBits; 
		int e = Exponent2;
		int e10 = Exponent10;
		
		switch(ExponentBits)
		{
		case 0x00:
		case 0xFF:
			Dump(title);
			break;
		default:
			if (e < 0)
			{
				binary += (significantBits | 0x800000).ToBinaryString(24 - e).SetSeparator(".", new int[] { 23 - e });
				string formatString  = (Sign == 0) ? "{0, -20}: {1} = {2, -26} =  {3, -20:G20}" :
													 "{0, -20}: {1} = {2, -26} = {3, -20:G20}";
				string.Format(formatString, title, BinaryPattern, binary, Value).Dump();
			}
			else if (e < 23)
			{
				binary += (significantBits | 0x800000).ToBinaryString(24).SetSeparator(".", new int[] { 23 - e });
				string formatString  = (Sign == 0) ? "{0, -20}: {1} = {2, -26} =  {3, -20:G20}" :
													 "{0, -20}: {1} = {2, -26} = {3, -20:G20}";
				string.Format(formatString, title, BinaryPattern, binary, Value).Dump();
			}
			else if (23 <= e && e <= 25)
			{
				binary += (significantBits | 0x800000).ToBinaryString(24);
				string formatString  = (Sign == 0) ? "{0, -20}: {1} = {2, -26} =  {3, -8:G8}" :
													 "{0, -20}: {1} = {2, -26} = {3, -8:G8}";
				string.Format(formatString, title, BinaryPattern, binary, Value).Dump();
			}
			else
			{
				Dump(title);
			}
			break;
		}
	}

	public string ToBinaryString()
	{
		return QWord.ToBinaryString();
	}
	
	public byte[] GetBytes()
	{
		return BitConverter.GetBytes(Value);
	}
}

​x
 
using System;
using System.Runtime.InteropServices;
                    
public static class Program
{
    public static void Main()
    {
        (5000000000000000.5).ToBinaryStringDump("5000000000000000.5");
        //(5000000000000000.5m).ToBinaryString().Dump();
        (5000000000000000.5m).ToDouble().ToBinaryStringDump("5000000000000000.5m");
        (5.0/10.0).ToBinaryStringDump("5.0/10.0");
    }
​
    public static double ToDouble(this decimal value)
    {
        return (double)value;
    }
    
    public static void Dump(this string value)
    {
        Console.WriteLine(value);
    }
​
    public static void Dump(this decimal value)
    {
        Console.WriteLine("{0:G28}", value);
    }
    
    public static void Dump(this double value)
    {
        Console.WriteLine("{0:G17}", value);
    }
}
                    
public static class BinaryStringHelper
{   
    public static string ToBinaryString(this uint value)
    {
        return unchecked(((int)value).ToBinaryString());
    }
    
    public static string ToBinaryString(this uint value, int digits)
    {
        return unchecked(((int)value).ToBinaryString(digits));
    }
    
    public static string ToBinaryString(this int value)
    {
        return Convert.ToString(value, 2).SetPadding(32);
    }
    
    public static string ToBinaryString(this int value, int digits)
    {
        return Convert.ToString(value, 2).SetPadding(digits);
    }
    
    public static string ToBinaryString(this ulong value)
    {
        return unchecked(((long)value).ToBinaryString());
    }
    
    public static string ToBinaryString(this ulong value, int digits)
    {
        return unchecked(((long)value).ToBinaryString(digits));
    }
    
    public static string ToBinaryString(this long value)
    {
        return Convert.ToString(value, 2).SetPadding(64);
    }
    
    public static string ToBinaryString(this long value, int digits)
    {
        return Convert.ToString(value, 2).SetPadding(digits);
    }
    
    public static string ToBinaryString(this double value)
    {
        return new UnionDouble { Value = value }.QWord.ToBinaryString();
    }
    
    public static string ToBinaryString(this double value, int digits)
    {
        return new UnionDouble { Value = value }.QWord.ToBinaryString(digits);
    }
    
    public static void ToBinaryStringDump(this double value, string title)
    {
        new UnionDouble { Value = value }.Dump(title);
    }
    
    public static void ToBinaryStringDumpEx(this double value, string title)
    {
        new UnionDouble { Value = value }.DumpEx(title);
    }
    
    public static void ToBinaryStringFormat(this double value, string format)
    {
        value.ToBinaryStringDump(value.ToString(format));
    }
    
    public static void ToBinaryStringFormatEx(this double value, string format)
    {
        value.ToBinaryStringDumpEx(value.ToString(format));
    }
    
    public static string SetPadding(this string binaryString, int digits)
    {
        // adds lost digits.
        int length = binaryString.Length;
        //if (digits > length) return binaryString.Insert(0, new string('0', digits - length));
        if (digits > 0) return binaryString.PadLeft(digits, '0');
        
        return binaryString;
    }
    
    public static string SetSeparator(this string binaryString, string separator, int[] digitsList)
    {
        // adds lost digits.
        var result = binaryString;
        int length = result.Length;
        
        if (digitsList.Length > 0)
        {
            // digitsList: from lsb to msb
            foreach (var digits in digitsList)
            {
                var position = length - digits;
                if (position > 0) result = result.Insert(position, separator);
            }
        }
        
        return result;
    }
}
​
​
[StructLayout(LayoutKind.Explicit)]
public struct UnionDouble
{
    [FieldOffset(0)]
    public double Value;
​
    [FieldOffset(0)]
    public ulong QWord;
    
    public byte Sign { get { return unchecked((byte)(QWord >> 63)); } }
​
    public ushort ExponentBits { get { return unchecked((ushort)(QWord << 1 >> 53)); } }
        
    public ulong SignificantBits { get { return unchecked((ulong)(QWord << 12 >> 12)); } }
    
    public string BinaryString { get { return QWord.ToBinaryString(); } }
    
    public string BinaryPattern { get { return BinaryString.SetSeparator("_", new int[] { 52, 63 }); } }
​
    public int Exponent2
    {
        get
        {
            return (ExponentBits - 1023);
        }
    }
​
    public int Exponent10
    {
        get
        {
            double e10 = Math.Log10(Math.Abs(Value));
            return (Exponent2 > 0) ? (int)Math.Ceiling(e10) : (int)Math.Floor(e10); 
        }
    }
    
    public void Dump(string title)
    {
        string binary = string.Empty;
        ulong significantBits = SignificantBits; 
        int e = Exponent2;
        int e10 = Exponent10;
        
        switch(ExponentBits)
        {
        case 0x00:
            binary += significantBits.ToBinaryString(53).SetSeparator(".", new int[] { 52 });
            if (significantBits != 0)
            {
                string formatString  = (Sign == 0) ? "{0, -20}: {1} = (-1)^{2} * 2^(-1022) * {3} =  {4, -18:E16}" :
                                                     "{0, -20}: {1} = (-1)^{2} * 2^(-1022) * {3} = {4, -18:E16}";
                string.Format(formatString, title, BinaryPattern, Sign, binary, Value).Dump();
            }
            else
            {
                string formatString  = "{0, -20}: {1} = (-1)^{2} * 2^(-1022) * {3} =  {4, -18:E16}";
                string.Format(formatString, title, BinaryPattern, Sign, binary, Value).Dump();
            }
            break;
        case 0xFF:
            string.Format("{0, -20}: {1} = {2}", title, BinaryPattern, Value).Dump();
            break;
        default:
            binary += (significantBits | 0x10000000000000).ToBinaryString(53).SetSeparator(".", new int[] { 52 });
            if (-15 <= e10 && e10 < 0)
            {
                string formattedValue = string.Format(string.Concat("{0:G", 16 - e10, "}"), Value);
                string formatString  = (Sign == 0) ? "{0, -20}: {1} = (-1)^{2} * 2^({3, 4}) * {4} =  {5}" :
                                                     "{0, -20}: {1} = (-1)^{2} * 2^({3, 4}) * {4} = {5}";
                string.Format(formatString, title, BinaryPattern, Sign, e, binary, formattedValue).Dump();
            }
            else if (0 <= e10 && e10 < 16)
            {
                string formattedValue = string.Format(string.Concat("{0:G", e10, "}"), Value);
                string formatString  = (Sign == 0) ? "{0, -20}: {1} = (-1)^{2} * 2^({3, 4}) * {4} =  {5}" :
                                                     "{0, -20}: {1} = (-1)^{2} * 2^({3, 4}) * {4} = {5}";
                string.Format(formatString, title, BinaryPattern, Sign, e, binary, formattedValue).Dump();
            }
            else
            {
                string formatString  = "{0, -20}: {1} = (-1)^{2} * 2^({3, 4}) * {4} = {5, 16:E8}";
                string.Format(formatString, title, BinaryPattern, Sign, e, binary, Value).Dump();
            }
            break;
        }
    }
    
    public void DumpEx(string title)
    {
        string binary = string.Empty;
        ulong significantBits = SignificantBits; 
        int e = Exponent2;
        int e10 = Exponent10;
        
        switch(ExponentBits)
        {
        case 0x00:
        case 0xFF:
            Dump(title);
            break;
        default:
            if (e < 0)
            {
                binary += (significantBits | 0x800000).ToBinaryString(24 - e).SetSeparator(".", new int[] { 23 - e });
                string formatString  = (Sign == 0) ? "{0, -20}: {1} = {2, -26} =  {3, -20:G20}" :
                                                     "{0, -20}: {1} = {2, -26} = {3, -20:G20}";
                string.Format(formatString, title, BinaryPattern, binary, Value).Dump();
            }
            else if (e < 23)
            {
                binary += (significantBits | 0x800000).ToBinaryString(24).SetSeparator(".", new int[] { 23 - e });
                string formatString  = (Sign == 0) ? "{0, -20}: {1} = {2, -26} =  {3, -20:G20}" :
                                                     "{0, -20}: {1} = {2, -26} = {3, -20:G20}";
                string.Format(formatString, title, BinaryPattern, binary, Value).Dump();
            }
            else if (23 <= e && e <= 25)
            {
                binary += (significantBits | 0x800000).ToBinaryString(24);
                string formatString  = (Sign == 0) ? "{0, -20}: {1} = {2, -26} =  {3, -8:G8}" :
                                                     "{0, -20}: {1} = {2, -26} = {3, -8:G8}";
                string.Format(formatString, title, BinaryPattern, binary, Value).Dump();
            }
            else
            {
                Dump(title);
            }
            break;
        }
    }
​
    public string ToBinaryString()
    {
        return QWord.ToBinaryString();
    }
    
    public byte[] GetBytes()
    {
        return BitConverter.GetBytes(Value);
    }
}
​

90 - 63 = 27 + 84 = 111
86 - 54 = 32 + 79 = 111
85 - 46 = 39 + 72 = 111
90 - 27 = 63 + 48 = 111
95 - 27 = 68 + 43 = 111

Cached Result
Last Run:	2:19:35 pm
Compile:	0.203s
Execute:	0.031s
Memory:	5.99Mb
CPU:	0.047s

View IL Code