fbc-tests: modify tests for -fpu sse -fpmode fast (less precision)

Author: jayrm

tests/optimizations/consteval.bas

@@ -7,12 +7,28 @@ SUITE( fbc_tests.optimizations.consteval )
 
 		const EPSILON_SNG as single = 1.19290929e-7
 
+		'' fast floating point is NOT precise, the compiler should have been
+		'' built with -fpmode precise, so we may have differences when
+		'' comparing const evaulation and runtime evaluation
+
+		#if __FB_FPMODE__ = "fast"
+			const EPSILON_SNG_FPU as single = EPSILON_SNG * 1000
+		#else
+			const EPSILON_SNG_FPU as single = EPSILON_SNG
+		#endif
+
 		#macro checkUop( func, value )
 			f = value
 			CU_ASSERT_DOUBLE_EQUAL( func( value ), func( f     ), EPSILON_SNG )
 			CU_ASSERT_DOUBLE_EQUAL( func( f     ), func( value ), EPSILON_SNG )
 		#endmacro
 
+		#macro checkUopFPU( func, value )
+			f = value
+			CU_ASSERT_DOUBLE_EQUAL( func( value ), func( f     ), EPSILON_SNG_FPU )
+			CU_ASSERT_DOUBLE_EQUAL( func( f     ), func( value ), EPSILON_SNG_FPU )
+		#endmacro
+
 		'' -
 		f =  1.0f : CU_ASSERT_DOUBLE_EQUAL( (- 1.0f), (- f)   , EPSILON_SNG )
 		f = -1.0f : CU_ASSERT_DOUBLE_EQUAL( (- 1.0f), f       , EPSILON_SNG )
@@ -26,20 +42,20 @@ SUITE( fbc_tests.optimizations.consteval )
 		CU_ASSERT_EQUAL( sgn(  0.0f ),  0 )
 		CU_ASSERT_EQUAL( sgn( -1.0f ), -1 )
 		'' sin
-		checkUop( sin,  1.0f )
-		checkUop( sin,  0.5f )
-		checkUop( sin, -0.5f )
-		checkUop( sin, -1.0f )
+		checkUopFPU( sin,  1.0f )
+		checkUopFPU( sin,  0.5f )
+		checkUopFPU( sin, -0.5f )
+		checkUopFPU( sin, -1.0f )
 		'' asin
 		checkUop( asin,  1.0f )
 		checkUop( asin,  0.5f )
 		checkUop( asin, -0.5f )
 		checkUop( asin, -1.0f )
 		'' cos
-		checkUop( cos,  1.0f )
-		checkUop( cos,  0.5f )
-		checkUop( cos, -0.5f )
-		checkUop( cos, -1.0f )
+		checkUopFPU( cos,  1.0f )
+		checkUopFPU( cos,  0.5f )
+		checkUopFPU( cos, -0.5f )
+		checkUopFPU( cos, -1.0f )
 		'' acos
 		checkUop( acos,  1.0f )
 		checkUop( acos,  0.5f )

tests/optimizations/inline-ops.bas

@@ -7,6 +7,17 @@ SUITE( fbc_tests.optimizations.inline_ops )
 	const EPSILON_SNG as single = 1.19290929e-7
 	const EPSILON_DBL as double = 2.2204460492503131e-016
 
+	'' fast floating point is NOT precise
+	#if __FB_FPMODE__ = "fast"
+		'' good to about 3 decimal places for 
+		'' cos/sin on -gen gas -fpu sse -fpmode fast
+		const EPSILON_SNG_FPU as single = EPSILON_SNG * 2000
+		const EPSILON_DBL_FPU as double = EPSILON_DBL * 2000
+	#else
+		const EPSILON_SNG_FPU as single = EPSILON_SNG
+		const EPSILON_DBL_FPU as double = EPSILON_DBL
+	#endif
+
 	#define hFixF( x ) (floorf( abs( x ) ) * sgn( x ))
 	#define hFixD( x ) ( floor( abs( x ) ) * sgn( x ))
 
@@ -165,9 +176,9 @@ SUITE( fbc_tests.optimizations.inline_ops )
 		for v as single = -1 to 1 step .01
 			CU_ASSERT_DOUBLE_EQUAL( frac( v ), (v - hFixF( v )) , EPSILON_SNG )
 			CU_ASSERT_DOUBLE_EQUAL(  fix( v ), hFixF( v ), EPSILON_SNG )
-			CU_ASSERT_DOUBLE_EQUAL(  sin( v ),  sinf( v ), EPSILON_SNG )
+			CU_ASSERT_DOUBLE_EQUAL(  sin( v ),  sinf( v ), EPSILON_SNG_FPU )
 			CU_ASSERT_DOUBLE_EQUAL( asin( v ), alt_asin( v ), EPSILON_SNG )
-			CU_ASSERT_DOUBLE_EQUAL(  cos( v ),  cosf( v ), EPSILON_SNG )
+			CU_ASSERT_DOUBLE_EQUAL(  cos( v ),  cosf( v ), EPSILON_SNG_FPU )
 			CU_ASSERT_DOUBLE_EQUAL( acos( v ), acosf( v ), EPSILON_SNG )
 			CU_ASSERT_DOUBLE_EQUAL(  tan( v ),  tanf( v ), EPSILON_SNG )
 			CU_ASSERT_DOUBLE_EQUAL(  atn( v ), atanf( v ), EPSILON_SNG )
@@ -244,7 +255,7 @@ SUITE( fbc_tests.optimizations.inline_ops )
 			dim x as single = 5
 			dim r as single
 			r = 1! / x
-			CU_ASSERT_DOUBLE_EQUAL( r, 0.2, EPSILON_SNG )
+			CU_ASSERT_DOUBLE_EQUAL( r, 0.2, EPSILON_SNG_FPU )
 		end scope
 
 		scope
@@ -287,7 +298,7 @@ SUITE( fbc_tests.optimizations.inline_ops )
 			dim x as TSQR
 			dim r as single
 			r =  1! / sqr(x)
-			CU_ASSERT_DOUBLE_EQUAL( r, 0.0625, EPSILON_SNG )
+			CU_ASSERT_DOUBLE_EQUAL( r, 0.0625, EPSILON_SNG_FPU )
 		end scope
 
 	END_TEST