public static Scalar Min(params Scalar[] vals)
{
if (vals == null)
{
throw new ArgumentNullException("vals");
}
if (vals.Length == 0)
{
throw new ArgumentException("There must be at least one value to compare", "vals");
}
Scalar min = vals[0];
if (Scalar.IsNaN(min))
{
return(min);
}
for (int i = 1; i < vals.Length; i++)
{
Scalar val = vals[i];
if (val < min)
{
min = val;
}
else if (Scalar.IsNaN(val))
{
return(val);
}
}
return(min);
}
public static void SanityCheckVector(ref Vector3 v)
{
if (Scalar.IsNaN(v.X) || Scalar.IsNaN(v.Y) || Scalar.IsNaN(v.Z))
{
Debug.Assert(false);
}
}
/**
* Set value range (basic Axis Options)
* @param axisIndex 0 - primary axis, 1 - secondary axis
* @param minimum minimum value; Double.NaN - automatic; null - no change
* @param maximum maximum value; Double.NaN - automatic; null - no change
* @param majorUnit major unit value; Double.NaN - automatic; null - no change
* @param minorUnit minor unit value; Double.NaN - automatic; null - no change
*/
public void SetValueRange( int axisIndex, Double minimum, Double maximum, Double majorUnit, Double minorUnit){
ValueRangeRecord valueRange = (ValueRangeRecord)valueRanges[ axisIndex ];
if( valueRange == null ) return;
if( minimum != null ){
valueRange.AutomaticMinimum=minimum.IsNaN();
valueRange.MinimumAxisValue=minimum;
}
if( maximum != null ){
valueRange.SetAutomaticMaximum(maximum.IsNaN());
valueRange.SetMaximumAxisValue(maximum);
}
if( majorUnit != null ){
valueRange.SetAutomaticMajor(majorUnit.IsNaN());
valueRange.SetMajorIncrement(majorUnit);
}
if( minorUnit != null ){
valueRange.SetAutomaticMinor(minorUnit.IsNaN());
valueRange.SetMinorIncrement(minorUnit);
}
}
public static void SanityCheckFloat(Scalar f)
{
Debug.Assert(!Scalar.IsInfinity(f) && !Scalar.IsNaN(f));
}
private static unsafe void DoubleToNumber(double value, int precision, ref NumberBuffer number)
{
Debug.Assert(precision > 0 && precision < 40);
number.precision = precision;
if (!Double.IsFinite(value))
{
number.scale = Double.IsNaN(value) ? ScaleNAN : ScaleINF;
number.sign = Double.IsNegative(value);
number.digits[0] = '\0';
return;
}
byte *tempBuffer = stackalloc byte[MAX_BUFFER_SIZE];
char *dst = number.digits;
number.scale = 0;
number.sign = false;
*dst = '\0';
if (value < 0.0)
{
number.sign = true;
}
if (value == 0.0)
{
for (int j = 0; j < precision; j++)
{
dst[j] = '0';
}
dst[precision] = '\0';
return;
}
//
// Get the number formatted as a string in the form x.xxxxxxexxxx
//
// "%.40e"
byte *format = stackalloc byte[6];
format[0] = (byte)'%';
format[1] = (byte)'.';
format[2] = (byte)'4';
format[3] = (byte)'0';
format[4] = (byte)'e';
format[5] = 0;
int tempBufferLength = Interop.Sys.DoubleToString(value, format, tempBuffer, MAX_BUFFER_SIZE);
Debug.Assert(tempBufferLength > 0 && MAX_BUFFER_SIZE > tempBufferLength);
//
// Calculate the exponent value
//
int exponentIndex = tempBufferLength - 1;
while (tempBuffer[exponentIndex] != (byte)'e' && exponentIndex > 0)
{
exponentIndex--;
}
Debug.Assert(exponentIndex > 0 && (exponentIndex < tempBufferLength - 1));
int i = exponentIndex + 1;
int exponentSign = 1;
if (tempBuffer[i] == '-')
{
exponentSign = -1;
i++;
}
else if (tempBuffer[i] == '+')
{
i++;
}
int exponentValue = 0;
while (i < tempBufferLength)
{
Debug.Assert(tempBuffer[i] >= (byte)'0' && tempBuffer[i] <= (byte)'9');
exponentValue = exponentValue * 10 + (tempBuffer[i] - (byte)'0');
i++;
}
exponentValue *= exponentSign;
//
// Determine decimal location.
//
if (exponentValue == 0)
{
number.scale = 1;
}
else
{
number.scale = exponentValue + 1;
}
//
// Copy the string from the temp buffer upto precision characters, removing the sign, and decimal as required.
//
i = 0;
int mantissaIndex = 0;
while (i < precision && mantissaIndex < exponentIndex)
{
if (tempBuffer[mantissaIndex] >= (byte)'0' && tempBuffer[mantissaIndex] <= (byte)'9')
{
dst[i] = (char)tempBuffer[mantissaIndex];
i++;
}
mantissaIndex++;
}
while (i < precision)
{
dst[i] = '0'; // append zeros as needed
i++;
}
dst[i] = '\0';
//
// Round if needed
//
if (mantissaIndex >= exponentIndex || tempBuffer[mantissaIndex] < (byte)'5')
{
return; // rounding is not needed
}
i = precision - 1;
while (dst[i] == '9' && i > 0)
{
dst[i] = '0';
i--;
}
if (i == 0 && dst[i] == '9')
{
dst[i] = '1';
number.scale++;
}
else
{
dst[i]++;
}
}
