public void WriteFloat(double value) { this.PrepareValue(); // ReSharper disable once CompareOfFloatsByEqualityOperator if (!this.forceFloat64 && value == (float)value) { // TODO: Increase testing coverage this.containerStack.IncreaseCurrentContainerLength(5); this.dataBuffer.WriteByte(TidFloatByte | 4); this.dataBuffer.WriteUint32(BitConverterEx.SingleToInt32Bits((float)value)); } else { this.containerStack.IncreaseCurrentContainerLength(9); this.dataBuffer.WriteByte(TidFloatByte | 8); if (double.IsNaN(value)) { // Double.NaN is different between C# and Java // For consistency, map NaN to the long value for NaN in Java this.dataBuffer.WriteUint64(0x7ff8000000000000L); } else { this.dataBuffer.WriteUint64(BitConverter.DoubleToInt64Bits(value)); } } this.FinishValue(); }
public void WriteFloat(double value) { PrepareValue(); // ReSharper disable once CompareOfFloatsByEqualityOperator if (value == (float)value) { //TODO requires careful testing _containerStack.IncreaseCurrentContainerLength(5); _dataBuffer.WriteByte(TidFloatByte | 4); _dataBuffer.WriteUint32(BitConverterEx.SingleToInt32Bits((float)value)); } else { _containerStack.IncreaseCurrentContainerLength(9); _dataBuffer.WriteByte(TidFloatByte | 8); _dataBuffer.WriteUint64(BitConverterEx.DoubleToInt64Bits(value)); } FinishValue(); }
public static unsafe bool IsNegative(float f) { var bits = unchecked ((uint)BitConverter.SingleToInt32Bits(f)); return((bits & 0x80000000) == 0x80000000); }
public static unsafe bool IsNaN(float f) { var bits = BitConverter.SingleToInt32Bits(f); return((bits & 0x7FFFFFFF) > 0x7F800000); }
public static bool IsFinite(float f) { var bits = BitConverter.SingleToInt32Bits(f); return((bits & 0x7FFFFFFF) < 0x7F800000); }
public static float Round(float x) { // ************************************************************************************ // IMPORTANT: Do not change this implementation without also updating MathF.Round(float), // FloatingPointUtils::round(double), and FloatingPointUtils::round(float) // ************************************************************************************ // This is based on the 'Berkeley SoftFloat Release 3e' algorithm uint bits = (uint)BitConverter.SingleToInt32Bits(x); int exponent = float.ExtractExponentFromBits(bits); if (exponent <= 0x7E) { if ((bits << 1) == 0) { // Exactly +/- zero should return the original value return(x); } // Any value less than or equal to 0.5 will always round to exactly zero // and any value greater than 0.5 will always round to exactly one. However, // we need to preserve the original sign for IEEE compliance. float result = ((exponent == 0x7E) && (float.ExtractSignificandFromBits(bits) != 0)) ? 1.0f : 0.0f; return(CopySign(result, x)); } if (exponent >= 0x96) { // Any value greater than or equal to 2^23 cannot have a fractional part, // So it will always round to exactly itself. return(x); } // The absolute value should be greater than or equal to 1.0 and less than 2^23 Debug.Assert((0x7F <= exponent) && (exponent <= 0x95)); // Determine the last bit that represents the integral portion of the value // and the bits representing the fractional portion uint lastBitMask = 1U << (0x96 - exponent); uint roundBitsMask = lastBitMask - 1; // Increment the first fractional bit, which represents the midpoint between // two integral values in the current window. bits += lastBitMask >> 1; if ((bits & roundBitsMask) == 0) { // If that overflowed and the rest of the fractional bits are zero // then we were exactly x.5 and we want to round to the even result bits &= ~lastBitMask; } else { // Otherwise, we just want to strip the fractional bits off, truncating // to the current integer value. bits &= ~roundBitsMask; } return(BitConverter.Int32BitsToSingle((int)bits)); }
public static unsafe bool IsNegative(float f) { return(BitConverter.SingleToInt32Bits(f) < 0); }
public static unsafe bool IsInfinity(float f) { int bits = BitConverter.SingleToInt32Bits(f); return((bits & 0x7FFFFFFF) == 0x7F800000); }
public Variant(float val) { _objref = null; _flags = CV_R4; _data = (uint)BitConverter.SingleToInt32Bits(val); }