QD library

Headers, Bindings, Libraries for use with FreeBASIC, Please include example of use to help ensure they are tested and usable.
Post Reply
srvaldez
Posts: 3373
Joined: Sep 25, 2005 21:54

QD library

Post by srvaldez »

here are Windows binaries of this Quad-mat library for anyone interested.
Last edited by srvaldez on Aug 27, 2017 19:33, edited 1 time in total.
srvaldez
Posts: 3373
Joined: Sep 25, 2005 21:54

Re: QD library

Post by srvaldez »

minor update to the headers
dd.bi

Code: Select all

#Ifdef __fb_win32__
	#Ifdef __fb_64bit__
		#Inclib "qd64"
	#Else
		#Inclib "qd32"
	#Endif
#Endif

#define DD_H_

Type dd
    As Double ddm1, ddm2
    
    Declare Constructor()
    Declare Constructor( Byref rhs As dd)
    Declare Constructor(Byval a As Double, Byval b As Double)
    Declare Constructor ( Byval rhs As Long )
    Declare Constructor ( Byval rhs As Longint )
    Declare Constructor ( Byval rhs As Integer )
    Declare Constructor ( Byval rhs As Double )
    Declare Constructor ( Byref rhs As String )

	Declare Operator Let ( Byref rhs As dd )
    Declare Operator Let ( Byval rhs As Long )
    Declare Operator Let ( Byval rhs As Longint )
    Declare Operator Let ( Byval rhs As Integer )
    Declare Operator Let ( Byval rhs As Double )
    Declare Operator Let ( Byref rhs As String )
    
    Declare Operator Cast ( ) As String
    Declare Operator Cast ( ) As Long
    Declare Operator Cast ( ) As Double
    Declare Operator Cast ( ) As Single

    ' For Next Implicit step = +1
    Declare Operator For ( )
    Declare Operator Step( )
    Declare Operator Next( Byref end_cond As dd ) As Integer
    ' For Next Exlicit step
    Declare Operator For ( Byref stp As dd )
    Declare Operator Step( Byref stp As dd )
    Declare Operator Next( Byref end_cond As dd, Byref step_var As dd ) As Integer
    ' self
    Declare Operator += (Byref rhs As dd)
    Declare Operator += (Byval rhs As Long)
    Declare Operator += (Byval rhs As Double)
    Declare Operator += (Byval rhs As Longint)
    Declare Operator += (Byval rhs As Integer)
    Declare Operator += (Byref rhs As String)
    Declare Operator -= (Byref rhs As dd)
    Declare Operator -= (Byval rhs As Double)
    Declare Operator -= (Byval rhs As Longint)
    Declare Operator -= (Byval rhs As Integer)
    Declare Operator -= (Byval rhs As Long)
    Declare Operator -= (Byref rhs As String)
    Declare Operator *= (Byref rhs As dd)
    Declare Operator *= (Byval rhs As Double)
    Declare Operator *= (Byval rhs As Longint)
    Declare Operator *= (Byval rhs As Integer)
    Declare Operator *= (Byval rhs As Long)
    Declare Operator *= (Byref rhs As String)
    Declare Operator /= (Byref rhs As dd)
    Declare Operator /= (Byval rhs As Double)
    Declare Operator /= (Byval rhs As Longint)
    Declare Operator /= (Byval rhs As Integer)
    Declare Operator /= (Byval rhs As Long)
    Declare Operator /= (Byref rhs As String)
End Type

	Declare Sub c_dd_abs          Cdecl Alias "c_dd_abs"          ( Byref As dd,Byref As dd )
	Declare Sub c_dd_acos         Cdecl Alias "c_dd_acos"         ( Byref As dd,Byref As dd )
	Declare Sub c_dd_acosh        Cdecl Alias "c_dd_acosh"        ( Byref As dd,Byref As dd )
	Declare Sub c_dd_add          Cdecl Alias "c_dd_add"          ( Byref As dd, Byref As dd, Byref As dd )
	Declare Sub c_dd_add_d_dd     Cdecl Alias "c_dd_add_d_dd"     ( Byval As Double, Byref As dd,Byref As dd )
	Declare Sub c_dd_add_dd_d     Cdecl Alias "c_dd_add_dd_d"     ( Byref As dd, Byval As Double,Byref As dd )
	Declare Sub c_dd_aint         Cdecl Alias "c_dd_aint"         ( Byref As dd,Byref As dd )
	Declare Sub c_dd_asin         Cdecl Alias "c_dd_asin"         ( Byref As dd,Byref As dd )
	Declare Sub c_dd_asinh        Cdecl Alias "c_dd_asinh"        ( Byref As dd,Byref As dd )
	Declare Sub c_dd_atan         Cdecl Alias "c_dd_atan"         ( Byref As dd,Byref As dd )
	Declare Sub c_dd_atan2        Cdecl Alias "c_dd_atan2"        ( Byref As dd, Byref As dd, Byref As dd )
	Declare Sub c_dd_atanh        Cdecl Alias "c_dd_atanh"        ( Byref As dd,Byref As dd )
	Declare Sub c_dd_ceil         Cdecl Alias "c_dd_ceil"         ( Byref As dd,Byref As dd )
	Declare Sub c_dd_comp         Cdecl Alias "c_dd_comp"         ( Byref As dd,Byref As dd, Byval As Long Ptr )
	Declare Sub c_dd_comp_d_dd    Cdecl Alias "c_dd_comp_d_dd"    ( Byval As Double,Byref As dd, Byval As Long Ptr )
	Declare Sub c_dd_comp_dd_d    Cdecl Alias "c_dd_comp_dd_d"    ( Byref As dd,Byval As Double, Byval As Long Ptr )
	Declare Sub c_dd_copy         Cdecl Alias "c_dd_copy"         ( Byref As dd,Byref As dd )
	Declare Sub c_dd_copy_d       Cdecl Alias "c_dd_copy_d"       ( Byval As Double,Byref As dd )
	Declare Sub c_dd_cos          Cdecl Alias "c_dd_cos"          ( Byref As dd,Byref As dd )
	Declare Sub c_dd_cosh         Cdecl Alias "c_dd_cosh"         ( Byref As dd,Byref As dd )
	Declare Sub c_dd_div          Cdecl Alias "c_dd_div"          ( Byref As dd, Byref As dd, Byref As dd )
	Declare Sub c_dd_div_d_dd     Cdecl Alias "c_dd_div_d_dd"     ( Byval As Double, Byref As dd, Byref As dd )
	Declare Sub c_dd_div_dd_d     Cdecl Alias "c_dd_div_dd_d"     ( Byref As dd, Byval As Double, Byref As dd )
	Declare Sub c_dd_exp          Cdecl Alias "c_dd_exp"          ( Byref As dd,Byref As dd )
	Declare Sub c_dd_exp10        Cdecl Alias "c_dd_exp10"        ( Byref As dd,Byref As dd )
	Declare Sub c_dd_floor        Cdecl Alias "c_dd_floor"        ( Byref As dd,Byref As dd )
	Declare Sub c_dd_log          Cdecl Alias "c_dd_log"          ( Byref As dd,Byref As dd )
	Declare Sub c_dd_log10        Cdecl Alias "c_dd_log10"        ( Byref As dd,Byref As dd )
	Declare Sub c_dd_mul          Cdecl Alias "c_dd_mul"          ( Byref As dd, Byref As dd, Byref As dd )
	Declare Sub c_dd_mul_d_dd     Cdecl Alias "c_dd_mul_d_dd"     ( Byval As Double, Byref As dd, Byref As dd )
	Declare Sub c_dd_mul_dd_d     Cdecl Alias "c_dd_mul_dd_d"     ( Byref As dd, Byval As Double, Byref As dd )
	Declare Sub c_dd_neg          Cdecl Alias "c_dd_neg"          ( Byref As dd,Byref As dd )
	Declare Sub c_dd_nint         Cdecl Alias "c_dd_nint"         ( Byref As dd,Byref As dd )
	Declare Sub c_dd_npwr         Cdecl Alias "c_dd_npwr"         ( Byref As dd, Byval As Integer, Byref As dd )
	Declare Sub c_dd_nroot        Cdecl Alias "c_dd_nroot"        ( Byref As dd, Byval As Integer, Byref As dd )
	Declare Sub c_dd_pi           Cdecl Alias "c_dd_pi"           ( Byref As dd )
	Declare Sub c_dd_rand         Cdecl Alias "c_dd_rand"         ( Byref As dd )
	Declare Sub c_dd_read         Cdecl Alias "c_dd_read"         ( Byval As Zstring Ptr, Byref As dd )
	Declare Sub c_dd_sin          Cdecl Alias "c_dd_sin"          ( Byref As dd,Byref As dd )
	Declare Sub c_dd_sincos       Cdecl Alias "c_dd_sincos"       ( Byref As dd, Byref As dd, Byref As dd )
	Declare Sub c_dd_sincosh      Cdecl Alias "c_dd_sincosh"      ( Byref As dd, Byref As dd, Byref As dd )
	Declare Sub c_dd_sinh         Cdecl Alias "c_dd_sinh"         ( Byref As dd,Byref As dd )
	Declare Sub c_dd_sqr          Cdecl Alias "c_dd_sqr"          ( Byref As dd,Byref As dd )
	Declare Sub c_dd_sqrt         Cdecl Alias "c_dd_sqrt"         ( Byref As dd,Byref As dd )
	Declare Sub c_dd_Sub          Cdecl Alias "c_dd_sub"          ( Byref As dd, Byref As dd, Byref As dd )
	Declare Sub c_dd_sub_d_dd     Cdecl Alias "c_dd_sub_d_dd"     ( Byval As Double, Byref As dd, Byref As dd )
	Declare Sub c_dd_sub_dd_d     Cdecl Alias "c_dd_sub_dd_d"     ( Byref As dd, Byval As Double, Byref As dd )
	Declare Sub c_dd_swrite       Cdecl Alias "c_dd_swrite"       ( Byref As dd,Byval As Integer, Byval As Zstring Ptr, baval As Integer )
	Declare Sub c_dd_tan          Cdecl Alias "c_dd_tan"          ( Byref As dd,Byref As dd )
	Declare Sub c_dd_tanh         Cdecl Alias "c_dd_tanh"         ( Byref As dd,Byref As dd )
	Declare Sub c_dd_write        Cdecl Alias "c_dd_write"        ( Byref As dd )

	Dim Shared As dd _dd_2pi = dd(6.283185307179586232e+00,_
						2.449293598294706414e-16)
										  
	Dim Shared As dd _dd_pi = dd(3.141592653589793116e+00,_
						1.224646799147353207e-16)
										 
	Dim Shared As dd _dd_pi2 = dd(1.570796326794896558e+00,_
						6.123233995736766036e-17)
										  
	Dim Shared As dd _dd_pi4 = dd(7.853981633974482790e-01,_
						3.061616997868383018e-17)
										  
	Dim Shared As dd _dd_3pi4 = dd(2.356194490192344837e+00,_
						9.1848509936051484375e-17)
										   
	Dim Shared As dd _dd_e = dd(2.718281828459045091e+00,_
						1.445646891729250158e-16)
									   
	Dim Shared As dd _dd_log2 = dd(6.931471805599452862e-01,_
						2.319046813846299558e-17)
										   
	Dim Shared As dd _dd_log10 = dd(2.302585092994045901e+00,_
						-2.170756223382249351e-16)
											

	Const _dd_eps As Double = 4.93038065763132e-32  ' 2^-104
	Const _dd_min_normalized As Double = 2.0041683600089728e-292  ' = 2^(-1022 + 53)
	Dim Shared As dd _dd_max = _
		dd(1.79769313486231570815e+308, 9.97920154767359795037e+291)
		
	Dim Shared As dd _dd_safe_max = _
		dd(1.7976931080746007281e+308, 9.97920154767359795037e+291)
		
	Const _dd_ndigits As Long = 31

	Constructor dd()
		this.ddm1=Cdbl(0)
		this.ddm2=Cdbl(0)
	End Constructor

	Constructor dd(Byref rhs As dd)
		c_dd_copy( rhs, This )
	End Constructor
	
	Constructor dd(Byval a As Double, Byval b As Double)
		this.ddm1=a
		this.ddm2=b
	End Constructor

	Constructor dd( Byval rhs As Long )
		this.ddm1=Cdbl(rhs)
		this.ddm2=Cdbl(0)
	End Constructor

	Constructor dd( Byval rhs As Longint )
		c_dd_read( Str(rhs), This )
	End Constructor

	Constructor dd( Byval rhs As Integer )
		c_dd_read( Str(rhs), This )
	End Constructor

	Constructor dd( Byval rhs As Double )
		this.ddm1=rhs
		this.ddm2=Cdbl(0)
	End Constructor

	Constructor dd( Byref rhs As String )
		c_dd_read( rhs, This )
	End Constructor

	Operator dd.let(Byref rhs As dd)
		c_dd_copy( rhs, This )
	End Operator
	
	Operator dd.let( Byval rhs As Long )
		this.ddm1=Cdbl(rhs)
		this.ddm2=Cdbl(0)
	End Operator

	Operator dd.let( Byval rhs As Longint )
		c_dd_read( Str(rhs), This )
	End Operator

	Operator dd.let( Byval rhs As Integer )
		c_dd_read( Str(rhs), This )
	End Operator

	Operator dd.let( Byval rhs As Double )
		this.ddm1=rhs
		this.ddm2=Cdbl(0)
	End Operator

	Operator dd.let( Byref rhs As String )
		c_dd_read( rhs, This )
	End Operator

	Operator dd.cast ( ) As String
		Dim As String sp=" "
		Dim As Zstring Ptr rstring=Allocate(127)
		c_dd_swrite(This, 32, rstring, 120)
		If (this.ddm1)<0 Then sp = ""
		Operator = sp + Ltrim(*rstring)
		Deallocate(rstring)
	End Operator

	Operator dd.cast ( ) As Long
		Operator = Clng(this.ddm1)
	End Operator

	Operator dd.cast ( ) As Double
		Operator = this.ddm1
	End Operator

	Operator dd.cast ( ) As Single
		Operator = Csng(this.ddm1)
	End Operator

	'============================================================================
	'' For Next for dd type
	''
	'' implicit step versions
	'' 
	'' In this example, we interpret implicit step
	'' to mean 1
	Operator dd.for ( )
	End Operator
	 
	Operator dd.step ( )
			c_dd_add_dd_d(This, 1, This) 'this = this+1 '
	End Operator 
	 
	Operator dd.next ( Byref end_cond As dd ) As Integer
		Dim As Long tst
		c_dd_comp( This, end_cond, @tst)
		Return tst-1
	End Operator
	 
	 
	'' explicit step versions
	'' 
	Operator dd.for ( Byref step_var As dd )
	End Operator
	 
	Operator dd.step ( Byref step_var As dd )
		c_dd_add_dd_d(This, step_var, This) 'this = this + step_var '    
	End Operator 
	 
	Operator dd.next ( Byref end_cond As dd, Byref step_var As dd ) As Integer
		Dim As Long tst
		c_dd_comp_dd_d( step_var, 0, @tst)
		If tst < 0 Then
			c_dd_comp( This, end_cond, @tst)
			Return tst+1 ' >= 0
		Else
			c_dd_comp( This, end_cond, @tst)
			Return tst-1' <= 0
		End If
	End Operator

	'++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	Operator + ( Byref lhs As dd, Byref rhs As dd ) As dd
		Dim As dd result
		c_dd_add( lhs, rhs, result )
		Operator = result
	End Operator

	Operator + ( Byref lhs As dd, Byval rhs As Long ) As dd
		Dim As dd result
		c_dd_add_dd_d( lhs, Cdbl(rhs), result)
		Operator = result
	End Operator
	
	Operator + ( Byref lhs As dd, Byval rhs As Ulong ) As dd
		Dim As dd result
		c_dd_add_dd_d( lhs, Cdbl(rhs), result)
		Operator = result
	End Operator
	
	Operator + ( Byref lhs As dd, Byval rhs As Longint ) As dd
		Dim As dd result
		c_dd_read( Str(rhs), result )
		c_dd_add( lhs, result, result)
		Operator = result
	End Operator

	Operator + ( Byref lhs As dd, Byval rhs As Ulongint ) As dd
		Dim As dd result
		c_dd_read( Str(rhs), result )
		c_dd_add( lhs, result, result)
		Operator = result
	End Operator

	Operator + ( Byref lhs As dd, Byval rhs As Integer ) As dd
		Dim As dd result
		c_dd_read( Str(rhs), result )
		c_dd_add( lhs, result, result)
		Operator = result
	End Operator

	Operator + ( Byref lhs As dd, Byval rhs As Uinteger ) As dd
		Dim As dd result
		c_dd_read( Str(rhs), result )
		c_dd_add( lhs, result, result)
		Operator = result
	End Operator
	
	Operator + ( Byref lhs As dd, Byval rhs As Double ) As dd
		Dim As dd result
		c_dd_add_dd_d( lhs, rhs, result)
		Operator = result
	End Operator

'''
	Operator + ( Byval lhs As Long, Byval rhs As dd) As dd
		Dim As dd result
		c_dd_add_d_dd( Cdbl(lhs), rhs, result)
		Operator = result
	End Operator
	
	Operator + ( Byval lhs As Ulong, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_add_d_dd( Cdbl(lhs), rhs, result)
		Operator = result
	End Operator
	
	Operator + ( Byval lhs As Longint, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_read( Str(lhs), result )
		c_dd_add( result, rhs, result)
		Operator = result
	End Operator

	Operator + ( Byval lhs As Ulongint, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_read( Str(lhs), result )
		c_dd_add( result, rhs, result)
		Operator = result
	End Operator

	Operator + ( Byref lhs As Integer, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_read( Str(lhs), result )
		c_dd_add( result, rhs, result)
		Operator = result
	End Operator

	Operator + ( Byval lhs As Uinteger, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_read( Str(lhs), result )
		c_dd_add( result, rhs, result)
		Operator = result
	End Operator
	
	Operator + ( Byval lhs As Double, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_add_d_dd( lhs, rhs, result)
		Operator = result
	End Operator
	
	'----------------------------------------------------------------
	Operator - ( Byref rhs As dd ) As dd
		Dim As dd result
		c_dd_neg( rhs, result)
		Operator = result
	End Operator

	Operator - ( Byref lhs As dd, Byref rhs As dd ) As dd
		Dim As dd result
		c_dd_sub( lhs, rhs, result )
		Operator = result
	End Operator

	Operator - ( Byref lhs As dd, Byval rhs As Long ) As dd
		Dim As dd result
		c_dd_sub_dd_d( lhs, Cdbl(rhs), result)
		Operator = result
	End Operator
	
	Operator - ( Byref lhs As dd, Byval rhs As Ulong ) As dd
		Dim As dd result
		c_dd_sub_dd_d( lhs, Cdbl(rhs), result)
		Operator = result
	End Operator
	
	Operator - ( Byref lhs As dd, Byval rhs As Longint ) As dd
		Dim As dd result
		c_dd_read( Str(rhs), result )
		c_dd_sub( lhs, result, result)
		Operator = result
	End Operator

	Operator - ( Byref lhs As dd, Byval rhs As Ulongint ) As dd
		Dim As dd result
		c_dd_read( Str(rhs), result )
		c_dd_sub( lhs, result, result)
		Operator = result
	End Operator

	Operator - ( Byref lhs As dd, Byval rhs As Integer ) As dd
		Dim As dd result
		c_dd_read( Str(rhs), result )
		c_dd_sub( lhs, result, result)
		Operator = result
	End Operator

	Operator - ( Byref lhs As dd, Byval rhs As Uinteger ) As dd
		Dim As dd result
		c_dd_read( Str(rhs), result )
		c_dd_sub( lhs, result, result)
		Operator = result
	End Operator
	
	Operator - ( Byref lhs As dd, Byval rhs As Double ) As dd
		Dim As dd result
		c_dd_sub_dd_d( lhs, rhs, result)
		Operator = result
	End Operator

'''
	Operator - ( Byval lhs As Long, Byval rhs As dd) As dd
		Dim As dd result
		c_dd_sub_d_dd( Cdbl(lhs), rhs, result)
		Operator = result
	End Operator
	
	Operator - ( Byval lhs As Ulong, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_sub_d_dd( Cdbl(lhs), rhs, result)
		Operator = result
	End Operator
	
	Operator - ( Byval lhs As Longint, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_read( Str(lhs), result )
		c_dd_sub( result, rhs, result)
		Operator = result
	End Operator

	Operator - ( Byval lhs As Ulongint, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_read( Str(lhs), result )
		c_dd_sub( result, rhs, result)
		Operator = result
	End Operator

	Operator - ( Byref lhs As Integer, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_read( Str(lhs), result )
		c_dd_sub( result, rhs, result)
		Operator = result
	End Operator

	Operator - ( Byval lhs As Uinteger, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_read( Str(lhs), result )
		c_dd_sub( result, rhs, result)
		Operator = result
	End Operator
	
	Operator - ( Byval lhs As Double, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_sub_d_dd( lhs, rhs, result)
		Operator = result
	End Operator
	
	'****************************************************************
	Operator * ( Byref lhs As dd, Byref rhs As dd ) As dd
		Dim As dd result
		c_dd_mul( lhs, rhs, result )
		Operator = result
	End Operator

	Operator * ( Byref lhs As dd, Byval rhs As Long ) As dd
		Dim As dd result
		c_dd_mul_dd_d( lhs, Cdbl(rhs), result)
		Operator = result
	End Operator
	
	Operator * ( Byref lhs As dd, Byval rhs As Ulong ) As dd
		Dim As dd result
		c_dd_mul_dd_d( lhs, Cdbl(rhs), result)
		Operator = result
	End Operator
	
	Operator * ( Byref lhs As dd, Byval rhs As Longint ) As dd
		Dim As dd result
		c_dd_read( Str(rhs), result )
		c_dd_mul( lhs, result, result)
		Operator = result
	End Operator

	Operator * ( Byref lhs As dd, Byval rhs As Ulongint ) As dd
		Dim As dd result
		c_dd_read( Str(rhs), result )
		c_dd_mul( lhs, result, result)
		Operator = result
	End Operator

	Operator * ( Byref lhs As dd, Byval rhs As Integer ) As dd
		Dim As dd result
		c_dd_read( Str(rhs), result )
		c_dd_mul( lhs, result, result)
		Operator = result
	End Operator

	Operator * ( Byref lhs As dd, Byval rhs As Uinteger ) As dd
		Dim As dd result
		c_dd_read( Str(rhs), result )
		c_dd_mul( lhs, result, result)
		Operator = result
	End Operator
	
	Operator * ( Byref lhs As dd, Byval rhs As Double ) As dd
		Dim As dd result
		c_dd_mul_dd_d( lhs, rhs, result)
		Operator = result
	End Operator

'''
	Operator * ( Byval lhs As Long, Byval rhs As dd) As dd
		Dim As dd result
		c_dd_mul_d_dd( Cdbl(lhs), rhs, result)
		Operator = result
	End Operator
	
	Operator * ( Byval lhs As Ulong, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_mul_d_dd( Cdbl(lhs), rhs, result)
		Operator = result
	End Operator
	
	Operator * ( Byval lhs As Longint, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_read( Str(lhs), result )
		c_dd_mul( result, rhs, result)
		Operator = result
	End Operator

	Operator * ( Byval lhs As Ulongint, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_read( Str(lhs), result )
		c_dd_mul( result, rhs, result)
		Operator = result
	End Operator

	Operator * ( Byref lhs As Integer, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_read( Str(lhs), result )
		c_dd_mul( result, rhs, result)
		Operator = result
	End Operator

	Operator * ( Byval lhs As Uinteger, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_read( Str(lhs), result )
		c_dd_mul( result, rhs, result)
		Operator = result
	End Operator
	
	Operator * ( Byval lhs As Double, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_mul_d_dd( lhs, rhs, result)
		Operator = result
	End Operator
	
	'////////////////////////////////////////////////////////////////
	Operator / ( Byref lhs As dd, Byref rhs As dd ) As dd
		Dim As dd result
		c_dd_div( lhs, rhs, result )
		Operator = result
	End Operator

	Operator / ( Byref lhs As dd, Byval rhs As Long ) As dd
		Dim As dd result
		c_dd_div_dd_d( lhs, Cdbl(rhs), result)
		Operator = result
	End Operator
	
	Operator / ( Byref lhs As dd, Byval rhs As Ulong ) As dd
		Dim As dd result
		c_dd_div_dd_d( lhs, Cdbl(rhs), result)
		Operator = result
	End Operator
	
	Operator / ( Byref lhs As dd, Byval rhs As Longint ) As dd
		Dim As dd result
		c_dd_read( Str(rhs), result )
		c_dd_div( lhs, result, result)
		Operator = result
	End Operator

	Operator / ( Byref lhs As dd, Byval rhs As Ulongint ) As dd
		Dim As dd result
		c_dd_read( Str(rhs), result )
		c_dd_div( lhs, result, result)
		Operator = result
	End Operator

	Operator / ( Byref lhs As dd, Byval rhs As Integer ) As dd
		Dim As dd result
		c_dd_read( Str(rhs), result )
		c_dd_div( lhs, result, result)
		Operator = result
	End Operator

	Operator / ( Byref lhs As dd, Byval rhs As Uinteger ) As dd
		Dim As dd result
		c_dd_read( Str(rhs), result )
		c_dd_div( lhs, result, result)
		Operator = result
	End Operator
	
	Operator / ( Byref lhs As dd, Byval rhs As Double ) As dd
		Dim As dd result
		c_dd_div_dd_d( lhs, rhs, result)
		Operator = result
	End Operator

'''
	Operator / ( Byval lhs As Long, Byval rhs As dd) As dd
		Dim As dd result
		c_dd_div_d_dd( Cdbl(lhs), rhs, result)
		Operator = result
	End Operator
	
	Operator / ( Byval lhs As Ulong, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_div_d_dd( Cdbl(lhs), rhs, result)
		Operator = result
	End Operator
	
	Operator / ( Byval lhs As Longint, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_read( Str(lhs), result )
		c_dd_div( result, rhs, result)
		Operator = result
	End Operator

	Operator / ( Byval lhs As Ulongint, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_read( Str(lhs), result )
		c_dd_div( result, rhs, result)
		Operator = result
	End Operator

	Operator / ( Byref lhs As Integer, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_read( Str(lhs), result )
		c_dd_div( result, rhs, result)
		Operator = result
	End Operator

	Operator / ( Byval lhs As Uinteger, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_read( Str(lhs), result )
		c_dd_div( result, rhs, result)
		Operator = result
	End Operator
	
	Operator / ( Byval lhs As Double, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_div_d_dd( lhs, rhs, result)
		Operator = result
	End Operator

	'^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
	Operator ^ ( Byref lhs As dd, Byval rhs As Integer ) As dd
		Dim As dd result
		c_dd_npwr( lhs, rhs, result )
		Operator = result
	End Operator

	Operator ^ ( Byref lhs As Integer, Byval rhs As dd ) As dd
		Dim As dd result=lhs
		c_dd_log( result, result )
		c_dd_mul( result, rhs, result)
		c_dd_exp( result, result )
		Operator = result
	End Operator

	Operator ^ ( Byref lhs As dd, Byval rhs As dd ) As dd
		Dim As dd result
		c_dd_log( lhs, result )
		c_dd_mul( result, rhs, result)
		c_dd_exp( result, result )
		Operator = result
	End Operator

	'seld add
	Operator dd.+= (Byref rhs As dd)
		c_dd_add(This, rhs, This)
	End Operator
	
	Operator dd.+= (Byval rhs As Long)
		c_dd_add_dd_d(This, Cdbl(rhs), This)
	End Operator
	
	Operator dd.+= (Byval rhs As Double)
		c_dd_add_dd_d(This, rhs, This)
	End Operator
	
	Operator dd.+= (Byval rhs As Longint)
		Dim As dd temp
		c_dd_read( Str(rhs), temp )
		c_dd_add(This, temp, This)
	End Operator
	
	Operator dd.+= (Byval rhs As Integer)
		Dim As dd temp
		c_dd_read( Str(rhs), temp )
		c_dd_add(This, temp, This)
	End Operator
	
	Operator dd.+= (Byref rhs As String)
		Dim As dd temp
		c_dd_read(rhs, temp )
		c_dd_add(This, temp, This)
	End Operator

	'self sub
	Operator dd.-= (Byref rhs As dd)
		c_dd_sub(This, rhs, This)
	End Operator
	
	Operator dd.-= (Byval rhs As Long)
		c_dd_sub_dd_d(This, Cdbl(rhs), This)
	End Operator
	
	Operator dd.-= (Byval rhs As Double)
		c_dd_sub_dd_d(This, rhs, This)
	End Operator
	
	Operator dd.-= (Byval rhs As Longint)
		Dim As dd temp
		c_dd_read( Str(rhs), temp )
		c_dd_sub(This, temp, This)
	End Operator
	
	Operator dd.-= (Byval rhs As Integer)
		Dim As dd temp
		c_dd_read( Str(rhs), temp )
		c_dd_sub(This, temp, This)
	End Operator
	
	Operator dd.-= (Byref rhs As String)
		Dim As dd temp
		c_dd_read(rhs, temp )
		c_dd_sub(This, temp, This)
	End Operator
	
	'self mul
	Operator dd.*= (Byref rhs As dd)
		c_dd_mul(This, rhs, This)
	End Operator
	
	Operator dd.*= (Byval rhs As Long)
		c_dd_mul_dd_d(This, Cdbl(rhs), This)
	End Operator
	
	Operator dd.*= (Byval rhs As Double)
		c_dd_mul_dd_d(This, rhs, This)
	End Operator
	
	Operator dd.*= (Byval rhs As Longint)
		Dim As dd temp
		c_dd_read( Str(rhs), temp )
		c_dd_mul(This, temp, This)
	End Operator
	
	Operator dd.*= (Byval rhs As Integer)
		Dim As dd temp
		c_dd_read( Str(rhs), temp )
		c_dd_mul(This, temp, This)
	End Operator
	
	Operator dd.*= (Byref rhs As String)
		Dim As dd temp
		c_dd_read(rhs, temp )
		c_dd_mul(This, temp, This)
	End Operator
	
	'self div
	Operator dd./= (Byref rhs As dd)
		c_dd_div(This, rhs, This)
	End Operator
	
	Operator dd./= (Byval rhs As Long)
		c_dd_div_dd_d(This, Cdbl(rhs), This)
	End Operator
	
	Operator dd./= (Byval rhs As Double)
		c_dd_div_dd_d(This, rhs, This)
	End Operator
	
	Operator dd./= (Byval rhs As Longint)
		Dim As dd temp
		c_dd_read( Str(rhs), temp )
		c_dd_div(This, temp, This)
	End Operator
	
	Operator dd./= (Byval rhs As Integer)
		Dim As dd temp
		c_dd_read( Str(rhs), temp )
		c_dd_div(This, temp, This)
	End Operator
	
	Operator dd./= (Byref rhs As String)
		Dim As dd temp
		c_dd_read(rhs, temp )
		c_dd_div(This, temp, This)
	End Operator
'''
	Operator = ( Byref lhs As dd, Byref rhs As dd ) As Long
		Dim As Long t
		c_dd_comp(lhs, rhs, @t)
		Operator = (t = 0)
	End Operator

	Operator = ( Byref lhs As dd, Byval rhs As Double) As Long
		Dim As Long t
		c_dd_comp_dd_d(lhs, rhs, @t)
		Operator = (t = 0)
	End Operator

	Operator = ( Byval lhs As Double, Byref rhs As dd) As Long
		Dim As Long t
		c_dd_comp_d_dd(lhs, rhs, @t)
		Operator = (t = 0)
	End Operator

	Operator < ( Byref lhs As dd, Byref rhs As dd ) As Long
		Dim As Long t
		c_dd_comp(lhs, rhs, @t)
		Operator = (t < 0)
	End Operator

	Operator < ( Byref lhs As dd, Byval rhs As Double) As Long
		Dim As Long t
		c_dd_comp_dd_d(lhs, rhs, @t)
		Operator = (t < 0)
	End Operator

	Operator < ( Byval lhs As Double, Byref rhs As dd) As Long
		Dim As Long t
		c_dd_comp_d_dd(lhs, rhs, @t)
		Operator = (t < 0)
	End Operator

	Operator <= ( Byref lhs As dd, Byref rhs As dd ) As Long
		Dim As Long t
		c_dd_comp(lhs, rhs, @t)
		Operator = (t <= 0)
	End Operator

	Operator <= ( Byref lhs As dd, Byval rhs As Double) As Long
		Dim As Long t
		c_dd_comp_dd_d(lhs, rhs, @t)
		Operator = (t <= 0)
	End Operator

	Operator <= ( Byval lhs As Double, Byref rhs As dd) As Long
		Dim As Long t
		c_dd_comp_d_dd(lhs, rhs, @t)
		Operator = (t <= 0)
	End Operator

	Operator >= ( Byref lhs As dd, Byref rhs As dd ) As Long
		Dim As Long t
		c_dd_comp(lhs, rhs, @t)
		Operator = (t >= 0)
	End Operator

	Operator >= ( Byref lhs As dd, Byval rhs As Double) As Long
		Dim As Long t
		c_dd_comp_dd_d(lhs, rhs, @t)
		Operator = (t >= 0)
	End Operator

	Operator >= ( Byval lhs As Double, Byref rhs As dd) As Long
		Dim As Long t
		c_dd_comp_d_dd(lhs, rhs, @t)
		Operator = (t >= 0)
	End Operator

	Operator > ( Byref lhs As dd, Byref rhs As dd ) As Long
		Dim As Long t
		c_dd_comp(lhs, rhs, @t)
		Operator = (t > 0)
	End Operator

	Operator > ( Byref lhs As dd, Byval rhs As Double) As Long
		Dim As Long t
		c_dd_comp_dd_d(lhs, rhs, @t)
		Operator = (t > 0)
	End Operator

	Operator > ( Byval lhs As Double, Byref rhs As dd) As Long
		Dim As Long t
		c_dd_comp_d_dd(lhs, rhs, @t)
		Operator = (t > 0)
	End Operator
	

	Function dd_abs(Byref x As dd) As dd
		Dim As dd result
		c_dd_abs( x, result)
		Function = result
	End Function

	Function dd_acos(Byref x As dd) As dd
		Dim As dd result
		c_dd_acos( x, result)
		Function = result
	End Function
	
	Function dd_acosh(Byref x As dd) As dd
		Dim As dd result
		c_dd_acosh( x, result)
		Function = result
	End Function

	Function dd_aint(Byref x As dd) As dd
		Dim As dd result
		c_dd_aint( x, result)
		Function = result
	End Function
		
	Function dd_asin(Byref x As dd) As dd
		Dim As dd result
		c_dd_asin( x, result)
		Function = result
	End Function
	
	Function dd_asinh(Byref x As dd) As dd
		Dim As dd result
		c_dd_asinh( x, result)
		Function = result
	End Function
	
	Function dd_atan(Byref x As dd) As dd
		Dim As dd result
		c_dd_atan( x, result)
		Function = result
	End Function
	
	Function dd_atan2(Byref x As dd, Byref y As dd) As dd
		Dim As dd result
		c_dd_atan2( x, y, result)
		Function = result
	End Function
	
	Function dd_atanh(Byref x As dd) As dd
		Dim As dd result
		c_dd_atanh( x, result)
		Function = result
	End Function
	
	Function dd_ceil(Byref x As dd) As dd
		Dim As dd result
		c_dd_ceil( x, result)
		Function = result
	End Function
	
	Function dd_cos(Byref x As dd) As dd
		Dim As dd result
		c_dd_cos( x, result)
		Function = result
	End Function
	
	Function dd_cosh(Byref x As dd) As dd
		Dim As dd result
		c_dd_cosh( x, result)
		Function = result
	End Function
	
	Function dd_exp(Byref x As dd) As dd
		Dim As dd result
		c_dd_exp( x, result)
		Function = result
	End Function
	
	Function dd_exp10(Byref x As dd) As dd
		Dim As dd result
		c_dd_exp10( x, result)
		Function = result
	End Function
	
	Function dd_floor(Byref x As dd) As dd
		Dim As dd result
		c_dd_floor( x, result)
		Function = result
	End Function
	
	Function dd_log(Byref x As dd) As dd
		Dim As dd result
		c_dd_log( x, result)
		Function = result
	End Function
	
	Function dd_log10(Byref x As dd) As dd
		Dim As dd result
		c_dd_log10( x, result)
		Function = result
	End Function
	
	Function dd_nint(Byref x As dd) As dd
		Dim As dd result
		c_dd_nint( x, result)
		Function = result
	End Function
	
	Function dd_nroot(Byref x As dd, Byval n As Long) As dd
		Dim As dd result
		c_dd_nroot( x, n, result)
		Function = result
	End Function
	
	Function dd_rand() As dd
		Dim As dd result
		c_dd_rand(result)
		Function = result
	End Function

	Function dd_sgn(Byref x As dd) As Long
		Function = Sgn(x.ddm1)
	End Function
	
	Function dd_sin(Byref x As dd) As dd
		Dim As dd result
		c_dd_sin( x, result)
		Function = result
	End Function
	
	Function dd_sinh(Byref x As dd) As dd
		Dim As dd result
		c_dd_sinh( x, result)
		Function = result
	End Function
	
	Function dd_sqr(Byref x As dd) As dd
		Dim As dd result
		c_dd_sqr( x, result)
		Function = result
	End Function
	
	Function dd_sqrt(Byref x As dd) As dd
		Dim As dd result
		c_dd_sqrt( x, result)
		Function = result
	End Function
	
	Function dd_tan(Byref x As dd) As dd
		Dim As dd result
		c_dd_tan( x, result)
		Function = result
	End Function
	
	Function dd_tanh(Byref x As dd) As dd
		Dim As dd result
		c_dd_tanh( x, result)
		Function = result
	End Function
srvaldez
Posts: 3373
Joined: Sep 25, 2005 21:54

Re: QD library

Post by srvaldez »

qd.bi

Code: Select all

#Ifdef __fb_win32__
	#Ifdef __fb_64bit__
		#Inclib "qd64"
	#Else
		#Inclib "qd32"
	#Endif
#Endif

#Ifndef dd
	Type dd
		As Double ddm1, ddm2
	End Type
#Endif

#define QD_H_

Type qd
    As Double qdm1, qdm2, qdm3, qdm4
    
    Declare Constructor()
    Declare Constructor( Byref rhs As qd)
    Declare Constructor(Byval a As Double, Byval b As Double, Byval c As Double, Byval d As Double)
    Declare Constructor ( Byval rhs As Long )    
    Declare Constructor ( Byval rhs As Longint )
    Declare Constructor ( Byval rhs As Integer )
    Declare Constructor ( Byval rhs As Double )
    Declare Constructor ( Byref rhs As String )

	Declare Operator Let ( Byref rhs As qd )
    Declare Operator Let ( Byval rhs As Long )
    Declare Operator Let ( Byval rhs As Longint )
    Declare Operator Let ( Byval rhs As Integer )
    Declare Operator Let ( Byval rhs As Double )
    Declare Operator Let ( Byref rhs As String )
    
    Declare Operator Cast ( ) As String
    Declare Operator Cast ( ) As Long
    Declare Operator Cast ( ) As Double
    Declare Operator Cast ( ) As Single

    ' For Next Implicit step = +1
    Declare Operator For ( )
    Declare Operator Step( )
    Declare Operator Next( Byref end_cond As qd ) As Integer
    ' For Next Exlicit step
    Declare Operator For ( Byref stp As qd )
    Declare Operator Step( Byref stp As qd )
    Declare Operator Next( Byref end_cond As qd, Byref step_var As qd ) As Integer
    ' self
    Declare Operator += (Byref rhs As qd)
    Declare Operator += (Byref rhs As dd)
    Declare Operator += (Byval rhs As Long)
    Declare Operator += (Byval rhs As Double)
    Declare Operator += (Byval rhs As Longint)
    Declare Operator += (Byval rhs As Integer)
    Declare Operator += (Byref rhs As String)
    Declare Operator -= (Byref rhs As qd)
	Declare Operator -= (Byref rhs As dd)
    Declare Operator -= (Byval rhs As Double)
    Declare Operator -= (Byval rhs As Longint)
    Declare Operator -= (Byval rhs As Integer)
    Declare Operator -= (Byval rhs As Long)
    Declare Operator -= (Byref rhs As String)
    Declare Operator *= (Byref rhs As qd)
    Declare Operator *= (Byref rhs As dd)
    Declare Operator *= (Byval rhs As Double)
    Declare Operator *= (Byval rhs As Longint)
    Declare Operator *= (Byval rhs As Integer)
    Declare Operator *= (Byval rhs As Long)
    Declare Operator *= (Byref rhs As String)
    Declare Operator /= (Byref rhs As qd)
    Declare Operator /= (Byref rhs As dd)
    Declare Operator /= (Byval rhs As Double)
    Declare Operator /= (Byval rhs As Longint)
    Declare Operator /= (Byval rhs As Integer)
    Declare Operator /= (Byval rhs As Long)
    Declare Operator /= (Byref rhs As String)
End Type


	Declare Sub c_qd_abs          Cdecl Alias "c_qd_abs"          ( Byref As qd, Byref As qd )
	Declare Sub c_qd_acos         Cdecl Alias "c_qd_acos"         ( Byref As qd, Byref As qd )
	Declare Sub c_qd_acosh        Cdecl Alias "c_qd_acosh"        ( Byref As qd, Byref As qd )
	Declare Sub c_qd_add          Cdecl Alias "c_qd_add"          ( Byref As qd, Byref As qd, Byref As qd )
	Declare Sub c_qd_add_d_qd     Cdecl Alias "c_qd_add_d_qd"     ( Byval As Double, Byref As qd, Byref As qd )
	Declare Sub c_qd_add_dd_qd    Cdecl Alias "c_qd_add_dd_qd"    ( Byref As dd, Byref As qd, Byref As qd )
	Declare Sub c_qd_add_qd_d     Cdecl Alias "c_qd_add_qd_d"     ( Byref As qd, Byval As Double, Byref As qd )
	Declare Sub c_qd_add_qd_dd    Cdecl Alias "c_qd_add_qd_dd"    ( Byref As qd, Byref As dd, Byref As qd )
	Declare Sub c_qd_aint         Cdecl Alias "c_qd_aint"         ( Byref As qd, Byref As qd )
	Declare Sub c_qd_asin         Cdecl Alias "c_qd_asin"         ( Byref As qd, Byref As qd )
	Declare Sub c_qd_asinh        Cdecl Alias "c_qd_asinh"        ( Byref As qd, Byref As qd )
	Declare Sub c_qd_atan         Cdecl Alias "c_qd_atan"         ( Byref As qd, Byref As qd )
	Declare Sub c_qd_atan2        Cdecl Alias "c_qd_atan2"        ( Byref As qd, Byref As qd, Byref As qd )
	Declare Sub c_qd_atanh        Cdecl Alias "c_qd_atanh"        ( Byref As qd, Byref As qd )
	Declare Sub c_qd_ceil         Cdecl Alias "c_qd_ceil"         ( Byref As qd, Byref As qd )
	Declare Sub c_qd_comp         Cdecl Alias "c_qd_comp"         ( Byref As qd, Byref As qd, Byval As Long Ptr )
	Declare Sub c_qd_comp_d_qd    Cdecl Alias "c_qd_comp_d_qd"    ( Byval As Double, Byref As qd, Byval As Long Ptr  )
	Declare Sub c_qd_comp_qd_d    Cdecl Alias "c_qd_comp_qd_d"    ( Byref As qd, Byval As Double, Byval As Long Ptr  )
	Declare Sub c_qd_copy         Cdecl Alias "c_qd_copy"         ( Byref As qd, Byref As qd )
	Declare Sub c_qd_copy_d       Cdecl Alias "c_qd_copy_d"       ( Byval As Double, Byref As qd )
	Declare Sub c_qd_copy_dd      Cdecl Alias "c_qd_copy_dd"      ( Byref As dd, Byref As qd )
	Declare Sub c_qd_cos          Cdecl Alias "c_qd_cos"          ( Byref As qd, Byref As qd )
	Declare Sub c_qd_cosh         Cdecl Alias "c_qd_cosh"         ( Byref As qd, Byref As qd )
	Declare Sub c_qd_div          Cdecl Alias "c_qd_div"          ( Byref As qd, Byref As qd, Byref As qd )
	Declare Sub c_qd_div_d_qd     Cdecl Alias "c_qd_div_d_qd"     ( Byval As Double, Byref As qd, Byref As qd )
	Declare Sub c_qd_div_dd_qd    Cdecl Alias "c_qd_div_dd_qd"    ( Byref As dd, Byref As qd, Byref As qd )
	Declare Sub c_qd_div_qd_d     Cdecl Alias "c_qd_div_qd_d"     ( Byref As qd, Byval As Double, Byref As qd )
	Declare Sub c_qd_div_qd_dd    Cdecl Alias "c_qd_div_qd_dd"    ( Byref As qd, Byref As dd, Byref As qd )
	Declare Sub c_qd_exp          Cdecl Alias "c_qd_exp"          ( Byref As qd, Byref As qd )
	Declare Sub c_qd_exp10        Cdecl Alias "c_qd_exp10"        ( Byref As qd, Byref As qd )
	Declare Sub c_qd_floor        Cdecl Alias "c_qd_floor"        ( Byref As qd, Byref As qd )
	Declare Sub c_qd_log          Cdecl Alias "c_qd_log"          ( Byref As qd, Byref As qd )
	Declare Sub c_qd_log10        Cdecl Alias "c_qd_log10"        ( Byref As qd, Byref As qd )
	Declare Sub c_qd_mul          Cdecl Alias "c_qd_mul"          ( Byref As qd, Byref As qd, Byref As qd )
	Declare Sub c_qd_mulX         Cdecl Alias "c_qd_mulX"         ( Byref As qd, Byref As qd, Byref As qd )
	Declare Sub c_qd_mul_d_qd     Cdecl Alias "c_qd_mul_d_qd"     ( Byval As Double, Byref As qd, Byref As qd )
	Declare Sub c_qd_mul_dd_qd    Cdecl Alias "c_qd_mul_dd_qd"    ( Byref As dd, Byref As qd, Byref As qd )
	Declare Sub c_qd_mul_qd_d     Cdecl Alias "c_qd_mul_qd_d"     ( Byref As qd, Byval As Double, Byref As qd )
	Declare Sub c_qd_mul_qd_dd    Cdecl Alias "c_qd_mul_qd_dd"    ( Byref As qd, Byref As dd, Byref As qd )
	Declare Sub c_qd_neg          Cdecl Alias "c_qd_neg"          ( Byref As qd, Byref As qd )
	Declare Sub c_qd_nint         Cdecl Alias "c_qd_nint"         ( Byref As qd, Byref As qd )
	Declare Sub c_qd_npwr         Cdecl Alias "c_qd_npwr"         ( Byref As qd, Byval As Integer, Byref As qd )
	Declare Sub c_qd_nroot        Cdecl Alias "c_qd_nroot"        ( Byref As qd, Byval As Integer, Byref As qd )
	Declare Sub c_qd_pi           Cdecl Alias "c_qd_pi"           ( Byref As qd )
	Declare Sub c_qd_rand         Cdecl Alias "c_qd_rand"         ( Byref As qd )
	Declare Sub c_qd_read         Cdecl Alias "c_qd_read"         ( Byval As Zstring Ptr, Byref As qd )
	Declare Sub c_qd_selfadd      Cdecl Alias "c_qd_selfadd"      ( Byref As qd, Byref As qd )
	Declare Sub c_qd_selfadd_d    Cdecl Alias "c_qd_selfadd_d"    ( Byval As Double, Byref As qd )
	Declare Sub c_qd_selfadd_dd   Cdecl Alias "c_qd_selfadd_dd"   ( Byref As dd, Byref As qd )
	Declare Sub c_qd_selfdiv      Cdecl Alias "c_qd_selfdiv"      ( Byref As qd, Byref As qd )
	Declare Sub c_qd_selfdiv_d    Cdecl Alias "c_qd_selfdiv_d"    ( Byval As Double, Byref As qd )
	Declare Sub c_qd_selfdiv_dd   Cdecl Alias "c_qd_selfdiv_dd"   ( Byref As dd, Byref As qd )
	Declare Sub c_qd_selfmul      Cdecl Alias "c_qd_selfmul"      ( Byref As qd, Byref As qd )
	Declare Sub c_qd_selfmul_d    Cdecl Alias "c_qd_selfmul_d"    ( Byval As Double, Byref As qd )
	Declare Sub c_qd_selfmul_dd	  Cdecl Alias "c_qd_selfmul_dd"   ( Byref As dd, Byref As qd )
	Declare Sub c_qd_selfsub      Cdecl Alias "c_qd_selfsub"      ( Byref As qd, Byref As qd )
	Declare Sub c_qd_selfsub_d    Cdecl Alias "c_qd_selfsub_d"    ( Byval As Double, Byref As qd )
	Declare Sub c_qd_selfsub_dd   Cdecl Alias "c_qd_selfsub_dd"   ( Byref As dd, Byref As qd )
	Declare Sub c_qd_sin          Cdecl Alias "c_qd_sin"          ( Byref As qd, Byref As qd )
	Declare Sub c_qd_sincos       Cdecl Alias "c_qd_sincos"       ( Byref As qd, Byref As qd, Byref As qd )
	Declare Sub c_qd_sincosh      Cdecl Alias "c_qd_sincosh"      ( Byref As qd, Byref As qd, Byref As qd )
	Declare Sub c_qd_sinh         Cdecl Alias "c_qd_sinh"         ( Byref As qd, Byref As qd )
	Declare Sub c_qd_sqr          Cdecl Alias "c_qd_sqr"          ( Byref As qd, Byref As qd )
	Declare Sub c_qd_sqrt         Cdecl Alias "c_qd_sqrt"         ( Byref As qd, Byref As qd )
	Declare Sub c_qd_sub          Cdecl Alias "c_qd_sub"          ( Byref As qd, Byref As qd, Byref As qd )
	Declare Sub c_qd_sub_d_qd     Cdecl Alias "c_qd_sub_d_qd"     ( Byval As Double, Byref As qd, Byref As qd )
	Declare Sub c_qd_sub_dd_qd    Cdecl Alias "c_qd_sub_dd_qd"    ( Byref As dd, Byref As qd, Byref As qd )
	Declare Sub c_qd_sub_qd_d     Cdecl Alias "c_qd_sub_qd_d"     ( Byref As qd, Byval As Double, Byref As qd )
	Declare Sub c_qd_sub_qd_dd    Cdecl Alias "c_qd_sub_qd_dd"    ( Byref As qd, Byref As dd, Byref As qd )
	Declare Sub c_qd_swrite       Cdecl Alias "c_qd_swrite"       ( Byref As qd, Byval As Integer, Byval As Zstring Ptr, Byval As Integer )
	Declare Sub c_qd_tan          Cdecl Alias "c_qd_tan"          ( Byref As qd, Byref As qd )
	Declare Sub c_qd_tanh         Cdecl Alias "c_qd_tanh"         ( Byref As qd, Byref As qd )
	Declare Sub c_qd_write        Cdecl Alias "c_qd_write"        ( Byref As qd )
'	Declare Sub c_fpu_fix_start   Cdecl Alias "fpu_fix_start"     ( Byref As integer )
'	Declare Sub c_fpu_fix_end     Cdecl Alias "fpu_fix_end"       ( Byref As integer )

	Dim Shared As qd _qd_2p = qd(6.283185307179586232e+00,_
						2.449293598294706414e-16,_
						-5.989539619436679332e-33,_
						2.224908441726730563e-49)
											
	Dim Shared As qd _qd_pi = qd(3.141592653589793116e+00,_
						1.224646799147353207e-16,_
						-2.994769809718339666e-33,_
						1.112454220863365282e-49)
						
	Dim Shared As qd _qd_pi2 = qd (1.570796326794896558e+00,_
						6.123233995736766036e-17,_
						-1.497384904859169833e-33,_
						5.562271104316826408e-50)
						
	Dim Shared As qd _qd_pi4 = qd (7.853981633974482790e-01,_
						3.061616997868383018e-17,_
						-7.486924524295849165e-34,_
						2.781135552158413204e-50)
						
	Dim Shared As qd _qd_3pi4 = qd (2.356194490192344837e+00,_
						9.1848509936051484375e-17,_
						3.9168984647504003225e-33,_
						-2.5867981632704860386e-49)
						
	Dim Shared As qd _qd_e = qd (2.718281828459045091e+00,_
						1.445646891729250158e-16,_
						-2.127717108038176765e-33,_
						1.515630159841218954e-49)
						
	Dim Shared As qd _qd_log2 = qd (6.931471805599452862e-01,_
						2.319046813846299558e-17,_
						5.707708438416212066e-34,_
						-3.582432210601811423e-50)
										   
	Dim Shared As qd _qd_log10 = qd (2.302585092994045901e+00,_
						-2.170756223382249351e-16,_
						-9.984262454465776570e-33,_
						-4.023357454450206379e-49)

	Const _qd_eps As Double = 1.21543267145725e-63 ' = 2^-209
	Const _qd_min_normalized As Double = 1.6259745436952323e-260 ' = 2^(-1022 + 3*53)
	Dim Shared As qd _qd_max = qd (_
		1.79769313486231570815e+308, 9.97920154767359795037e+291,_ 
		5.53956966280111259858e+275, 3.07507889307840487279e+259)
	Dim Shared As qd _qd_safe_max = qd (_
		1.7976931080746007281e+308,  9.97920154767359795037e+291,_ 
		5.53956966280111259858e+275, 3.07507889307840487279e+259)

	Const _qd_ndigits As Long = 62

	Constructor qd()
		this.qdm1=0
		this.qdm2=0
		this.qdm3=0
		this.qdm4=0
	End Constructor

	Constructor qd(Byref rhs As qd)
		c_qd_copy( rhs, This )
	End Constructor
	
	Constructor qd(Byval a As Double, Byval b As Double, Byval c As Double, Byval d As Double)
		this.qdm1=a
		this.qdm2=b
		this.qdm3=c
		this.qdm4=d
	End Constructor

	Constructor qd( Byval rhs As Long )
		this.qdm1=rhs
		this.qdm2=0
		this.qdm3=0
		this.qdm4=0
	End Constructor

	Constructor qd( Byval rhs As Longint )
		c_qd_read( Str(rhs), This )
	End Constructor

	Constructor qd( Byval rhs As Integer )
		c_qd_read( Str(rhs), This )
	End Constructor

	Constructor qd( Byval rhs As Double )
		this.qdm1=rhs
		this.qdm2=0
		this.qdm3=0
		this.qdm4=0
	End Constructor

	Constructor qd( Byref rhs As String )
		c_qd_read( rhs, This )
	End Constructor

	Operator qd.let(Byref rhs As qd)
		c_qd_copy( rhs, This )
	End Operator
	
	Operator qd.let( Byval rhs As Long )
		this.qdm1=rhs
		this.qdm2=0
		this.qdm3=0
		this.qdm4=0
	End Operator

	Operator qd.let( Byval rhs As Longint )
		c_qd_read( Str(rhs), This )
	End Operator

	Operator qd.let( Byval rhs As Integer )
		c_qd_read( Str(rhs), This )
	End Operator

	Operator qd.let( Byval rhs As Double )
		this.qdm1=rhs
		this.qdm2=0
		this.qdm3=0
		this.qdm4=0
	End Operator

	Operator qd.let( Byref rhs As String )
		c_qd_read( rhs, This )
	End Operator

	Operator qd.cast ( ) As String
		Dim As String sp=" "
		Dim As Zstring Ptr rstring=Allocate(127)
		c_qd_swrite(This, 62, rstring, 120)
		If (this.qdm1)<0 Then sp = ""
		Operator = sp + Ltrim(*rstring)
		Deallocate(rstring)
	End Operator

	Operator qd.cast ( ) As Long
		Operator = Clng(this.qdm1)
	End Operator

	Operator qd.cast ( ) As Double
		Operator = this.qdm1
	End Operator

	Operator qd.cast ( ) As Single
		Operator = Csng(this.qdm1)
	End Operator

	'============================================================================
	'' For Next for qd type
	''
	'' implicit step versions
	'' 
	'' In this example, we interpret implicit step
	'' to mean 1
	Operator qd.for ( )
	End Operator
	 
	Operator qd.step ( )
			c_qd_add_qd_d(This, 1, This) 'this = this+1 '
	End Operator 
	 
	Operator qd.next ( Byref end_cond As qd ) As Integer
		Dim As Long tst
		c_qd_comp( This, end_cond, @tst)
		Return tst-1
	End Operator
	 
	 
	'' explicit step versions
	'' 
	Operator qd.for ( Byref step_var As qd )
	End Operator
	 
	Operator qd.step ( Byref step_var As qd )
		c_qd_add_qd_d(This, step_var, This) 'this = this + step_var '    
	End Operator 
	 
	Operator qd.next ( Byref end_cond As qd, Byref step_var As qd ) As Integer
		Dim As Long tst
		c_qd_comp_qd_d( step_var, 0, @tst)
		If tst < 0 Then
			c_qd_comp( This, end_cond, @tst)
			Return tst+1 ' >= 0
		Else
			c_qd_comp( This, end_cond, @tst)
			Return tst-1' <= 0
		End If
	End Operator
	
	'++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	Operator + ( Byref lhs As qd, Byref rhs As qd ) As qd
		Dim As qd result
		c_qd_add( lhs, rhs, result )
		Operator = result
	End Operator
	
	Operator + ( Byref lhs As qd, Byref rhs As dd ) As qd
		Dim As qd result
		c_qd_add_qd_dd( lhs, rhs, result )
		Operator = result
	End Operator

	Operator + ( Byref lhs As dd, Byref rhs As qd ) As qd
		Dim As qd result
		c_qd_add_dd_qd( lhs, rhs, result )
		Operator = result
	End Operator
	
	Operator + ( Byref lhs As qd, Byval rhs As Long ) As qd
		Dim As qd result
		c_qd_add_qd_d( lhs, Cdbl(rhs), result)
		Operator = result
	End Operator
	
	Operator + ( Byref lhs As qd, Byval rhs As Ulong ) As qd
		Dim As qd result
		c_qd_add_qd_d( lhs, Cdbl(rhs), result)
		Operator = result
	End Operator
	
	Operator + ( Byref lhs As qd, Byval rhs As Longint ) As qd
		Dim As qd result
		c_qd_read( Str(rhs), result )
		c_qd_add( lhs, result, result)
		Operator = result
	End Operator

	Operator + ( Byref lhs As qd, Byval rhs As Ulongint ) As qd
		Dim As qd result
		c_qd_read( Str(rhs), result )
		c_qd_add( lhs, result, result)
		Operator = result
	End Operator

	Operator + ( Byref lhs As qd, Byval rhs As Integer ) As qd
		Dim As qd result
		c_qd_read( Str(rhs), result )
		c_qd_add( lhs, result, result)
		Operator = result
	End Operator

	Operator + ( Byref lhs As qd, Byval rhs As Uinteger ) As qd
		Dim As qd result
		c_qd_read( Str(rhs), result )
		c_qd_add( lhs, result, result)
		Operator = result
	End Operator
	
	Operator + ( Byref lhs As qd, Byval rhs As Double ) As qd
		Dim As qd result
		c_qd_add_qd_d( lhs, rhs, result)
		Operator = result
	End Operator

'''
	Operator + ( Byval lhs As Long, Byval rhs As qd) As qd
		Dim As qd result
		c_qd_add_d_qd( Cdbl(lhs), rhs, result)
		Operator = result
	End Operator
	
	Operator + ( Byval lhs As Ulong, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_add_d_qd( Cdbl(lhs), rhs, result)
		Operator = result
	End Operator
	
	Operator + ( Byval lhs As Longint, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_read( Str(lhs), result )
		c_qd_add( result, rhs, result)
		Operator = result
	End Operator

	Operator + ( Byval lhs As Ulongint, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_read( Str(lhs), result )
		c_qd_add( result, rhs, result)
		Operator = result
	End Operator

	Operator + ( Byval lhs As Integer, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_read( Str(lhs), result )
		c_qd_add( result, rhs, result)
		Operator = result
	End Operator

	Operator + ( Byval lhs As Uinteger, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_read( Str(lhs), result )
		c_qd_add( result, rhs, result)
		Operator = result
	End Operator
	
	Operator + ( Byval lhs As Double, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_add_d_qd( lhs, rhs, result)
		Operator = result
	End Operator
	
	'----------------------------------------------------------------
	Operator - ( Byref rhs As qd ) As qd
		Dim As qd result
		c_qd_neg( rhs, result)
		Operator = result
	End Operator
	
	Operator - ( Byref lhs As qd, Byref rhs As qd ) As qd
		Dim As qd result
		c_qd_sub( lhs, rhs, result )
		Operator = result
	End Operator
	
	Operator - ( Byref lhs As qd, Byref rhs As dd ) As qd
		Dim As qd result
		c_qd_sub_qd_dd( lhs, rhs, result )
		Operator = result
	End Operator

	Operator - ( Byref lhs As dd, Byref rhs As qd ) As qd
		Dim As qd result
		c_qd_sub_dd_qd( lhs, rhs, result )
		Operator = result
	End Operator
	
	Operator - ( Byref lhs As qd, Byval rhs As Long ) As qd
		Dim As qd result
		c_qd_sub_qd_d( lhs, Cdbl(rhs), result)
		Operator = result
	End Operator
	
	Operator - ( Byref lhs As qd, Byval rhs As Ulong ) As qd
		Dim As qd result
		c_qd_sub_qd_d( lhs, Cdbl(rhs), result)
		Operator = result
	End Operator
	
	Operator - ( Byref lhs As qd, Byval rhs As Longint ) As qd
		Dim As qd result
		c_qd_read( Str(rhs), result )
		c_qd_sub( lhs, result, result)
		Operator = result
	End Operator

	Operator - ( Byref lhs As qd, Byval rhs As Ulongint ) As qd
		Dim As qd result
		c_qd_read( Str(rhs), result )
		c_qd_sub( lhs, result, result)
		Operator = result
	End Operator

	Operator - ( Byref lhs As qd, Byval rhs As Integer ) As qd
		Dim As qd result
		c_qd_read( Str(rhs), result )
		c_qd_sub( lhs, result, result)
		Operator = result
	End Operator

	Operator - ( Byref lhs As qd, Byval rhs As Uinteger ) As qd
		Dim As qd result
		c_qd_read( Str(rhs), result )
		c_qd_sub( lhs, result, result)
		Operator = result
	End Operator
	
	Operator - ( Byref lhs As qd, Byval rhs As Double ) As qd
		Dim As qd result
		c_qd_sub_qd_d( lhs, rhs, result)
		Operator = result
	End Operator

'''
	Operator - ( Byval lhs As Long, Byval rhs As qd) As qd
		Dim As qd result
		c_qd_sub_d_qd( Cdbl(lhs), rhs, result)
		Operator = result
	End Operator
	
	Operator - ( Byval lhs As Ulong, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_sub_d_qd( Cdbl(lhs), rhs, result)
		Operator = result
	End Operator
	
	Operator - ( Byval lhs As Longint, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_read( Str(lhs), result )
		c_qd_sub( result, rhs, result)
		Operator = result
	End Operator

	Operator - ( Byval lhs As Ulongint, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_read( Str(lhs), result )
		c_qd_sub( result, rhs, result)
		Operator = result
	End Operator

	Operator - ( Byval lhs As Integer, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_read( Str(lhs), result )
		c_qd_sub( result, rhs, result)
		Operator = result
	End Operator

	Operator - ( Byval lhs As Uinteger, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_read( Str(lhs), result )
		c_qd_sub( result, rhs, result)
		Operator = result
	End Operator
	
	Operator - ( Byval lhs As Double, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_sub_d_qd( lhs, rhs, result)
		Operator = result
	End Operator

	'****************************************************************
	Operator * ( Byref lhs As qd, Byref rhs As qd ) As qd
		Dim As qd result
		c_qd_mul( lhs, rhs, result )
		Operator = result
	End Operator
	
	Operator * ( Byref lhs As qd, Byref rhs As dd ) As qd
		Dim As qd result
		c_qd_mul_qd_dd( lhs, rhs, result )
		Operator = result
	End Operator

	Operator * ( Byref lhs As dd, Byref rhs As qd ) As qd
		Dim As qd result
		c_qd_mul_dd_qd( lhs, rhs, result )
		Operator = result
	End Operator
	
	Operator * ( Byref lhs As qd, Byval rhs As Long ) As qd
		Dim As qd result
		c_qd_mul_qd_d( lhs, Cdbl(rhs), result)
		Operator = result
	End Operator
	
	Operator * ( Byref lhs As qd, Byval rhs As Ulong ) As qd
		Dim As qd result
		c_qd_mul_qd_d( lhs, Cdbl(rhs), result)
		Operator = result
	End Operator
	
	Operator * ( Byref lhs As qd, Byval rhs As Longint ) As qd
		Dim As qd result
		c_qd_read( Str(rhs), result )
		c_qd_mul( lhs, result, result)
		Operator = result
	End Operator

	Operator * ( Byref lhs As qd, Byval rhs As Ulongint ) As qd
		Dim As qd result
		c_qd_read( Str(rhs), result )
		c_qd_mul( lhs, result, result)
		Operator = result
	End Operator

	Operator * ( Byref lhs As qd, Byval rhs As Integer ) As qd
		Dim As qd result
		c_qd_read( Str(rhs), result )
		c_qd_mul( lhs, result, result)
		Operator = result
	End Operator

	Operator * ( Byref lhs As qd, Byval rhs As Uinteger ) As qd
		Dim As qd result
		c_qd_read( Str(rhs), result )
		c_qd_mul( lhs, result, result)
		Operator = result
	End Operator
	
	Operator * ( Byref lhs As qd, Byval rhs As Double ) As qd
		Dim As qd result
		c_qd_mul_qd_d( lhs, rhs, result)
		Operator = result
	End Operator

'''
	Operator * ( Byval lhs As Long, Byval rhs As qd) As qd
		Dim As qd result
		c_qd_mul_d_qd( Cdbl(lhs), rhs, result)
		Operator = result
	End Operator
	
	Operator * ( Byval lhs As Ulong, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_mul_d_qd( Cdbl(lhs), rhs, result)
		Operator = result
	End Operator
	
	Operator * ( Byval lhs As Longint, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_read( Str(lhs), result )
		c_qd_mul( result, rhs, result)
		Operator = result
	End Operator

	Operator * ( Byval lhs As Ulongint, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_read( Str(lhs), result )
		c_qd_mul( result, rhs, result)
		Operator = result
	End Operator

	Operator * ( Byval lhs As Integer, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_read( Str(lhs), result )
		c_qd_mul( result, rhs, result)
		Operator = result
	End Operator

	Operator * ( Byval lhs As Uinteger, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_read( Str(lhs), result )
		c_qd_mul( result, rhs, result)
		Operator = result
	End Operator
	
	Operator * ( Byval lhs As Double, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_mul_d_qd( lhs, rhs, result)
		Operator = result
	End Operator

	'////////////////////////////////////////////////////////////////
	Operator / ( Byref lhs As qd, Byref rhs As qd ) As qd
		Dim As qd result
		c_qd_div( lhs, rhs, result )
		Operator = result
	End Operator
	
	Operator / ( Byref lhs As qd, Byref rhs As dd ) As qd
		Dim As qd result
		c_qd_div_qd_dd( lhs, rhs, result )
		Operator = result
	End Operator

	Operator / ( Byref lhs As dd, Byref rhs As qd ) As qd
		Dim As qd result
		c_qd_div_dd_qd( lhs, rhs, result )
		Operator = result
	End Operator
	
	Operator / ( Byref lhs As qd, Byval rhs As Long ) As qd
		Dim As qd result
		c_qd_div_qd_d( lhs, Cdbl(rhs), result)
		Operator = result
	End Operator
	
	Operator / ( Byref lhs As qd, Byval rhs As Ulong ) As qd
		Dim As qd result
		c_qd_div_qd_d( lhs, Cdbl(rhs), result)
		Operator = result
	End Operator
	
	Operator / ( Byref lhs As qd, Byval rhs As Longint ) As qd
		Dim As qd result
		c_qd_read( Str(rhs), result )
		c_qd_div( lhs, result, result)
		Operator = result
	End Operator

	Operator / ( Byref lhs As qd, Byval rhs As Ulongint ) As qd
		Dim As qd result
		c_qd_read( Str(rhs), result )
		c_qd_div( lhs, result, result)
		Operator = result
	End Operator

	Operator / ( Byref lhs As qd, Byval rhs As Integer ) As qd
		Dim As qd result
		c_qd_read( Str(rhs), result )
		c_qd_div( lhs, result, result)
		Operator = result
	End Operator

	Operator / ( Byref lhs As qd, Byval rhs As Uinteger ) As qd
		Dim As qd result
		c_qd_read( Str(rhs), result )
		c_qd_div( lhs, result, result)
		Operator = result
	End Operator
	
	Operator / ( Byref lhs As qd, Byval rhs As Double ) As qd
		Dim As qd result
		c_qd_div_qd_d( lhs, rhs, result)
		Operator = result
	End Operator

'''
	Operator / ( Byval lhs As Long, Byval rhs As qd) As qd
		Dim As qd result
		c_qd_div_d_qd( Cdbl(lhs), rhs, result)
		Operator = result
	End Operator
	
	Operator / ( Byval lhs As Ulong, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_div_d_qd( Cdbl(lhs), rhs, result)
		Operator = result
	End Operator
	
	Operator / ( Byval lhs As Longint, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_read( Str(lhs), result )
		c_qd_div( result, rhs, result)
		Operator = result
	End Operator

	Operator / ( Byval lhs As Ulongint, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_read( Str(lhs), result )
		c_qd_div( result, rhs, result)
		Operator = result
	End Operator

	Operator / ( Byval lhs As Integer, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_read( Str(lhs), result )
		c_qd_div( result, rhs, result)
		Operator = result
	End Operator

	Operator / ( Byval lhs As Uinteger, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_read( Str(lhs), result )
		c_qd_div( result, rhs, result)
		Operator = result
	End Operator
	
	Operator / ( Byval lhs As Double, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_div_d_qd( lhs, rhs, result)
		Operator = result
	End Operator

	'^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
	Operator ^ ( Byref lhs As qd, Byval rhs As Integer ) As qd
		Dim As qd result
		c_qd_npwr( lhs, rhs, result )
		Operator = result
	End Operator
	
	Operator ^ ( Byval lhs As Integer, Byval rhs As qd ) As qd
		Dim As qd result=lhs
		c_qd_log( result, result )
		c_qd_mul( result, rhs, result)
		c_qd_exp( result, result )
		Operator = result
	End Operator

	Operator ^ ( Byref lhs As qd, Byval rhs As qd ) As qd
		Dim As qd result
		c_qd_log( lhs, result )
		c_qd_mul( result, rhs, result)
		c_qd_exp( result, result )
		Operator = result
	End Operator

	' self add
	Operator qd.+= (Byref rhs As qd)
		c_qd_selfadd(rhs, This)
	End Operator
	
	Operator qd.+= (Byref rhs As dd)
		c_qd_selfadd_dd(rhs, This)
	End Operator

	Operator qd.+= (Byval rhs As Long)
		c_qd_selfadd_d(Cdbl(rhs), This)
	End Operator
	
	Operator qd.+= (Byval rhs As Double)
		c_qd_selfadd_d(rhs, This)
	End Operator
	
	Operator qd.+= (Byval rhs As Longint)
		Dim As qd temp
		c_qd_read( Str(rhs), temp )
		c_qd_selfadd(temp, This)
	End Operator
	
	Operator qd.+= (Byval rhs As Integer)
		Dim As qd temp
		c_qd_read( Str(rhs), temp )
		c_qd_selfadd(temp, This)
	End Operator
	
	Operator qd.+= (Byref rhs As String)
		Dim As qd temp
		c_qd_read(rhs, temp )
		c_qd_selfadd(temp, This)
	End Operator

	'self sub
	Operator qd.-= (Byref rhs As qd)
		c_qd_selfsub(rhs, This)
	End Operator
	
	Operator qd.-= (Byref rhs As dd)
		c_qd_selfsub_dd(rhs, This)
	End Operator

	Operator qd.-= (Byval rhs As Long)
		c_qd_selfsub_d(Cdbl(rhs), This)
	End Operator
	
	Operator qd.-= (Byval rhs As Double)
		c_qd_selfsub_d(rhs, This)
	End Operator
	
	Operator qd.-= (Byval rhs As Longint)
		Dim As qd temp
		c_qd_read( Str(rhs), temp )
		c_qd_selfsub(temp, This)
	End Operator
	
	Operator qd.-= (Byval rhs As Integer)
		Dim As qd temp
		c_qd_read( Str(rhs), temp )
		c_qd_selfsub(temp, This)
	End Operator
	
	Operator qd.-= (Byref rhs As String)
		Dim As qd temp
		c_qd_read(rhs, temp )
		c_qd_selfsub(temp, This)
	End Operator

	'self mul

	Operator qd.*= (Byref rhs As qd)
		c_qd_selfmul(rhs, This)
	End Operator
	
	Operator qd.*= (Byref rhs As dd)
		c_qd_selfmul_dd(rhs, This)
	End Operator

	Operator qd.*= (Byval rhs As Long)
		c_qd_selfmul_d(Cdbl(rhs), This)
	End Operator
	
	Operator qd.*= (Byval rhs As Double)
		c_qd_selfmul_d(rhs, This)
	End Operator
	
	Operator qd.*= (Byval rhs As Longint)
		Dim As qd temp
		c_qd_read( Str(rhs), temp )
		c_qd_selfmul(temp, This)
	End Operator
	
	Operator qd.*= (Byval rhs As Integer)
		Dim As qd temp
		c_qd_read( Str(rhs), temp )
		c_qd_selfmul(temp, This)
	End Operator
	
	Operator qd.*= (Byref rhs As String)
		Dim As qd temp
		c_qd_read(rhs, temp )
		c_qd_selfmul(temp, This)
	End Operator

	'self div

	Operator qd./= (Byref rhs As qd)
		c_qd_selfdiv(rhs, This)
	End Operator
	
	Operator qd./= (Byref rhs As dd)
		c_qd_selfdiv_dd(rhs, This)
	End Operator

	Operator qd./= (Byval rhs As Long)
		c_qd_selfdiv_d(Cdbl(rhs), This)
	End Operator
	
	Operator qd./= (Byval rhs As Double)
		c_qd_selfdiv_d(rhs, This)
	End Operator
	
	Operator qd./= (Byval rhs As Longint)
		Dim As qd temp
		c_qd_read( Str(rhs), temp )
		c_qd_selfdiv(temp, This)
	End Operator
	
	Operator qd./= (Byval rhs As Integer)
		Dim As qd temp
		c_qd_read( Str(rhs), temp )
		c_qd_selfdiv(temp, This)
	End Operator
	
	Operator qd./= (Byref rhs As String)
		Dim As qd temp
		c_qd_read(rhs, temp )
		c_qd_selfdiv(temp, This)
	End Operator
'''
	Operator = ( Byref lhs As qd, Byref rhs As qd ) As Long
		Dim As Long t
		c_qd_comp(lhs, rhs, @t)
		Operator = (t = 0)
	End Operator

	Operator = ( Byref lhs As qd, Byval rhs As Double) As Long
		Dim As Long t
		c_qd_comp_qd_d(lhs, rhs, @t)
		Operator = (t = 0)
	End Operator

	Operator = ( Byval lhs As Double, Byref rhs As qd) As Long
		Dim As Long t
		c_qd_comp_d_qd(lhs, rhs, @t)
		Operator = (t = 0)
	End Operator

	Operator < ( Byref lhs As qd, Byref rhs As qd ) As Long
		Dim As Long t
		c_qd_comp(lhs, rhs, @t)
		Operator = (t < 0)
	End Operator

	Operator < ( Byref lhs As qd, Byval rhs As Double) As Long
		Dim As Long t
		c_qd_comp_qd_d(lhs, rhs, @t)
		Operator = (t < 0)
	End Operator

	Operator < ( Byval lhs As Double, Byref rhs As qd) As Long
		Dim As Long t
		c_qd_comp_d_qd(lhs, rhs, @t)
		Operator = (t < 0)
	End Operator

	Operator <= ( Byref lhs As qd, Byref rhs As qd ) As Long
		Dim As Long t
		c_qd_comp(lhs, rhs, @t)
		Operator = (t <= 0)
	End Operator

	Operator <= ( Byref lhs As qd, Byval rhs As Double) As Long
		Dim As Long t
		c_qd_comp_qd_d(lhs, rhs, @t)
		Operator = (t <= 0)
	End Operator

	Operator <= ( Byval lhs As Double, Byref rhs As qd) As Long
		Dim As Long t
		c_qd_comp_d_qd(lhs, rhs, @t)
		Operator = (t <= 0)
	End Operator

	Operator >= ( Byref lhs As qd, Byref rhs As qd ) As Long
		Dim As Long t
		c_qd_comp(lhs, rhs, @t)
		Operator = (t >= 0)
	End Operator

	Operator >= ( Byref lhs As qd, Byval rhs As Double) As Long
		Dim As Long t
		c_qd_comp_qd_d(lhs, rhs, @t)
		Operator = (t >= 0)
	End Operator

	Operator >= ( Byval lhs As Double, Byref rhs As qd) As Long
		Dim As Long t
		c_qd_comp_d_qd(lhs, rhs, @t)
		Operator = (t >= 0)
	End Operator

	Operator > ( Byref lhs As qd, Byref rhs As qd ) As Long
		Dim As Long t
		c_qd_comp(lhs, rhs, @t)
		Operator = (t > 0)
	End Operator

	Operator > ( Byref lhs As qd, Byval rhs As Double) As Long
		Dim As Long t
		c_qd_comp_qd_d(lhs, rhs, @t)
		Operator = (t > 0)
	End Operator

	Operator > ( Byval lhs As Double, Byref rhs As qd) As Long
		Dim As Long t
		c_qd_comp_d_qd(lhs, rhs, @t)
		Operator = (t > 0)
	End Operator

'---------------------------------------------------------	
	Function qd_abs(Byref x As qd) As qd
		Dim As qd result
		c_qd_abs( x, result)
		Function = result
	End Function

	Function qd_acos(Byref x As qd) As qd
		Dim As qd result
		c_qd_acos( x, result)
		Function = result
	End Function
	
	Function qd_acosh(Byref x As qd) As qd
		Dim As qd result
		c_qd_acosh( x, result)
		Function = result
	End Function

	Function qd_aint(Byref x As qd) As qd
		Dim As qd result
		c_qd_aint( x, result)
		Function = result
	End Function
		
	Function qd_asin(Byref x As qd) As qd
		Dim As qd result
		c_qd_asin( x, result)
		Function = result
	End Function
	
	Function qd_asinh(Byref x As qd) As qd
		Dim As qd result
		c_qd_asinh( x, result)
		Function = result
	End Function
	
	Function qd_atan(Byref x As qd) As qd
		Dim As qd result
		c_qd_atan( x, result)
		Function = result
	End Function
	
	Function qd_atan2(Byref x As qd, Byref y As qd) As qd
		Dim As qd result
		c_qd_atan2( x, y, result)
		Function = result
	End Function
	
	Function qd_atanh(Byref x As qd) As qd
		Dim As qd result
		c_qd_atanh( x, result)
		Function = result
	End Function
	
	Function qd_ceil(Byref x As qd) As qd
		Dim As qd result
		c_qd_ceil( x, result)
		Function = result
	End Function
	
	Function qd_cos(Byref x As qd) As qd
		Dim As qd result
		c_qd_cos( x, result)
		Function = result
	End Function
	
	Function qd_cosh(Byref x As qd) As qd
		Dim As qd result
		c_qd_cosh( x, result)
		Function = result
	End Function
	
	Function qd_exp(Byref x As qd) As qd
		Dim As qd result
		c_qd_exp( x, result)
		Function = result
	End Function
	
	Function qd_exp10(Byref x As qd) As qd
		Dim As qd result
		c_qd_exp10( x, result)
		Function = result
	End Function
	
	Function qd_floor(Byref x As qd) As qd
		Dim As qd result
		c_qd_floor( x, result)
		Function = result
	End Function
	
	Function qd_log(Byref x As qd) As qd
		Dim As qd result
		c_qd_log( x, result)
		Function = result
	End Function
	
	Function qd_log10(Byref x As qd) As qd
		Dim As qd result
		c_qd_log10( x, result)
		Function = result
	End Function
	
	Function qd_nint(Byref x As qd) As qd
		Dim As qd result
		c_qd_nint( x, result)
		Function = result
	End Function
	
	Function qd_nroot(Byref x As qd, Byval n As Long) As qd
		Dim As qd result
		c_qd_nroot( x, n, result)
		Function = result
	End Function
	
	Function qd_rand() As qd
		Dim As qd result
		c_qd_rand(result)
		Function = result
	End Function

	Function qd_sgn(Byref x As qd) As Long
		Function = Sgn(x.qdm1)
	End Function
	
	Function qd_sin(Byref x As qd) As qd
		Dim As qd result
		c_qd_sin( x, result)
		Function = result
	End Function
	
	Function qd_sinh(Byref x As qd) As qd
		Dim As qd result
		c_qd_sinh( x, result)
		Function = result
	End Function
	
	Function qd_sqr(Byref x As qd) As qd
		Dim As qd result
		c_qd_sqr( x, result)
		Function = result
	End Function
	
	Function qd_sqrt(Byref x As qd) As qd
		Dim As qd result
		c_qd_sqrt( x, result)
		Function = result
	End Function
	
	Function qd_tan(Byref x As qd) As qd
		Dim As qd result
		c_qd_tan( x, result)
		Function = result
	End Function
	
	Function qd_tanh(Byref x As qd) As qd
		Dim As qd result
		c_qd_tanh( x, result)
		Function = result
	End Function
srvaldez
Posts: 3373
Joined: Sep 25, 2005 21:54

Re: QD library

Post by srvaldez »

qd_overload.bi

Code: Select all

	#Ifndef DD_H_
		#include "dd.bi"
	#Endif
	#Ifndef QD_H_
		#include "qd.bi"
	#Endif
	Operator abs(byref x As dd) As dd
		dim as dd result
		c_dd_abs( x, result)
		Operator = result
	end Operator
	
	Operator acos(byref x As dd) As dd
		dim as dd result
		c_dd_acos( x, result)
		Operator = result
	end Operator

	function acosh Overload(byref x As dd) As dd
		dim as dd result
		c_dd_acosh( x, result)
		function = result
	end function

	Operator asin(byref x As dd) As dd
		dim as dd result
		c_dd_asin( x, result)
		Operator = result
	end Operator

	function asinh Overload(byref x As dd) As dd
		dim as dd result
		c_dd_asinh( x, result)
		function = result
	end function

	Operator atn(byref x As dd) As dd
		dim as dd result
		c_dd_atan( x, result)
		Operator = result
	end Operator

	function atanh Overload(byref x As dd) As dd
		dim as dd result
		c_dd_atanh( x, result)
		function = result
	end function

	Function Atan2_ ( ByVal y As Double, ByVal x As Double ) As Double
		Function = Atan2 ( y, x )
	End Function

	#undef Atan2

	Function Atan2 Overload ( ByVal y As Double, ByVal x As Double ) As Double
		Function = Atan2_ ( y, x )
	End Function

	Function Atan2 ( Byref y As dd, Byref x As dd ) As dd
		dim as dd result
		c_dd_atan2 ( y, x, result )
		Function = result
	End Function
	
	Operator cos(byref x As dd) As dd
		dim as dd result
		c_dd_cos( x, result)
		Operator = result
	end Operator
	
	Function cosh Overload(byref x As dd) As dd
		dim as dd result
		c_dd_cosh( x, result)
		Function = result
	end Function
	
	Function sinh Overload(byref x As dd) As dd
		dim as dd result
		c_dd_sinh( x, result)
		Function = result
	end Function

	Function tanh Overload(byref x As dd) As dd
		dim as dd result
		c_dd_tanh( x, result)
		Function = result
	end Function
	
	operator log(byref x As dd) As dd
		dim as dd result
		c_dd_log( x, result)
		return result
	end operator
	
	function log10 Overload (byref x As dd) As dd
		dim as dd result
		c_dd_log10( x, result)
		return result
	end function
		
	Operator exp(byref x As dd) As dd
		dim as dd result
		c_dd_exp( x, result)
		Operator = result
	end Operator
	
	function exp10 Overload(byref x As dd) As dd
		dim as dd result
		c_dd_exp10( x, result)
		return result
	end function
	
	function sqr_ (byval x as double) as double
		function=sqr(x)
	end function
	
	#undef Sqr

	Function Sqr Overload( ByVal x As double ) As Double
		Function = Sqr_( x )
	End Function

	Function Sqr ( Byref x As dd ) As dd
		dim as dd result
		c_dd_Sqrt( x, result )
		Function = result
	End Function
''qd
	Operator abs(byref x As qd) As qd
		dim as qd result
		c_qd_abs( x, result)
		Operator = result
	end Operator
	
	Operator acos(byref x As qd) As qd
		dim as qd result
		c_qd_acos( x, result)
		Operator = result
	end Operator

	function acosh(byref x As qd) As qd
		dim as qd result
		c_qd_acosh( x, result)
		function = result
	end function

	Operator asin(byref x As qd) As qd
		dim as qd result
		c_qd_asin( x, result)
		Operator = result
	end Operator

	function asinh(byref x As qd) As qd
		dim as qd result
		c_qd_asinh( x, result)
		function = result
	end function

	Operator atn(byref x As qd) As qd
		dim as qd result
		c_qd_atan( x, result)
		Operator = result
	end Operator

	function atanh(byref x As qd) As qd
		dim as qd result
		c_qd_atanh( x, result)
		function = result
	end function

	Function Atan2 ( Byref y As qd, Byref x As qd ) As qd
		dim as qd result
		c_qd_atan2 ( y, x, result )
		Function = result
	End Function
	
	Operator cos(byref x As qd) As qd
		dim as qd result
		c_qd_cos( x, result)
		Operator = result
	end Operator

	Function cosh (byref x As qd) As qd
		dim as qd result
		c_qd_cosh( x, result)
		Function = result
	end Function
	
	Function sinh (byref x As qd) As qd
		dim as qd result
		c_qd_sinh( x, result)
		Function = result
	end Function

	Function tanh (byref x As qd) As qd
		dim as qd result
		c_qd_tanh( x, result)
		Function = result
	end Function
		
	Operator exp(byref x As qd) As qd
		dim as qd result
		c_qd_exp( x, result)
		Operator = result
	end Operator

	operator log(byref x As qd) As qd
		dim as qd result
		c_qd_log( x, result)
		return result
	end operator
	
	function log10(byref x As qd) As qd
		dim as qd result
		c_qd_log10( x, result)
		return result
	end function
	
	function exp10(byref x As qd) As qd
		dim as qd result
		c_qd_exp10( x, result)
		return result
	end function

	Function Sqr ( Byref x As qd ) As qd
		dim as qd result
		c_qd_Sqrt( x, result )
		Function = result
	End Function
Post Reply