public static unsafe float CopySign(float x, float y)
{
// This method is required to work for all inputs,
// including NaN, so we operate on the raw bits.
var xbits = BitConverter.SingleToInt32Bits(x);
var ybits = BitConverter.SingleToInt32Bits(y);
// If the sign bits of x and y are not the same,
// flip the sign bit of x and return the new value;
// otherwise, just return x
if ((xbits ^ ybits) < 0)
{
return(BitConverter.Int32BitsToSingle(xbits ^ int.MinValue));
}
return(x);
}
public static float BitDecrement(float x)
{
var bits = BitConverter.SingleToInt32Bits(x);
if ((bits & 0x7F800000) >= 0x7F800000)
{
// NaN returns NaN
// -Infinity returns -Infinity
// +Infinity returns float.MaxValue
return((bits == 0x7F800000) ? float.MaxValue : x);
}
if (bits == 0x00000000)
{
// +0.0 returns -float.Epsilon
return(-float.Epsilon);
}
// Negative values need to be incremented
// Positive values need to be decremented
bits += ((bits < 0) ? +1 : -1);
return(BitConverter.Int32BitsToSingle(bits));
}
public static float BitIncrement(float x)
{
var bits = BitConverter.SingleToInt32Bits(x);
if ((bits & 0x7F800000) >= 0x7F800000)
{
// NaN returns NaN
// -Infinity returns float.MinValue
// +Infinity returns +Infinity
return((bits == unchecked ((int)(0xFF800000))) ? float.MinValue : x);
}
if (bits == unchecked ((int)(0x80000000)))
{
// -0.0 returns float.Epsilon
return(float.Epsilon);
}
// Negative values need to be decremented
// Positive values need to be incremented
bits += ((bits < 0) ? -1 : +1);
return(BitConverter.Int32BitsToSingle(bits));
}
public object?ToObject()
{
switch (CVType)
{
case CV_EMPTY:
return(null);
case CV_BOOLEAN:
return((object)((int)_data != 0));
case CV_I1:
return((object)((sbyte)_data));
case CV_U1:
return((object)((byte)_data));
case CV_CHAR:
return((object)((char)_data));
case CV_I2:
return((object)((short)_data));
case CV_U2:
return((object)((ushort)_data));
case CV_I4:
return((object)((int)_data));
case CV_U4:
return((object)((uint)_data));
case CV_I8:
return((object)((long)_data));
case CV_U8:
return((object)((ulong)_data));
case CV_R4:
return((object)(BitConverter.Int32BitsToSingle((int)_data)));
case CV_R8:
return((object)(BitConverter.Int64BitsToDouble(_data)));
case CV_DATETIME:
return(new DateTime(_data));
case CV_TIMESPAN:
return(new TimeSpan(_data));
case CV_ENUM:
return(BoxEnum());
case CV_MISSING:
return(Type.Missing);
case CV_NULL:
return(System.DBNull.Value);
case CV_DECIMAL:
case CV_STRING:
case CV_OBJECT:
default:
return(_objref);
}
}
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));
}
