math.hhf

High Level assembly language(HLA)软件

			@external( "MATH_ACOT32" );

	procedure acot64( r:real64 ); 		@returns( "st0" ); 
			@external( "MATH_ACOT64" );

	procedure acot80( r:real80 ); 		@returns( "st0" ); 
			@external( "MATH_ACOT80" );




	


	#macro acsc( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._acsc() )
			hla.signature( math.acsc32(real32) )
			hla.signature( math.acsc64(real64) )
			hla.signature( math.acsc80(real80) )
			
		hla.endoverload
		
	#endmacro

	
	procedure _acsc;					@returns( "st0" ); 
			@external( "MATH__ACSC" );

	procedure acsc64( r:real64 ); 		@returns( "st0" ); 
			@external( "MATH_ACSC64" );

	procedure acsc32( r:real32 ); 		@returns( "st0" ); 
			@external( "MATH_ACSC32" );

	procedure acsc80( r:real80 ); 		@returns( "st0" ); 
			@external( "MATH_ACSC80" );




	


	#macro asec( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._asec() )
			hla.signature( math.asec32(real32) )
			hla.signature( math.asec64(real64) )
			hla.signature( math.asec80(real80) )
			
		hla.endoverload
		
	#endmacro
	
	procedure _asec; 					@returns( "st0" ); 
			@external( "MATH__ASEC" );

	procedure asec32( r:real32 ); 		@returns( "st0" ); 
			@external( "MATH_ASEC32" );

	procedure asec64( r:real64 ); 		@returns( "st0" ); 
			@external( "MATH_ASEC64" );

	procedure asec80( r:real80 ); 		@returns( "st0" ); 
			@external( "MATH_ASEC80" );




	


	#macro twoToX( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._twoToX() )
			hla.signature( math.twoToX32(real32) )
			hla.signature( math.twoToX64(real64) )
			hla.signature( math.twoToX80(real80) )
			
		hla.endoverload
		
	#endmacro

	
	procedure _twoToX;					@returns( "st0" ); 
			@external( "MATH__TWOTOX" );

	procedure twoToX32( r:real32 );		@returns( "st0" ); 
			@external( "MATH_TWOTOX32" );

	procedure twoToX64( r:real64 );		@returns( "st0" ); 
			@external( "MATH_TWOTOX64" );

	procedure twoToX80( r:real80 );		@returns( "st0" ); 
			@external( "MATH_TWOTOX80" );





	


	#macro tenToX( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._tenToX() )
			hla.signature( math.tenToX32(real32) )
			hla.signature( math.tenToX64(real64) )
			hla.signature( math.tenToX80(real80) )
			
		hla.endoverload
		
	#endmacro
   
	
	procedure _tenToX;					@returns( "st0" ); 
			@external( "MATH__TENTOX" );

	procedure tenToX32( r:real32 ); 	@returns( "st0" ); 
			@external( "MATH_TENTOX32" );

	procedure tenToX64( r:real64 ); 	@returns( "st0" ); 
			@external( "MATH_TENTOX64" );

	procedure tenToX80( r:real80 ); 	@returns( "st0" ); 
			@external( "MATH_TENTOX80" );





	


	#macro exp( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._exp() )
			hla.signature( math.exp32(real32) )
			hla.signature( math.exp64(real64) )
			hla.signature( math.exp80(real80) )
			
		hla.endoverload
		
	#endmacro

	
	procedure _exp; 					@returns( "st0" ); 
			@external( "MATH__EXP" );

	procedure exp32( r:real32 ); 		@returns( "st0" ); 
			@external( "MATH_EXP32" );

	procedure exp64( r:real64 ); 		@returns( "st0" ); 
			@external( "MATH_EXP64" );

	procedure exp80( r:real80 ); 		@returns( "st0" ); 
			@external( "MATH_EXP80" );






	


	#macro yToX( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._yToX() )
			hla.signature( math.yToX32(real32) )
			hla.signature( math.yToX64(real64) )
			hla.signature( math.yToX80(real80) )
			
		hla.endoverload
		
	#endmacro

	
	procedure _yToX;							@returns( "st0" ); 
			@external( "MATH__YTOX" );

	procedure yToX32( y:real32; x:real32 );		@returns( "st0" ); 
			@external( "MATH_YTOX32" );

	procedure yToX64( y:real64; x:real64 );		@returns( "st0" ); 
			@external( "MATH_YTOX64" );

	procedure yToX80( y:real80; x:real80 );		@returns( "st0" ); 
			@external( "MATH_YTOX80" );







	


	#macro log( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._log() )
			hla.signature( math.log32(real32) )
			hla.signature( math.log64(real64) )
			hla.signature( math.log80(real80) )
			
		hla.endoverload
		
	#endmacro

	
	procedure _log; 					@returns( "st0" ); 
			@external( "MATH__LOG" );

	procedure log32( r:real32 ); 		@returns( "st0" ); 
			@external( "MATH_LOG32" );

	procedure log64( r:real64 ); 		@returns( "st0" ); 
			@external( "MATH_LOG64" );

	procedure log80( r:real80 ); 		@returns( "st0" ); 
			@external( "MATH_LOG80" );







	


	#macro ln( parms[] );
	
		hla.overload( parms )
		
			hla.signature( math._ln() )
			hla.signature( math.ln32(real32) )
			hla.signature( math.ln64(real64) )
			hla.signature( math.ln80(real80) )
			
		hla.endoverload
		
	#endmacro

	
	procedure _ln; 						@returns( "st0" ); 
			@external( "MATH__LN" );

	procedure ln32( r:real32 ); 		@returns( "st0" ); 
			@external( "MATH_LN32" );

	procedure ln64( r:real64 ); 		@returns( "st0" ); 
			@external( "MATH_LN64" );

	procedure ln80( r:real80 ); 		@returns( "st0" ); 
			@external( "MATH_LN80" );



		
	// Unsigned division by a constant using reciprocal multiplication
	// Leaves quotient in EDX. Usually modifies EAX.
	
	val
		n:=0;
		a:=@global:false;
		t:=0;
		l:=0;
		j:=0;
		k:=0;
		s:=0;
		m:=0;
		r:=0;
		m_low:=0;
		m_high:=0;
		_li := 0;
		
	
	#macro udivc( divisor, dividend );

		#if( !@isConst( divisor ))
		
			#error( "Expected a constant as divisor operand" )
				
		#elseif( divisor = 0 )
		
			#error( "Attempt to divide by constant zero" )
			
		#elseif( divisor >= $8000_0000 )
		
			cmp( dividend, divisor );
			mov( 0, edx );
			sbb( -1, edx );
						
		#else
		
			// Reduce divisor until it becomes odd
			
			?math.n := 0;
			?math.t := divisor;
			#while( (math.t & 1) = 0 )
			
				?math.t := math.t >> 1;
				?math.n := math.n + 1;
				
			#endwhile
			
			// Check for a power of two (easy and cheap):
			
			#if( math.t = 1 )
			
				#if( math.n = 0 )	// Division by 1.
				
					#if( @lowercase(@string( dividend ), 0) <> "edx" )
					
						mov( dividend, edx );
						
					#endif
					
				#else
				
					#if( @lowercase(@string( dividend ), 0) <> "edx" )
					
						mov( dividend, edx );
						
					#endif
					shr( math.n, edx );
					
				#endif
				
			#else
			
				?math.l := 0;
				?math._li := math.t >> 1;
				#while( math._li <> 0 )
				
					?math._li := math._li >> 1;
					?math.l := math.l + 1;
					
				#endwhile
				?math.l := math.l + 1;

				?math.j := ($ffff_ffff mod math.t);
				?math.k := (1 << (32 + math.l)) div ( $ffff_ffff - math.j);
				?math.m_low := (1 << (32 + math.l)) div math.t;
				?math.m_high := ((1 << (32 + math.l)) + math.k) div math.t;
				#while( ((math.m_low >> 1) < (math.m_high >> 1)) & (math.l > 0))
				
					?math.m_low := math.m_low >> 1;
					?math.m_high := math.m_high >> 1;
					?math.l := math.l - 1;
					
				#endwhile
				
				#if( (math.m_high >> 32) = 0 )
				
					?math.m := math.m_high;
					?math.s := math.l;
					?math.a := @global:false;
					
				#else
				
					?math.s := 0;
					?math._li := math.t >> 1;
					#while( math._li <> 0 )
					
						?math._li := math._li >> 1;
						?math.s += 1;
						
					#endwhile
				
					?math.m_low := (( 1 << (32+math.s)) div math.t;
					?math.r := (1 << (32+math.s)) mod math.t;
					#if( math.r < ((math.t >> 1) + 1))
					
						?math.m := math.m_low;
						
					#else
					
						?math.m := math.m_low+1;
						
					#endif
					?math.a := @global:true; 
					
				#endif
				#while( (math.m & 1) = 0 )
				
					?math.m := math.m >> 1;
					?math.s := math.s - 1;
				
				#endwhile
				?math.s := math.s + math.n;
				#if( math.a )
				
					#if( @lowercase(@string( dividend ),0) <> "eax" )
					
						mov( math.m, eax );
						mul( dividend );
						add( math.m, eax );
						adc( 0, edx );
						#if( math.s <> 0 )
						
							shr( math.s, edx );
							
						#endif
						
					#else
						
						mov( eax, edx );
						mov( math.m, eax );
						mul( edx );
						add( math.m, eax );
						adc( 0, edx );
						#if( math.s <> 0 )
						
							shr( math.s, edx );
						
						#endif
						
					#endif
				
				#else
				
					#if( @lowercase(@string( dividend ),0) <> "eax" )
					
						mov( math.m, eax );
						mul( dividend );
						shr( math.s, edx );
						
					#else
						
						mov( eax, edx );
						mov( math.m, eax );
						mul( dividend );
						shr( math.s, edx );
						
					#endif
				
				#endif
			
			#endif
					
		#endif
		
	#endmacro


end math;


#endif