Merge pull request #76 from jayrm/sqrt-overload

Allow overload operator SQR()

Author: jayrm

changelog.txt

@@ -11,6 +11,7 @@ Version 1.06.0
 - Windows API binding updated to additionally support _WIN32_WINNT &h0501, &h0600, &h0601
 - Under X11, ScreenControl GET_WINDOW_HANDLE places the Display ptr in param2
 - Updated bindings: SDL2 2.0.6, SDL2_image 2.0.1, SDL2_mixer 2.0.1, SDL2_net 2.0.1, SDL2_ttf 2.0.14
+- allow overload operator SQR()
 
 [fixed]
 - win/d3dx9.bi no longer has a hard-coded #inclib "d3dx9d". d3dx9d.dll is apparently not a generally valid choice. In practice programs have to be linked against d3dx9_33.dll or d3dx9_39.dll, etc.

src/compiler/ast-optimize.bas

@@ -1739,19 +1739,22 @@ private function hOptReciprocal _
 		if( astIsCONST( l ) ) then
 			if( (astGetDataType( l ) = FB_DATATYPE_SINGLE) andalso (astConstGetFloat( l ) = 1.0) ) then
 				r = n->r
-				if( astIsUOP( r, AST_OP_SQRT ) ) then
-					'' change this to a rsqrt
-					*n = *r
-					n->class = AST_NODECLASS_UOP
-					n->op.op = AST_OP_RSQRT
-					astDelNode( r )
-					astDelNode( l )
-				elseif( astGetDataType( r ) = FB_DATATYPE_SINGLE ) then
-					'' change this to a rcp
-					astDelNode( n )
-					n = astNewUOP( AST_OP_RCP, r )
-					astDelNode( l )
-				end if
+				select case as const astGetDataClass( r )
+				case FB_DATACLASS_INTEGER, FB_DATACLASS_FPOINT
+					if( astIsUOP( r, AST_OP_SQRT ) ) then
+						'' change this to a rsqrt
+						*n = *r
+						n->class = AST_NODECLASS_UOP
+						n->op.op = AST_OP_RSQRT
+						astDelNode( r )
+						astDelNode( l )
+					elseif( astGetDataType( r ) = FB_DATATYPE_SINGLE ) then
+						'' change this to a rcp
+						astDelNode( n )
+						n = astNewUOP( AST_OP_RCP, r )
+						astDelNode( l )
+					end if
+				end select
 			end if
 		end if
 	end if

src/compiler/parser-assignment.bas

@@ -65,7 +65,7 @@ function cOperator( byval is_overload as integer ) as integer
 	     FB_TK_ABS, FB_TK_SGN, FB_TK_FIX, FB_TK_FRAC, _
 	     FB_TK_INT, FB_TK_EXP, FB_TK_LOG, FB_TK_SIN, _
 	     FB_TK_ASIN, FB_TK_COS, FB_TK_ACOS, FB_TK_TAN, _
-	     FB_TK_ATN, FB_TK_LEN, _
+	     FB_TK_ATN, FB_TK_SQR, FB_TK_LEN, _
 	     FB_TK_ADDROFCHAR, FB_TK_FIELDDEREF, CHAR_LBRACKET, _
 	     FB_TK_NEW, FB_TK_DELETE, _
 	     FB_TK_FOR, FB_TK_STEP, FB_TK_NEXT
@@ -99,6 +99,7 @@ function cOperator( byval is_overload as integer ) as integer
 		case FB_TK_ACOS : op = AST_OP_ACOS
 		case FB_TK_TAN  : op = AST_OP_TAN
 		case FB_TK_ATN  : op = AST_OP_ATAN
+		case FB_TK_SQR  : op = AST_OP_SQRT
 		case FB_TK_LEN  : op = AST_OP_LEN
 		case FB_TK_ADDROFCHAR : op = AST_OP_ADDROF
 		case FB_TK_FIELDDEREF : op = AST_OP_FLDDEREF

src/compiler/symb-mangling.bas

@@ -1067,6 +1067,9 @@ private function hGetOperatorName( byval proc as FBSYMBOL ptr ) as const zstring
 	case AST_OP_ATAN
 		function = @"v13atn"
 
+	case AST_OP_SQRT
+		function = @"v13sqr"
+
 	case AST_OP_NEW, AST_OP_NEW_SELF
 		function = @"nw"
 

tests/Makefile

@@ -89,6 +89,8 @@ all :
 	@$(ECHO) "   ARCH=arch (default is 486)"
 	@$(ECHO) "   OS=DOS"
 	@$(ECHO) "   FPU=fpu | sse"
+	@$(ECHO) "   FPMODE=fast | precise"
+	@$(ECHO) "   GEN=gas | gcc"
 	@$(ECHO) "   UNITTEST_RUN_ARGS=args"
 	@$(ECHO) "   ENABLE_CHECK_BUGS=1"
 	@$(ECHO) "   ENABLE_CONSOLE_OUTPUT=1"

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 ))
 
@@ -30,7 +41,7 @@ SUITE( fbc_tests.optimizations.inline_ops )
 		end if
 	end function
 
-	TEST( all )
+	TEST( sgn_ )
 
 		scope
 			dim as long l
@@ -58,6 +69,10 @@ SUITE( fbc_tests.optimizations.inline_ops )
 			ll = &h8000000000000000ll : CU_ASSERT_EQUAL( sgn( ll ), -1 )
 		end scope
 
+	END_TEST
+
+	TEST( abs_ )
+
 		'' Not all the abs() tests below are useful to test abs(), but they
 		'' also help testing -gen gcc's number literal emitting.
 		scope
@@ -136,12 +151,34 @@ SUITE( fbc_tests.optimizations.inline_ops )
 			CU_ASSERT_DOUBLE_EQUAL( int( v ), floor( v ), EPSILON_DBL )
 		next
 
+	END_TEST
+
+
+	'' transcendental tests
+
+	#ifdef __FB_DOS__
+		'' djgpp's math lib has an implementation that requires 2 * EPSILON_SNG to
+		'' pass the single asin() tests, we could increase epsilon, or calculate with
+		'' alternate asin() function
+		#if ENABLE_CHECK_BUGS
+			#define alt_asin asinf
+		#else
+			private function alt_asin( byval x as single ) as single
+				function = atan2(x, sqr( 1! - x*x ))
+			end function
+		#endif
+	#else
+		#define alt_asin asinf
+	#endif
+
+    TEST( transcendental )
+
 		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( asin( v ), asinf( v ), EPSILON_SNG )
-			CU_ASSERT_DOUBLE_EQUAL(  cos( v ),  cosf( 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_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 )
@@ -184,6 +221,86 @@ SUITE( fbc_tests.optimizations.inline_ops )
 			b = 5.0
 			CU_ASSERT_DOUBLE_EQUAL( atan2( a, b ), atan2_( a, b ), EPSILON_DBL )
 		end scope
+
+	END_TEST
+
+	
+	'' reciprocal 
+
+	type TDIV
+		__ as integer
+	end type
+	operator / ( byval x as single, byref y as const TDIV ) as single
+		operator = 888 '' cook a value to test with
+	end operator
+
+	type TSQR
+		__ as integer
+	end type
+	operator sqr ( byref x as const TSQR ) as single
+		operator = 16 '' cook a value to test with
+	end operator
+
+	TEST( reciprocal )
+
+		'' in some modes (i.e. -gen gas -fpmode fast -fpu sse )
+		'' AST optimizer will replace expressions with equivalent
+		'' reciprocal instructions.  We can't prove that the
+		'' optimization actually took place unless we look at the
+		'' ASM/C code generated, but we can prove that fb code has 
+		'' valid results for all forms.
+
+		scope
+			'' 1! / single
+			dim x as single = 5
+			dim r as single
+			r = 1! / x
+			CU_ASSERT_DOUBLE_EQUAL( r, 0.2, EPSILON_SNG_FPU )
+		end scope
+
+		scope
+			'' 1! / double
+			dim x as double = 5
+			dim r as single
+			r = 1! / x
+			CU_ASSERT_DOUBLE_EQUAL( r, 0.2, EPSILON_SNG )
+		end scope
+
+		scope
+			'' 1! / integer
+			dim x as integer = 5
+			dim r as single
+			r = 1! / x
+			CU_ASSERT_DOUBLE_EQUAL( r, 0.2, EPSILON_SNG )
+		end scope
+
+		scope
+			'' 1! / sqr(number)
+			dim x as single = 0.0025
+			dim r as single
+			r = 1! / sqr(x)
+			CU_ASSERT_DOUBLE_EQUAL( r, 20, EPSILON_SNG )
+		end scope
+
+		'' For overloaded / and SQR(), prove that the
+		'' optimization is not used.
+
+		scope
+			'' 1! / UDT
+			dim x as TDIV
+			dim r as single
+			r =  1! / x
+			CU_ASSERT_DOUBLE_EQUAL( r, 888, EPSILON_SNG )
+		end scope
+
+		scope
+			'' 1! / SQR(UDT)
+			dim x as TSQR
+			dim r as single
+			r =  1! / sqr(x)
+			CU_ASSERT_DOUBLE_EQUAL( r, 0.0625, EPSILON_SNG_FPU )
+		end scope
+
 	END_TEST
 
 END_SUITE

tests/structs/ops.bas

@@ -32,6 +32,7 @@ SUITE( fbc_tests.structs.ops )
 	makeop(INT)
 	makeop(EXP)
 	makeop(LOG)
+	makeop(SQR)
 	makeop(SIN)
 	makeop(ASIN)
 	makeop(COS)
@@ -74,6 +75,7 @@ SUITE( fbc_tests.structs.ops )
 		testop(INT)
 		testop(EXP)
 		testop(LOG)
+		testop(SQR)
 		testop(SIN)
 		testop(ASIN)
 		testop(COS)

tests/unit-tests.mk

@@ -96,6 +96,9 @@ endif
 ifneq ($(FPU),)
 	FBC_CFLAGS += -fpu $(FPU)
 endif
+ifneq ($(FPMODE),)
+	FBC_CFLAGS += -fpmode $(FPMODE)
+endif
 ifneq ($(GEN),)
 	FBC_CFLAGS += -gen $(GEN)
 endif