public static void GetDoubleParts(double dbl, out int sign, out int exp, out ulong man, out bool fFinite) { ulong bits = BitConverter.DoubleToUInt64Bits(dbl); sign = 1 - ((int)(bits >> 62) & 2); man = bits & 0x000FFFFFFFFFFFFF; exp = (int)(bits >> 52) & 0x7FF; if (exp == 0) { // Denormalized number. fFinite = true; if (man != 0) { exp = -1074; } } else if (exp == 0x7FF) { // NaN or Infinite. fFinite = false; exp = int.MaxValue; } else { fFinite = true; man |= 0x0010000000000000; exp -= 1075; } }
public static void DoubleToUInt64Bits() { double input = 123456.3234; ulong result = BitConverter.DoubleToUInt64Bits(input); Assert.Equal(4683220267154373240UL, result); double roundtripped = BitConverter.UInt64BitsToDouble(result); Assert.Equal(input, roundtripped); }
public static UInt64 ToBits(this Double num) { #if BITWISE_FLOAT_CONVERSION return(BitConverter.DoubleToUInt64Bits(num)); #else unsafe { return(*(UInt64 *)&num); } #endif }
public void TestParserDouble_SpecificPowers(int b, int start, int end) { for (int i = start; i != end; i++) { double d = Math.Pow(b, i); ulong bits = BitConverter.DoubleToUInt64Bits(d); TestRoundTripDouble(bits - 1); TestRoundTripDouble(bits); TestRoundTripDouble(bits + 1); } }
private static void AssertBitwiseEqual(double expected, double actual) { ulong expectedBits = BitConverter.DoubleToUInt64Bits(expected); ulong actualBits = BitConverter.DoubleToUInt64Bits(actual); if (expectedBits == actualBits) { return; } if (Complex.IsNaN(expected) && Complex.IsNaN(actual)) { return; } throw new Xunit.Sdk.EqualException(expected, actual); }
public static void PositiveInfinity() { Assert.Equal(1.0 / 0.0, double.PositiveInfinity); Assert.Equal(0x7FF00000_00000000u, BitConverter.DoubleToUInt64Bits(double.PositiveInfinity)); }
public static void NegativeInfinity() { Assert.Equal(-1.0 / 0.0, double.NegativeInfinity); Assert.Equal(0xFFF00000_00000000u, BitConverter.DoubleToUInt64Bits(double.NegativeInfinity)); }
public static void NaN() { Assert.Equal(0.0 / 0.0, double.NaN); Assert.Equal(0xFFF80000_00000000u, BitConverter.DoubleToUInt64Bits(double.NaN)); }
public static void MinValue() { Assert.Equal(-1.7976931348623157E+308, double.MinValue); Assert.Equal(0xFFEFFFFF_FFFFFFFFu, BitConverter.DoubleToUInt64Bits(double.MinValue)); }
public static void Epsilon() { Assert.Equal(4.9406564584124654E-324, double.Epsilon); Assert.Equal(0x00000000_00000001u, BitConverter.DoubleToUInt64Bits(double.Epsilon)); }
// Writes a double to this stream. The current position of the stream is // advanced by eight. // //| <include file='doc\BinaryWriter.uex' path='docs/doc[@for="BinaryWriter.Write8"]/*' /> public virtual void Write(double value) { Write(BitConverter.DoubleToUInt64Bits(value)); }
public static void MinTest(double left, double right, double expected) { Assert.That(() => BitConverter.DoubleToUInt64Bits(MathUtilities.Min(left, right)), Is.EqualTo(BitConverter.DoubleToUInt64Bits(expected)) ); }
public static uint ExtractMostSignificantBit(T value) { if (typeof(T) == typeof(byte)) { uint bits = (byte)(object)value; return(bits >> 7); } else if (typeof(T) == typeof(double)) { ulong bits = BitConverter.DoubleToUInt64Bits((double)(object)value); return((uint)(bits >> 63)); } else if (typeof(T) == typeof(short)) { uint bits = (ushort)(short)(object)value; return(bits >> 15); } else if (typeof(T) == typeof(int)) { uint bits = (uint)(int)(object)value; return(bits >> 31); } else if (typeof(T) == typeof(long)) { ulong bits = (ulong)(long)(object)value; return((uint)(bits >> 63)); } else if (typeof(T) == typeof(nint)) { #if TARGET_64BIT ulong bits = (ulong)(nint)(object)value; return((uint)(bits >> 63)); #else uint bits = (uint)(nint)(object)value; return(bits >> 31); #endif } else if (typeof(T) == typeof(nuint)) { #if TARGET_64BIT ulong bits = (ulong)(nuint)(object)value; return((uint)(bits >> 63)); #else uint bits = (uint)(nuint)(object)value; return(bits >> 31); #endif } else if (typeof(T) == typeof(sbyte)) { uint bits = (byte)(sbyte)(object)value; return(bits >> 7); } else if (typeof(T) == typeof(float)) { uint bits = BitConverter.SingleToUInt32Bits((float)(object)value); return(bits >> 31); } else if (typeof(T) == typeof(ushort)) { uint bits = (ushort)(object)value; return(bits >> 15); } else if (typeof(T) == typeof(uint)) { uint bits = (uint)(object)value; return(bits >> 31); } else if (typeof(T) == typeof(ulong)) { ulong bits = (ulong)(object)value; return((uint)(bits >> 63)); } else { throw new NotSupportedException(SR.Arg_TypeNotSupported); } }