X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?p=rmac;a=blobdiff_plain;f=fltpoint.c;h=911e0085ae2729b6c513cf16f975061a86287adb;hp=38bd0b59be21cd829b79cd8146c3d811caf587f3;hb=66b362fa203d0850e8dce8045adb454e354c22ce;hpb=29b32d134bc12831a8ddd098bf9aeeda26dcfe7c

diff --git a/fltpoint.c b/fltpoint.c
index 38bd0b5..911e008 100644
--- a/fltpoint.c
+++ b/fltpoint.c
@@ -14,6 +14,7 @@
 #include "fltpoint.h"
 #include <float.h>
 #include <math.h>
+#include <stdio.h>
 
 //
 // Check for IEEE-754 conformance (C99 compilers should be OK here)
@@ -66,13 +67,13 @@
 
 uint32_t FloatToIEEE754(float f)
 {
-	uint32_t sign = (f < 0 ? 0x80000000 : 0);
+	uint32_t sign = (signbit(f) ? 0x80000000 : 0);
 
 	// Split the float into normalized mantissa (range: (-1, -0.5], 0,
 	// [+0.5, +1)) and base-2 exponent
 	// d = mantissa * (2 ^ exponent) *exactly* for FLT_RADIX=2
 	// Also, since we want the mantissa to be non-inverted (2's complemented),
-	// we make sure to pass in a positive number (floats/doubles are not 2's
+	// we make sure to pass in a positive number (floats/doubles are *not* 2's
 	// complemented) as we already captured the sign bit above.
 	int32_t exponent;
 	float mantissa = frexpf((f < 0 ? -f : f), &exponent);
@@ -104,14 +105,14 @@ uint32_t FloatToIEEE754(float f)
 
 uint64_t DoubleToIEEE754(double d)
 {
-	uint64_t sign = (d < 0 ? 0x8000000000000000LL : 0);
+	uint64_t sign = (signbit(d) ? 0x8000000000000000LL : 0);
 	int32_t exponent;
 
 	// Split double into normalized mantissa (range: (-1, -0.5], 0, [+0.5, +1))
 	// and base-2 exponent
 	// d = mantissa * (2 ^ exponent) *exactly* for FLT_RADIX=2
 	// Also, since we want the mantissa to be non-inverted (2's complemented),
-	// we make sure to pass in a positive number (floats/doubles are not 2's
+	// we make sure to pass in a positive number (floats/doubles are *not* 2's
 	// complemented) as we already captured the sign bit above.
 	double mantissa = frexp((d < 0 ? -d : d), &exponent);
 
@@ -141,9 +142,10 @@ uint64_t DoubleToIEEE754(double d)
 
 void DoubleToExtended(double d, uint8_t out[])
 {
+	int8_t sign = (signbit(d) ? 0x80 : 0);
 	int32_t exponent;
 	double mantissa = frexp((d < 0 ? -d : d), &exponent);
-	exponent += 0x3FFF;
+	exponent += 0x3FFE;
 
 	if (d == 0)
 		exponent = 0;
@@ -154,7 +156,7 @@ void DoubleToExtended(double d, uint8_t out[])
 	// Motorola extended floating point is 96 bits, so we pack it into the
 	// 12-byte array that's passed in. The format is as follows: 1 bit (sign),
 	// 15 bits (exponent w/$3FFF bias), 16 bits of zero, 64 bits of mantissa.
-	out[0] = (d < 0 ? 0x80 : 0x00) | ((exponent >> 8) & 0x7F);
+	out[0] = sign | ((exponent >> 8) & 0x7F);
 	out[1] = exponent & 0xFF;
 	out[2] = 0;
 	out[3] = 0;
@@ -168,3 +170,25 @@ void DoubleToExtended(double d, uint8_t out[])
 	out[11] = intMant & 0xFF;
 }
 
+
+//
+// Convert a host native floating point number to a fixed point number.
+//
+uint64_t DoubleToFixedPoint(double d, int intBits, int fracBits)
+{
+	uint8_t signBit = (signbit(d) ? 1 : 0);
+
+	// Ensure what we're working on is positive...
+	if (d < 0)
+		d *= -1;
+
+	double scaleFactor = (double)(1 << fracBits);
+	uint64_t result = (uint64_t)(d * scaleFactor);
+
+	// Invert the result, if necessary
+	if (signBit == 1)
+		result = (result = 0xFFFFFFFFFFFFFFFFLL) + 1;
+
+	return result;
+}
+