Buchempfehlung
Mikrocomputertechnik mit Controllern der Atmel AVR-RISC-Familie
Mikrocomputertechnik mit Controllern der Atmel AVR-RISC-Familie
Umfassend, aber leicht verständlich führt dieses Buch in die Programmierung von ATMEL AVR Mikrocontrollern ein. [Mehr Infos...]
FreeBASIC-Chat
Es sind Benutzer im FreeBASIC-Chat online.
(Stand:  )
FreeBASIC bei Twitter
Twitter FreeBASIC-Nachrichten jetzt auch über Twitter erhalten. Follow us!

fb:porticula NoPaste

Info
Info / Hilfe Liste
Übersicht / Liste Neu
Datei hochladen Suche
Quellcode suchen Download
Dateidownload

quad_4.bi

Uploader:RedakteurVolta
Datum/Zeit:30.09.2010 20:36:07

Operator * ( ByRef lhs As quad, ByRef rhs As quad ) As quad
  Dim As quad retval
  retval = longmul(lhs, rhs )
  Return retval
End Operator

Operator * ( ByRef lhs As quad, ByRef rhs As Integer ) As quad
  Dim As quad retval
  retval = mult_quad_int(lhs, rhs )
  Return retval
End Operator

Operator * ( ByRef lhs As Integer, ByRef rhs As quad ) As quad
  Dim As quad retval
  retval = mult_int_quad(lhs, rhs )
  Return retval
End Operator

Operator * ( ByRef lhs As quad, ByRef rhs As Long ) As quad
  Dim As quad retval
  retval = mult_quad_int(lhs, rhs )
  Return retval
End Operator

Operator * ( ByRef lhs As Long, ByRef rhs As quad ) As quad
  Dim As quad retval
  retval = mult_int_quad(lhs, rhs )
  Return retval
End Operator

Operator * ( ByRef lhs As quad, ByRef rhs As LongInt ) As quad
  Dim As quad retval
  retval = mult_quad_dp(lhs, CDbl(rhs) )
  Return retval
End Operator

Operator * ( ByRef lhs As LongInt, ByRef rhs As quad ) As quad
  Dim As quad retval
  retval = mult_dp_quad(CDbl(lhs), rhs )
  Return retval
End Operator

Operator * ( ByRef lhs As quad, ByRef rhs As Single ) As quad
  Dim As quad retval
  retval = mult_quad_Real(lhs, rhs )
  Return retval
End Operator

Operator * ( ByRef lhs As Single, ByRef rhs As quad ) As quad
  Dim As quad retval
  retval = mult_Real_quad(lhs, rhs )
  Return retval
End Operator

Operator * ( ByRef lhs As quad, ByRef rhs As Double ) As quad
  Dim As quad retval
  retval = mult_quad_dp(lhs, rhs )
  Return retval
End Operator

Operator * ( ByRef lhs As Double, ByRef rhs As quad ) As quad
  Dim As quad retval
  retval = mult_dp_quad(lhs, rhs )
  Return retval
End Operator

Operator quad.*= ( ByRef rhs As quad )
  Dim As quad retval
  this = longmul(this, rhs )
End Operator

Operator quad.*= ( ByRef rhs As Double )
  Dim As quad retval
  this = mult_quad_dp(this, rhs )
End Operator

Operator quad.*= ( ByRef rhs As Integer )
  Dim As quad retval
  this = mult_quad_int(this, rhs )
End Operator

Operator quad.*= ( ByRef rhs As String )
  Dim As quad retval
  retval = string_quad( rhs )
  this = longmul(this, retval )
End Operator


Operator / ( ByRef lhs As quad, ByRef rhs As quad ) As quad
  Dim As quad retval
  retval = longdiv(lhs, rhs )
  Return retval
End Operator

Operator / ( ByRef lhs As quad, ByRef rhs As Integer ) As quad
  Dim As quad retval
  retval = div_quad_int(lhs, rhs )
  Return retval
End Operator

Operator / ( ByRef lhs As Integer, ByRef rhs As quad ) As quad
  Dim As quad retval
  retval = div_int_quad(lhs, rhs )
  Return retval
End Operator

Operator / ( ByRef lhs As quad, ByRef rhs As Long ) As quad
  Dim As quad retval
  retval = div_quad_int(lhs, rhs )
  Return retval
End Operator

Operator / ( ByRef lhs As Long, ByRef rhs As quad ) As quad
  Dim As quad retval
  retval = div_int_quad(lhs, rhs )
  Return retval
End Operator

Operator / ( ByRef lhs As quad, ByRef rhs As LongInt ) As quad
  Dim As quad retval
  retval = div_quad_dp(lhs, CDbl(rhs) )
  Return retval
End Operator

Operator / ( ByRef lhs As LongInt, ByRef rhs As quad ) As quad
  Dim As quad retval
  retval = div_dp_quad(CDbl(lhs), rhs )
  Return retval
End Operator

Operator / ( ByRef lhs As quad, ByRef rhs As Single ) As quad
  Dim As quad retval
  retval = div_quad_Real(lhs, rhs )
  Return retval
End Operator

Operator / ( ByRef lhs As Single, ByRef rhs As quad ) As quad
  Dim As quad retval
  retval = div_Real_quad(lhs, rhs )
  Return retval
End Operator

Operator / ( ByRef lhs As quad, ByRef rhs As Double ) As quad
  Dim As quad retval
  retval = div_quad_dp(lhs, rhs )
  Return retval
End Operator

Operator / ( ByRef lhs As Double, ByRef rhs As quad ) As quad
  Dim As quad retval
  retval = div_dp_quad(lhs, rhs )
  Return retval
End Operator

Operator quad./= ( ByRef rhs As quad )
  Dim As quad retval
  this = longdiv(this, rhs )
End Operator

Operator quad./= ( ByRef rhs As Double )
  Dim As quad retval
  this = div_quad_dp(this, rhs )
End Operator

Operator quad./= ( ByRef rhs As Integer )
  Dim As quad retval
  this = div_quad_int(this, rhs )
End Operator

Operator quad./= ( ByRef rhs As String )
  Dim As quad retval
  retval = string_quad( rhs )
  this = longdiv(this, retval )
End Operator


Operator ^ ( ByRef lhs As quad, ByRef rhs As quad ) As quad
  Dim As quad retval
  retval = quad_pow_quad(lhs, rhs )
  Return retval
End Operator

Operator ^ ( ByRef lhs As quad, ByRef rhs As Integer ) As quad
  Dim As quad retval
  retval = quad_pow_int(lhs, rhs )
  Return retval
End Operator

Operator ^ ( ByRef lhs As quad, ByRef rhs As LongInt ) As quad
  Dim As quad retval
  retval = quad_pow_dp(lhs, CDbl(rhs) )
  Return retval
End Operator

Operator ^ ( ByRef lhs As quad, ByRef rhs As Double ) As quad
  Dim As quad retval
  retval = quad_pow_dp(lhs, rhs )
  Return retval
End Operator

Operator ^ ( ByRef lhs As Quad, ByRef rhs As Single ) As quad
  Dim As quad retval
  retval = quad_pow_Real(lhs, rhs )
  Return retval
End Operator

Operator Mod ( ByRef lhs As quad, ByRef rhs As quad ) As quad_rm
  Dim As quad_rm retval
  Dim As quad rm
  Dim As Integer n
  longmodr ( lhs, rhs, n, rm )
  retval.n = n
  retval.rm = rm
  Return retval
End Operator

Operator quad.^= ( ByRef rhs As quad )
  Dim As quad retval
  this = quad_pow_quad(this, rhs )
End Operator

Operator quad.^= ( ByRef rhs As Double )
  Dim As quad retval
  this = quad_pow_dp(this, CDbl(rhs) )
End Operator

Operator quad.^= ( ByRef rhs As Integer )
  Dim As quad retval
  this = quad_pow_int(this, rhs )
End Operator

Operator quad.^= ( ByRef rhs As String )
  Dim As quad retval
  retval = string_quad( rhs )
  this = quad_pow_quad(this, retval )
End Operator

'<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
Operator <> ( ByRef lhs As quad, ByRef rhs As quad ) As Integer
  Dim As Integer relop
  relop = Not quad_eq( lhs, rhs )
  Return relop
End Operator

Operator = ( ByRef lhs As quad, ByRef rhs As quad ) As Integer
  Dim As Integer relop
  relop = quad_eq( lhs, rhs )
  Return relop
End Operator

Operator > ( ByRef lhs As quad, ByRef rhs As quad ) As Integer
  Dim As Integer relop
  relop = quad_gt( lhs, rhs )
  Return relop
End Operator

Operator >= ( ByRef lhs As quad, ByRef rhs As quad ) As Integer
  Dim As Integer relop
  relop = quad_ge( lhs, rhs )
  Return relop
End Operator

Operator <= ( ByRef lhs As quad, ByRef rhs As quad ) As Integer
  Dim As Integer relop
  relop = quad_le( lhs, rhs )
  Return relop
End Operator

Operator < ( ByRef lhs As quad, ByRef rhs As quad ) As Integer
  Dim As Integer relop
  relop = quad_lt( lhs, rhs )
  Return relop
End Operator


Operator quad.cast ( ) As Integer
Operator = cquad ( CDbl(this), zero )
End Operator

Operator quad.cast ( ) As Long
Operator = cquad ( CDbl(this), zero )
End Operator

Operator quad.cast ( ) As LongInt
Operator = cquad ( CDbl(this), zero )
End Operator

Operator quad.cast ( ) As UInteger
Operator = cquad ( CDbl(this), zero )
End Operator

Operator quad.cast ( ) As ULong
Operator = cquad ( CDbl(this), zero )
End Operator

Operator quad.cast ( ) As ULongInt
Operator = cquad ( CDbl(this), zero )
End Operator

Operator quad.cast ( ) As Single
Operator = cquad ( CDbl(this), zero )
End Operator

Operator quad.cast ( ) As Double
Operator = cquad ( this, zero )
End Operator

Operator quad.cast ( ) As String
Operator = quad_string( this )
End Operator

Constructor quad ( ByRef rhs As quad )
this = rhs
End Constructor

Constructor quad ( ByRef rhs As Integer )
this.hi = CDbl(rhs )
this.lo = zero
End Constructor

Constructor quad ( ByRef rhs As Long )
this.hi = CDbl(rhs )
this.lo = zero
End Constructor

Constructor quad ( ByRef rhs As LongInt )
this.hi = CDbl(rhs )
this.lo = zero
End Constructor

Constructor quad ( ByRef rhs As UInteger )
this.hi = CDbl(rhs )
this.lo = zero
End Constructor

Constructor quad ( ByRef rhs As ULong )
this.hi = CDbl(rhs )
this.lo = zero
End Constructor

Constructor quad ( ByRef rhs As ULongInt )
this.hi = CDbl(rhs )
this.lo = zero
End Constructor

Constructor quad ( ByRef rhs As Single )
this.hi = CDbl(rhs )
this.lo = zero
End Constructor

Constructor quad ( ByRef rhs As Double )
this.hi = rhs
this.lo = zero
End Constructor

Constructor quad ( ByRef rhs As String )
this = string_quad ( rhs )
End Constructor

Operator quad.let ( ByRef rhs As quad )
  this.hi = rhs.hi
  this.lo = rhs.lo
End Operator

Operator quad.let ( ByRef rhs As Integer )
  this.hi = CDbl(rhs)
  this.lo = zero
End Operator

Operator quad.let ( ByRef rhs As Long )
  this.hi = CDbl(rhs )
  this.lo = zero
End Operator

Operator quad.let ( ByRef rhs As LongInt )
  this.hi = CDbl(rhs )
  this.lo = zero
End Operator

Operator quad.let ( ByRef rhs As UInteger )
  this.hi = CDbl(rhs )
  this.lo = zero
End Operator

Operator quad.let ( ByRef rhs As ULong )
  this.hi = CDbl(rhs )
  this.lo = zero
End Operator

Operator quad.let ( ByRef rhs As ULongInt )
  this.hi = CDbl(rhs )
  this.lo = zero
End Operator

Operator quad.let ( ByRef rhs As Single )
  this.hi = CDbl(rhs )
  this.lo = zero
End Operator

Operator quad.let ( ByRef rhs As Double )
  this.hi = rhs
  this.lo = zero
End Operator

Operator quad.let ( ByRef rhs As String )
  this = string_quad ( rhs )
End Operator

'=========================================================
'' For next for quadended type
''
'' implicit step versions
''
'' In this example, we interpret implicit step
'' to mean 1
Operator quad.for( )
End Operator

Operator quad.step( )
  this += 1 'this = this+1 '
End Operator

Operator quad.next( ByRef end_cond As quad ) As Integer
  Return this <= end_cond
End Operator


'' explicit step versions
''
Operator quad.for( ByRef step_var As quad )
End Operator

Operator quad.step( ByRef step_var As quad )
  this += step_var 'this = this + step_var '
End Operator

Operator quad.next( ByRef end_cond As quad, ByRef step_var As quad ) As Integer
  If step_var < 0 Then
    Return this >= end_cond
  Else
    Return this <= end_cond
  End If
End Operator

End Namespace