public static void WriteDoubleBE(Stream destination, double value)
{
var union = new DoubleUnion();
union.Double = value;
WriteUInt64BE(destination, union.ULong);
}
public static double ReadDoubleBE(Stream source)
{
var union = new DoubleUnion();
union.ULong = ReadUInt64BE(source);
return(union.Double);
}
internal static bool IsNaN(double value)
{
var nanUnion = new DoubleUnion {
Double = value
};
var num1 = nanUnion.ULong & 18442240474082181120UL;
var num2 = nanUnion.ULong & 4503599627370495UL;
if ((long)num1 == 9218868437227405312L || (long)num1 == -4503599627370496L)
{
return(num2 > 0UL);
}
return(false);
}
/// <summary>Serialize double (8 bytes) to the buffer.</summary>
/// <param name="buffer">Buffer to write to.</param>
/// <param name="offset">Buffer offset to write to.</param>
/// <param name="value">Value to write.</param>
public static void WriteDouble(byte[] buffer, int offset, double value)
{
DoubleUnion union = new DoubleUnion {
DoubleData = value
};
buffer[offset] = (byte)(union.IntData);
buffer[offset + 1] = (byte)(union.IntData >> 8);
buffer[offset + 2] = (byte)(union.IntData >> 16);
buffer[offset + 3] = (byte)(union.IntData >> 24);
buffer[offset + 4] = (byte)(union.IntData >> 32);
buffer[offset + 5] = (byte)(union.IntData >> 40);
buffer[offset + 6] = (byte)(union.IntData >> 48);
buffer[offset + 7] = (byte)(union.IntData >> 56);
}
public static void Write(ref byte[] bytes, ref int offset, double value)
{
var union = new DoubleUnion {
Value = value
};
Write(ref bytes, ref offset, union.byte0);
Write(ref bytes, ref offset, union.byte1);
Write(ref bytes, ref offset, union.byte2);
Write(ref bytes, ref offset, union.byte3);
Write(ref bytes, ref offset, union.byte4);
Write(ref bytes, ref offset, union.byte5);
Write(ref bytes, ref offset, union.byte6);
Write(ref bytes, ref offset, union.byte7);
}
public static void Write(BitStream stream, double value)
{
var union = new DoubleUnion {
Value = value
};
Write(stream, union.byte0);
Write(stream, union.byte1);
Write(stream, union.byte2);
Write(stream, union.byte3);
Write(stream, union.byte4);
Write(stream, union.byte5);
Write(stream, union.byte6);
Write(stream, union.byte7);
}
/// <summary>Deserialize double (8 bytes) from the buffer.</summary>
/// <param name="buffer">Buffer to read from.</param>
/// <param name="offset">Buffer offset to read from.</param>
/// <returns>Deserialized value.</returns>
public static double ReadDouble(byte[] buffer, int offset)
{
DoubleUnion union = new DoubleUnion {
IntData = 0
};
union.IntData |= buffer[offset];
union.IntData |= ((ulong)buffer[offset + 1]) << 8;
union.IntData |= ((ulong)buffer[offset + 2]) << 16;
union.IntData |= ((ulong)buffer[offset + 3]) << 24;
union.IntData |= ((ulong)buffer[offset + 4]) << 32;
union.IntData |= ((ulong)buffer[offset + 5]) << 40;
union.IntData |= ((ulong)buffer[offset + 6]) << 48;
union.IntData |= ((ulong)buffer[offset + 7]) << 56;
return(union.DoubleData);
}
internal static double SplitFractional(double value, out double integral)
{
var doubleUnion = new DoubleUnion(value);
var e = (int)(doubleUnion.ULong >> 52 & 0x7ff) - 0x3ff;
// No fractional part
if (e >= 52)
{
integral = value;
// NaN
if (e == 0x400 && doubleUnion.ULong << 12 != 0)
{
return(value);
}
doubleUnion.ULong &= (ulong)1 << 63;
return(doubleUnion.Double);
}
// No integral part
if (e < 0)
{
doubleUnion.ULong &= (ulong)1 << 63;
integral = doubleUnion.Double;
return(value);
}
var mask = 0xffffffffffffffff >> 12 >> e;
if ((doubleUnion.ULong & mask) == 0)
{
integral = value;
doubleUnion.ULong &= (ulong)1 << 63;
return(doubleUnion.Double);
}
doubleUnion.ULong &= ~mask;
integral = doubleUnion.Double;
return(value - integral);
}
