BlackTDN Search

sexta-feira, 3 de junho de 2011

Protheus :: Advpl : Class TMathIntegerStr ( Brincando de ser GRANDE )

No "AMM - ADVPL Básico : Introdução á programação e ADVPL Básico : página 27" tem a seguinte afirmação: "Uma variável do tipo de dado numérico pode conter um número de dezoito dígitos incluindo o ponto flutuante, no intervalo de 2.2250738585072014 E–308 até 1.7976931348623158 E+308". Que, considerando a precisão numérica, torna-se uma inverdade. A precisão numérica no Protheus são de 15 dígitos: incluido aí o ponto flutuante.

Para "Brincar um pouco de ser GRANDE", e superar os limites numéricos da linguagem, e, a exemplo do post : Protheus :: Multiplicando Números Absurdamente Grandes, vamos agora implementar as 4 Operações. Para isso implementaremos a Classe base denominada TMathIntegerStr, que será utilizada para operações com Números Inteiros, e sua derivada TMathFloatStr para números em Ponto Flutuante. É uma divertida brincadeira e que funciona de verdade.

TMathIntegerStr, a despeito de futuras otimizações no método Pow (exponenciação), está funcional. Adiciona, Subtrai, Multiplica, Divide, Retorna o Módulo da Divisão e, ainda, calcula Exponenciação. Tudo isso para Números Inteiros absurdamente GRANDES.

Já a sua derivada, TMathFloatStr, Opera: Multiplicação, Divisão, Subtração e Adição de Números em Ponto Flutuante. Mas números muito, mas muito, mas muito GRANDES ou, tão pequenos, que tendem a ZERO.

Outras funcionalidades serão implementadas futuramente, estava ansioso para mostrar a "Novidade". Foi, de certa forma, proposital. Pois terão o prazer de brincar de "matemático". Considerem usar a Diversidade e aprendam brincando. Muito divertido.

Bem, para aqueles que não gostam de muita ladainha, lá vai o código:
Class TMathIntegerStr: Operando com Inteiros

#INCLUDE "PROTHEUS.CH"
#INCLUDE "TMATHSTR.CH"

/*/
 Class:  TMathIntegerStr
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Operando com Numeros Inteiros
 Sintaxe: TMathIntegerStr():New() -> Objeto do Tipo TMathIntegerStr
/*/
Class TMathIntegerStr From LongClassName

 Method New() CONSTRUCTOR

 Method Multiply( cN1 , cN2 )

 Method Pow( cN1 , cN2 )
 Method __Pow( cN1 , cN2 )

 Method Divide( cN1 , cN2 )
 Method Mod( cN1 , cN2 )
 
 Method Add( cN1 , cN2 )
 Method Subtract( cN1 , cN2 )
 
 Method MathC( cN1 , cOperator , cN2 )

EndClass

User Function MathIntegerStr()
Return( TMathIntegerStr():New() )

/*/
 Method:  New
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: CONSTRUCTOR
 Sintaxe: TMathIntegerStr():New() -> Self
/*/
Method New() Class TMathIntegerStr
Return( self )

/*/
 Method:  Multiply
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Multiplicacao de Inteiros
 Sintaxe: TMathIntegerStr():Multiply( cN1 , cN2 ) -> cNRet
/*/
Method Multiply( cN1 , cN2 ) Class TMathIntegerStr

 Local a
 Local b
 Local c

 Local cNRet

 Local g  := 0
 Local h  := 0
 Local i  := 0
 Local j  := 0
 Local k  := 0
 Local l  := 0
 Local n  := 0
 Local y  := 0

 h  := Len( cN1 )
 g  := Len( cN2 )

 y  := Max( h , g )
 
 n := y
 h := y
 g := y

 a := StrByteToArr( Inverte( PadL( cN1 , y , "0" ) ) , .T. )
 b := StrByteToArr( Inverte( PadL( cN2 , y , "0" ) ) , .T. )

 y := ( h + g )

 c := Array( y )

 aFill( c , 0 )

 k := 1

 i := 1
 While ( i <= n )
  s := 1
  j := i
  While ( s <= i )
   c[k] += ( a[s] * b[j] )
   s++
   j--
  End While
  IF ( c[k] >= 10 )
   c[k+1] := Int( c[k] / 10 )
   c[k] -= ( c[k+1] * 10 )
  EndIF
  k++
  i++
 End While

 l := 2
 While ( l <= n )
  s := n
  j := l
  While ( s >= l )
   c[k] += ( a[s] * b[j] )
   s--
   j++
  End While
  IF ( c[k] >= 10 )
   c[k+1] := Int( c[k] / 10 )
   c[k] -= ( c[k+1] * 10 )
  EndIF
  k++
  IF ( k >= y )
   Exit
  EndIF
  l++
 End While

 cNRet := GetcNRet( @c , @k )

Return( cNRet )

/*/
 Method:  Pow
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Exponenciacao de Inteiros
 Sintaxe: TMathIntegerStr():Pow( cN1 , cN2 ) -> cNRet
/*/
Method Pow( cN1 , cN2 ) Class TMathIntegerStr

 Local cLN1 := cN1
 Local cLN2 := cN2

 Local cNRet
 Local cLaco
 
 Local nPadL

 BEGIN SEQUENCE

  While ( SubStr( cN1 , 1 , 1 ) == "0" )
   cN1 := SubStr( cN1 , 2 )
  End While

  IF Empty( cN1 )
   cNRet := "0"
   BREAK
  EndIF

  While ( SubStr( cN2 , 1 , 1 ) == "0" )
   cN2 := SubStr( cN2 , 2 )
  End While

  IF Empty( cN2 )
   cNRet := "1"
   BREAK
  EndIF

  cNRet := cN1

  IF ( cN2 == "1" )
   BREAK
  EndIF

  cN2  := Self:Subtract( cN2 , "1" )
  nPadL := Len( cN2 )
  cLaco := PadL( "0" , nPadL , "0" )
  While ( cLaco < cN2 ) //Processo de Multiplicacoes Sucessivas. Buscar Forma de Otimizar
   cNRet := Self:Multiply( cNRet , cN1 )
   cLaco := PadL( Self:Add( cLaco , "1" ) , nPadL , "0" )
  End While

 END SEQUENCE

 cN1 := cLN1
 cN2 := cLN2

Return( cNRet )

/*/
 Method:  __Pow
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Exponenciacao de Inteiros
 Sintaxe: TMathIntegerStr():__Pow( cN1 , cN2 ) -> cNRet
/*/
Method __Pow( cN1 , cN2 ) Class TMathIntegerStr

 Local cLN1 := cN1
 Local cLN2 := cN2

 Local cNRet
 Local cLaco
 
 Local nPadL

 BEGIN SEQUENCE

  While ( SubStr( cN1 , 1 , 1 ) == "0" )
   cN1 := SubStr( cN1 , 2 )
  End While

  IF Empty( cN1 )
   cNRet := "0"
   BREAK
  EndIF

  While ( SubStr( cN2 , 1 , 1 ) == "0" )
   cN2 := SubStr( cN2 , 2 )
  End While

  IF Empty( cN2 )
   cNRet := "1"
   BREAK
  EndIF

  cNRet := cN1

  IF ( cN2 == "1" )
   BREAK
  EndIF

  cN2  := Self:Subtract( cN2 , "1" )
  nPadL := Len( cN2 )
  cLaco := PadL( "0" , nPadL , "0" )
  While ( cLaco < cN2 ) //Processo de Multiplicacoes Sucessivas. Buscar Forma de Otimizar
   cNRet := Self:Multiply( cNRet , cN1 )
   cLaco := __Soma1( cLaco )
  End While

 END SEQUENCE

 cN1 := cLN1
 cN2 := cLN2

Return( cNRet )

/*/
 Method:  Divide
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Divisao de Inteiros
 Sintaxe: TMathIntegerStr():Divide( cN1 , cN2 , @cNRest ) -> cNRet
/*/
Method Divide( cN1 , cN2 , cNRest ) Class TMathIntegerStr

 Local e
 Local d
 Local r
    Local x
 Local g
 Local h
 Local y

 Local pe  := ""
 Local pd  := ""
 Local cLN1  := cN1
 Local cLN2  := cN2

 Local cNRet

 BEGIN SEQUENCE

  While ( SubStr( cN2 , 1 , 1 ) == "0" )
   cN2 := SubStr( cN2 , 2 )
  End While

  IF Empty( cN2 )
   cNRet := "0"
   cNRest := "0"
   BREAK
  EndIF

  h := Len( cN1 )
  g := Len( cN2 )
 
  y := Max( h , g )
  y += 1
 
  cN1 := PadL( cN1 , y , "0" )
  cN2 := PadL( cN2 , y , "0" )
 
  e  := {}
  d  := {}
 
  pe := PadL( "1" , y , "0" )
  pd := cN2
  z := 0
 
  While ( pd <= cN1 )
   ++z
   aAdd( e , { pe , pd , .F. } )
   pe := Self:Add( pe ,  pe )
   pd := Self:Add( pd ,  pd )
   pd := PadL( pd , y , "0" )
  End While
 
  z := Len( e )
  x := "0"
  While ( z > 0 )
   x := Self:Add( e[ z ][ 2 ] ,  x )
   x := PadL( x , y , "0" )
   IF ( x <= cN1 )
    e[ z ][ 3 ] := .T.
   Else
    x  := Self:Subtract( x , e[ z ][ 2 ] )
   EndIF
   --z
  End While
 
  r := Self:Subtract( cN1 , x )
 
  z := 0
  q := "0"
  While ( ( z := aScan( e , { |e| e[ 3 ] } , ++z ) ) > 0 )
   q := Self:Add( q , e[ z ][ 1 ] )
  End While

  cNRet := q
  cNRest  := r

 END SEQUENCE  
 
 cN1  := cLN1  
 cN2  := cLN2

Return( cNRet )

/*/
 Method:  Mod
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Resto da Divisao Inteira
 Sintaxe: TMathIntegerStr():Mod( cN1 , cN2 ) -> cNRest
/*/
Method Mod( cN1 , cN2 ) Class TMathIntegerStr

 Local cNRest

 Self:Divide( cN1 , cN2 , @cNRest )
 
Return( cNRest )

/*/
 Method:  Add
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Soma de Inteiros
 Sintaxe: TMathIntegerStr():Add( cN1 , cN2 ) -> cNRet
/*/
Method Add( cN1 , cN2 ) Class TMathIntegerStr

 Local a
 Local b
 Local c

 Local cLN1 := cN1
 Local cLN2 := cN2

 Local cNRet

 Local g  := 0
 Local h  := 0
 Local n  := 0
 Local y  := 0
 Local k  := 0

 h  := Len( cN1 )
 g  := Len( cN2 )

 y  := Max( h , g )       
 n := y
 
 cN1 := PadL( cN1 , y , "0" )
 cN2 := PadL( cN2 , y , "0" )

 a  := StrByteToArr( cN1 , .T. )
 b  := StrByteToArr( cN2 , .T. )

 y  := ( h + g )

 c  := Array( y )

 aFill( c , 0 )

 k := 1

 While ( n > 0  )
  c[k] += ( a[n] + b[n] )
  IF ( c[k] >= 10 )
   c[k+1] += 1
   c[k] -= 10
  EndIF
  ++k
  --n
 End While

 cN1  := cLN1
 cN2  := cLN2

 cNRet := GetcNRet( @c , @y )

Return( cNRet )

/*/
 Method:  Subtract
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Subtracao de Inteiros
 Sintaxe: TMathIntegerStr():Subtract( cN1 , cN2 ) -> cNRet
/*/
Method Subtract( cN1 , cN2 ) Class TMathIntegerStr

 Local a
 Local b
 Local c

 Local cLN1 := cN1
 Local cLN2 := cN2

 Local cNRet

 Local g  := 0
 Local h  := 0
 Local n  := 0
 Local y  := 0
 Local k  := 0
 
 Local lNegative

 h := Len( cN1 )
 g := Len( cN2 )

 y := Max( h , g )       
 n := y

 cN1 := PadL( cN1 , y , "0" )
 cN2 := PadL( cN2 , y , "0" )

 lNegative := ( cN1 < cN2 )
 IF ( lNegative )
  cNRet := cN1
  cN1  := cN2
  cN2  := cNRet
  cNRet := "0" 
 EndIF

 a := StrByteToArr( cN1 , .T. )
 b := StrByteToArr( cN2 , .T. )

 y := ( h + g )

 c := Array( y )

 aFill( c , 0 )

 k := 1

 While ( n > 0  )
  c[k] += ( a[n] - b[n] )
  IF ( c[k] < 0 )
   c[k+1] -= 1
   c[k] += 10
  EndIF
  ++k
  --n
 End While

 cN1  := cLN1
 cN2  := cLN2

 cNRet := GetcNRet( @c , @y )
 IF ( lNegative )
  cNRet := "-" + cNRet
 EndIF

Return( cNRet )

/*/
 Method:  MathC
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Operacoes com Numeros Inteiros
 Sintaxe: TMathIntegerStr():MathC( cN1 , cOperator , cN2 ) -> cNRet
/*/
Method MathC( cN1 , cOperator , cN2 ) Class TMathIntegerStr

 Local cNRet

 DO CASE
  CASE ( aScan( OPERATOR_ADD , { |cOp| cOperator == cOp } ) > 0 )
   cNRet := Self:Add( cN1 , cN2 )
  CASE ( aScan( OPERATOR_SUBTRACT , { |cOp| cOperator == cOp } ) > 0 )
   cNRet := Self:Subtract( cN1 , cN2 )
  CASE ( aScan( OPERATOR_MULTIPLY , { |cOp| cOperator == cOp } ) > 0 )
   cNRet := Self:Multiply( cN1 , cN2 )
  CASE ( aScan( OPERATOR_DIVIDE , { |cOp| cOperator == cOp } ) > 0 )
   cNRet := Self:Divide( cN1 , cN2 )
  CASE ( aScan( OPERATOR___POW  , { |cOp| cOperator == cOp } ) > 0 )
   cNRet := Self:__Pow( cN1 , cN2 )
  CASE ( aScan( OPERATOR_POW  , { |cOp| cOperator == cOp } ) > 0 )
   cNRet := Self:Pow( cN1 , cN2 )
  CASE ( aScan( OPERATOR_MOD  , { |cOp| cOperator == cOp } ) > 0 )
   cNRet := Self:Mod( cN1 , cN2 )
 OTHERWISE
  cNRet := "0"
 ENDCASE

Return( cNRet )

/*/
 Funcao:  GetcNRet
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Montar a String de Retorno
 Sintaxe: GetcNRet( c , x ) -> cNRet
/*/
Static Function GetcNRet( c , x )

 Local cNRet := ""

 While ( x >= 1 )
  While ( ( x >= 1 ) .and. ( c[x] == 0 ) )
   x--
  End While
  While ( x >= 1 )
   cNRet += Str( c[x] , 1 )
   x--
  End While
 End While
 
 IF ( cNRet == "" )
  cNRet := "0" 
 EndIF

Return( cNRet  )

/*/
 Funcao:  Inverte
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Inversao
 Sintaxe: Inverte( uInverte ) -> cInverso
/*/
Static Function Inverte( uInverte )

 Local cValType  := ValType( uInverte )
 Local cInverte  := ""
 Local cInverso   := ""

 IF ( cValType == "D" )
  cInverte   := Dtos( uInverte )
 ElseIF ( cValType $ "A/O" ) 
  cInverte  := ""
 ElseIF ( cValType == "N" )
  cInverte   := Transform( uInverte , RetPictVal( uInverte ) )
 ElseIF ( cValType == "L" )
  IF ( uInverte )
   cInverte := "0"
  Else
   cInverte := "1"   
  EndIF
 ElseIF ( cValType == "C" )
  cInverte   := uInverte
 Else
  cInverte     := ""
 EndIF 

 nIndex := Len( cInverte )

 While ( nIndex > 0 )
  cInverso += SubStr( cInverte , nIndex , 1 )
  --nIndex
 End While

Return( cInverso )

/*/
 Funcao:  RetPictVal
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Retorna a Picture de um Valor Numerico
 Sintaxe: RetPictVal( nVal , lDecZero , nInt , nDec , lPictSepMil ) -> cPict
/*/
Static Function RetPictVal( nVal , lDecZero , nInt , nDec , lPictSepMil )

 Local cPict
 Local cPictSepMil
 
 Local uInt
 Local uDec
 
 IF ( ValType( nVal ) == "N" )
  uInt := Int( nVal )
  uDec := ( nVal - uInt )
  DEFAULT lDecZero := .F.
  IF (;
    ( uDec == 0 );
    .and.;
    !( lDecZero );
   )
   uDec := NIL
  EndIF
  IF ( uDec <> NIL )
   uDec := AllTrim( Str( uDec ) )
   uDec := SubStr( uDec , At( "." , uDec ) + 1 )
   uDec := Len( uDec )
  EndIF
  uInt := Len( AllTrim( Str( uInt ) ) )
  nInt := uInt
  cPict := Replicate( "9" , uInt )
  DEFAULT lPictSepMil := .F.
  IF ( lPictSepMil )
   IF ( nInt > 3 )
    cPictSepMil := cPict
    cPict  := ""
    For uInt := nInt To 1 Step - 3
     cPict := ( "," + SubStr( cPictSepMil , -3 , uInt ) + cPict )
    Next uInt
   EndIF
  EndIF
  IF ( uDec <> NIL )
   cPict += "."
   cPict += Replicate( "9" , uDec )
   nDec := uDec
  EndIF
 EndIF

Return( cPict )

/*/
 Funcao:  StrByteToArr
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Array OF String Byte
 Sintaxe: StrByteToArr( cStr , lToVal )
/*/
Static Function StrByteToArr( cStr , lToVal )

 Local aStrByteArr := {}
 
 Local cByte
 
 Local nByte
 Local nBytes

 DEFAULt lToVal := .F.

 nByte  := 0
 nBytes := Len( cStr )
 While ( ( ++nByte ) <= nBytes )
  cByte := SubStr( cStr , nByte , 1 )
  aAdd( aStrByteArr , IF( lToVal , Val( cByte ) , cByte ) )
 End While

Return( aStrByteArr )
Class TMathFloatStr: Operando com Números com Ponto Flutuante.

#INCLUDE "PROTHEUS.CH"
#INCLUDE "TMATHSTR.CH"

/*/
 Class:  TMathFloatStr
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Operando com Numeros em Ponto Flutuante
 Sintaxe: TMathFloatStr():New() -> Objeto do Tipo TMathFloatStr
/*/
Class TMathFloatStr From TMathIntegerStr

 DATA nDecimalPrecision

 Method New() CONSTRUCTOR

 Method Multiply( cN1 , cN2 )
 
 Method Pow( cN1 , cN2 )
 Method __Pow( cN1 , cN2 )

 Method e()
 Method Exp( cN )
 
 Method SQRT( cN )
 
 Method Log( cN )

 Method Divide( cN1 , cN2 )
 Method Mod( cN1 , cN2 )

 Method Add( cN1 , cN2 )
 Method Subtract( cN1 , cN2 )

 Method MathC( cN1 , cOperator , cN2 )

 Method SetDecimals( nSet )

EndClass

User Function MathFloatStr()
Return( TMathFloatStr():New() )

/*/
 Method:  New
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: CONSTRUCTOR
 Sintaxe: TMathFloatStr():New() -> Self
/*/
Method New() Class TMathFloatStr

 _Super:New()

 Self:SetDecimals()

Return( self )

/*/
 Method:  Multiply
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Multiplicacao de Numeros em Ponto Flutuante
 Sintaxe: TMathFloatStr():Multiply( cN1 , cN2 ) -> cNRet
/*/
Method Multiply( cN1 , cN2 ) Class TMathFloatStr

 Local cLN1  := cN1
 Local cLN2  := cN2
 
 Local cNRet
 Local cPFloat

 Local nPFloat
 Local nN1PFloat := rAT( "." , cN1 )
 Local nN2PFloat := rAT( "." , cN2 )

 Local lPFloat := .F.

 IF ( nN1PFloat > 0 )
  nN1PFloat := Len( SubStr( cN1 , nN1PFloat + 1 ) )
  cN1   := StrTran( cN1 , "." , "" )
  lPFloat  := .T.
 EndIF

 IF ( nN2PFloat > 0 )
  nN2PFloat := Len( SubStr( cN2 , nN2PFloat + 1 ) )
  cN2   := StrTran( cN2 , "." , "" )
  lPFloat  := .T.
 EndIF

 cNRet   := _Super:Multiply( cN1 , cN2 )

 IF ( lPFloat )
  nPFloat := ( nN1PFloat + nN2PFloat )
  cPFloat := SubStr( cNRet , -nPFloat )
  nPFloat := ( Len( cNRet ) - Len( cPFloat ) )
  cNRet := SubStr( cNRet , 1 , nPFloat )
  IF ( cPFloat > "0" )
   nPFloat := Min( nPFloat , Self:nDecimalPrecision )
   cNRet += ( "." + SubStr( cPFloat , 1 , nPFloat ) )
  EndIF 
 EndIF 

 cN1 := cLN1
 cN2 := cLN2

Return( cNRet )

/*/
 Method:  Pow
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Exponenciacao de Numeros em Ponto Flutuante
 Sintaxe: TMathFloatStr():Pow( cN1 , cN2 ) -> cNRet
/*/
Method Pow( cN1 , cN2 ) Class TMathFloatStr
 Local cNRet := "0"//Futura Implementacao
Return( cNRet )

/*/
 Method:  __Pow
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Exponenciacao de Numeros em Ponto Flutuante
 Sintaxe: TMathFloatStr():__Pow( cN1 , cN2 ) -> cNRet
/*/
Method __Pow( cN1 , cN2 ) Class TMathFloatStr
 Local cNRet := "0"//Futura Implementacao
Return( cNRet )

/*/
 Method:  Divide
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Divisao de Numeros em Ponto Flutuante
 Sintaxe: TMathFloatStr():Divide( cN1 , cN2 ) -> cNRet
/*/
Method Divide( cN1 , cN2 ) Class TMathFloatStr

 Local cLN1   := cN1
 Local cLN2  := cN2

 Local cNRet
 Local cNRest
 Local cPFloat

 Local nPFloat := 0
 Local nN1PFloat := rAT( "." , cN1 )
 Local nN2PFloat := rAT( "." , cN2 )

 Local lPFloat := .F.

 IF ( nN1PFloat > 0 )
  nN1PFloat := Len( SubStr( cN1 , nN1PFloat + 1 ) )
  cN1   := StrTran( cN1 , "." , "" )
  lPFloat  := .T.
 EndIF

 IF ( nN2PFloat > 0 )
  nN2PFloat := Len( SubStr( cN2 , nN2PFloat + 1 ) )
  cN2   := StrTran( cN2 , "." , "" )
  IF ( nN2PFloat > nN1PFloat )
   cN1  += Replicate( "0" , nN2PFloat )
  EndIF
  lPFloat  := .T.
 ElseIF ( lPFloat )
  cN2   += Replicate( "0" , nN1PFloat )
 EndIF

 cNRet   := _Super:Divide( cN1 , cN2 , @cNRest )

 IF ( cNRest > "0" )
  lPFloat  := .F.
  cPFloat  := ""
  cNRest  := PadL( cNRest , Max( Len( cNRest )  , Len( cN2 ) ) , "0" )
  While ( cNRest < cN2 )
   cNRest += "0"
   cN2   := PadL( cN2 , Max( Len( cNRest )  , Len( cN2 ) ) , "0" )
   IF ( cNRest < cN2 )
    cPFloat += "0"
   EndIF
  End While
  While ( cNRest >= cN2 )
   cN1   := cNRest
   cPFloat  += _Super:Divide( cN1 , cN2 , @cNRest )
   nPFloat  := Len( cPFloat )
   IF (;
     ( cNRest == "0" );
     .or.;
     ( nPFloat >= Self:nDecimalPrecision );
    ) 
    Exit
   EndIF
   While ( SubStr( cN2 , 1 , 1 ) == "0" )
    cN2  := SubStr( cN2 , 2 )
   End While
   cNRest  := PadL( cNRest , Max( Len( cNRest )  , Len( cN2 ) ) , "0" )
   While ( cNRest < cN2 )
    cNRest += "0"
    cN2  := PadL( cN2 , Max( Len( cNRest )  , Len( cN2 ) ) , "0" )
    IF ( cNRest < cN2 )
     cPFloat += "0"
    EndIF
   End While
  End While
  While ( SubStr( cPFloat , -1 ) == "0" )
   cPFloat  := SubStr( cPFloat , 1 , --nPFloat )
  End While
  cNRet   += ( "."  + SubStr( cPFloat , 1 , Self:nDecimalPrecision ) )
 EndIF

 IF ( lPFloat )
  IF ( nPFloat > 0 )
   nPFloat := ( ( nPFloat + nN1PFloat ) - nN2PFloat )
  Else
   nPFloat := ( nN1PFloat - nN2PFloat )
   nPFloat := Max( 0 , nPFloat )
  EndIF
  lPFloat := ( nPFloat > 0 )
  IF ( lPFloat )
   cPFloat := SubStr( cNRet , -nPFloat )
   nPFloat := ( Len( cNRet ) - Len( cPFloat ) )
   cNRet := SubStr( cNRet , 1 , nPFloat )
   IF ( cPFloat > "0" )
    nPFloat := Min( nPFloat , Self:nDecimalPrecision )
    cNRet += ( "." + SubStr( cPFloat , 1 , nPFloat ) )
   EndIF
  EndIF
 EndIF

 cN1 := cLN1
 cN2 := cLN2

Return( cNRet )

/*/
 METHOD:  Mod
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Resto da Divisao Inteira
 Sintaxe: TMathIntegerStr():Mod( cN1 , cN2 ) -> cNRest
/*/
Method Mod( cN1 , cN2 ) Class TMathIntegerStr
 Local cNRest := "0"//Futura Implementacao
Return( cNRest )

/*/
 Method:  Add
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Soma de Numeros em Ponto Flutuante
 Sintaxe: TMathFloatStr():Add( cN1 , cN2 ) -> cNRet
/*/
Method Add( cN1 , cN2 ) Class TMathFloatStr

 Local cLN1   := cN1
 Local cLN2  := cN2

 Local cNRet
 Local cPFloat

 Local nPFloat
 Local nN1PFloat := rAT( "." , cN1 )
 Local nN2PFloat := rAT( "." , cN2 )

 Local lPFloat := .F.

 IF ( nN1PFloat > 0 )
  nN1PFloat := Len( SubStr( cN1 , nN1PFloat + 1 ) )
  cN1   := StrTran( cN1 , "." , "" )
  lPFloat  := .T.
 EndIF

 IF ( nN2PFloat > 0 )
  nN2PFloat := Len( SubStr( cN2 , nN2PFloat + 1 ) )
  cN2   := StrTran( cN2 , "." , "" )
  IF ( nN2PFloat > nN1PFloat )
   cN1  += Replicate( "0" , nN2PFloat )
  EndIF
  lPFloat  := .T.
 ElseIF ( lPFloat )
  cN2      += Replicate( "0" , nN1PFloat )
 EndIF

 cNRet   := _Super:Add( cN1 , cN2 )

 IF ( lPFloat )
  nPFloat := Max( nN1PFloat , nN2PFloat )
  cPFloat := SubStr( cNRet , -nPFloat )
  nPFloat := ( Len( cNRet ) - Len( cPFloat ) )
  cNRet := SubStr( cNRet , 1 , nPFloat )
  IF ( cPFloat > "0" )
   nPFloat := Min( nPFloat , Self:nDecimalPrecision )
   cNRet += ( "." + SubStr( cPFloat , 1 , nPFloat ) )
  EndIF 
 EndIF 

 cN1 := cLN1
 cN2 := cLN2

Return( cNRet ) 

/*/
 Method:  Subtract
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Subtracao de Numeros em Ponto Flutuante
 Sintaxe: TMathFloatStr():Subtract( cN1 , cN2 ) -> cNRet
/*/
Method Subtract( cN1 , cN2 ) Class TMathFloatStr

 Local cLN1   := cN1
 Local cLN2  := cN2

 Local cNRet
 Local cPFloat

 Local nPFloat
 Local nN1PFloat := rAT( "." , cN1 )
 Local nN2PFloat := rAT( "." , cN2 )

 Local lPFloat := .F.

 IF ( nN1PFloat > 0 )
  nN1PFloat := Len( SubStr( cN1 , nN1PFloat + 1 ) )
  cN1   := StrTran( cN1 , "." , "" )
  lPFloat  := .T.
 EndIF

 IF ( nN2PFloat > 0 )
  nN2PFloat := Len( SubStr( cN2 , nN2PFloat + 1 ) )
  cN2   := StrTran( cN2 , "." , "" )
  IF ( nN2PFloat > nN1PFloat )
   cN1  += Replicate( "0" , nN2PFloat )
  EndIF
  lPFloat  := .T.
 ElseIF ( lPFloat )
  cN2      += Replicate( "0" , nN1PFloat )
 EndIF

 cNRet   := _Super:Subtract( cN1 , cN2 )

 IF ( lPFloat )
  nPFloat := Max( nN1PFloat , nN2PFloat )
  cPFloat := SubStr( cNRet , -nPFloat )
  nPFloat := ( Len( cNRet ) - Len( cPFloat ) )
  cNRet := SubStr( cNRet , 1 , nPFloat )
  IF ( cPFloat > "0" )
   nPFloat := Min( nPFloat , Self:nDecimalPrecision )
   cNRet += ( "." + SubStr( cPFloat , 1 , nPFloat ) )
  EndIF 
 EndIF 

 cN1 := cLN1
 cN2 := cLN2

Return( cNRet )

/*/
 Method:  MathC
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Operacoes com Numeros Inteiros
 Sintaxe: TMathIntegerStr():MathC( cN1 , cOperator , cN2 ) -> cNRet
/*/
Method MathC( cN1 , cOperator , cN2 ) Class TMathFloatStr

 Local cNRet

 DO CASE
  CASE ( aScan( OPERATOR_ADD , { |cOp| cOperator == cOp } ) > 0 )
   cNRet := Self:Add( cN1 , cN2 )
  CASE ( aScan( OPERATOR_SUBTRACT , { |cOp| cOperator == cOp } ) > 0 )
   cNRet := Self:Subtract( cN1 , cN2 )
  CASE ( aScan( OPERATOR_MULTIPLY , { |cOp| cOperator == cOp } ) > 0 )
   cNRet := Self:Multiply( cN1 , cN2 )
  CASE ( aScan( OPERATOR_DIVIDE , { |cOp| cOperator == cOp } ) > 0 )
   cNRet := Self:Divide( cN1 , cN2 )
  CASE ( aScan( OPERATOR___POW  , { |cOp| cOperator == cOp } ) > 0 )
   cNRet := Self:__Pow( cN1 , cN2 )
  CASE ( aScan( OPERATOR_POW  , { |cOp| cOperator == cOp } ) > 0 )
   cNRet := Self:Pow( cN1 , cN2 )
  CASE ( aScan( OPERATOR_MOD  , { |cOp| cOperator == cOp } ) > 0 )
   cNRet := Self:Mod( cN1 , cN2 )
 OTHERWISE
  cNRet := "0"
 ENDCASE

Return( cNRet )

/*/
 Method:  SetDecimals
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Setar o Numero de Casas Decimais
 Sintaxe: TMathFloatStr():SetDecimals( nSet ) -> nLastSet
/*/
Method SetDecimals( nSet ) Class TMathFloatStr

 Local nLastSet := Self:nDecimalPrecision

 DEFAULT nSet := 32

 IF ( nSet > MAX_DECIMAL_PRECISION )
  nSet := MAX_DECIMAL_PRECISION
 EndIF

 Self:nDecimalPrecision := nSet

Return( nLastSet )

/*/
 Method:  e
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Retorna o Numero de Neper ( 2.7182818284590452353602874... )
 Sintaxe: TMathFloatStr():e( nDecimals , lForce ) -> cNRet
/*/
Method e( nDecimals , lForce ) Class TMathFloatStr

 Local cNRet := "2.7182818284590452353602874" //Vamos implementar o calculo

 Static __e
 
 BEGIN SEQUENCE

  DEFAULT lForce := .F.

  lForce   := IF( Empty( __e ) , .T. , lForce )

  IF !( lForce )
   BREAK
  EndIF 

  //...Aqui implementamos o calculo
  __e := cNRet

 END SEQUENCE
 
Return( cNRet )

/*/
 Method:  Exp
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Potencia do Numero de Neper e^cN
 Sintaxe: TMathFloatStr():Exp( cN ) -> cNRet
/*/
Method Exp( cN ) Class TMathFloatStr
 Local cNRet := "0"//Futura Implementacao
Return( cNRet )

/*/
 Method:  SQRT
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Retorna a Raiz Quadrada ( radix quadratum -> O Lado do Quadrado ) do Numero passado como parametro
 Sintaxe: TMathFloatStr():SQRT( cN ) -> cNRet
/*/
Method SQRT( cN ) Class TMathFloatStr
 Local cNRet := "0" //Futura Implementacao
Return( cNRet )

/*/
 Method:  Log
 Autor:  Marinaldo de Jesus
 Data:  01/06/2011
 Descricao: Retorna o logaritmo natural de um Numero.
 Sintaxe: TMathFloatStr():Log( cN ) -> cNRet
/*/
Method Log( cN ) Class TMathFloatStr
 cNRet := "0" //Futura Implementacao
Return( cNRet )
E um pequeno exemplo de uso. A saida das operações são direcionadas para o Console do Protheus. No exemplo tempos: U_TMathI() para operações com Números Inteiros e U_TMathF() para operação com Ponto Flutuante.

User Function TMathI()

 Local oTMathI := U_MathIntegerStr()

 ConOut( "Add : 1 + 1 = " + oTMathI:Add( "1" , "1" ) )
 ConOut( "Add : 12 + 12 = " + oTMathI:Add( "12" , "12" ) )
 ConOut( "Add : 123 + 123 = " + oTMathI:Add( "123" , "123" ) )
 ConOut( "Add : 1234 + 1234 = " + oTMathI:Add( "1234" , "1234" ) )
 ConOut( "Add : 12345 + 12345 = " + oTMathI:Add( "12345" , "12345" ) )
 ConOut( "Add : 123456 + 123456 = " + oTMathI:Add( "123456" , "123456" ) )
 ConOut( "Add : 1234567 + 1234567 = " + oTMathI:Add( "1234567" , "1234567" ) )
 ConOut( "Add : 12345678 + 12345678 = " + oTMathI:Add( "12345678" , "12345678" ) )
 ConOut( "Add : 123456789 + 123456789 = " + oTMathI:Add( "123456789" , "123456789" ) )
 ConOut( "Add : 123456789123456789 + 123456789123456789 = " + oTMathI:Add( "123456789123456789" , "123456789123456789" ) )
 ConOut( "Add : 123456789123456789123456789123456789 + 123456789123456789123456789123456789 = " + oTMathI:Add( "123456789123456789123456789123456789" , "123456789123456789123456789123456789" ) )
 ConOut( "Add : 123456789123456789123456789123456789123456789123456789123456789123456789 + 123456789123456789123456789123456789123456789123456789123456789123456789 =  " + oTMathI:Add( "123456789123456789123456789123456789123456789123456789123456789123456789" , "123456789123456789123456789123456789123456789123456789123456789123456789" ) )

 ConOut( "Subtract : 10 - 10 = " + oTMathI:Subtract( "10" , "10" ) )
 ConOut( "Subtract : 10 - 9 = " + oTMathI:Subtract( "10" , "9" ) )
 ConOut( "Subtract : 10 - 8 = " + oTMathI:Subtract( "10" , "8" ) )
 ConOut( "Subtract : 10 - 7 = " + oTMathI:Subtract( "10" , "7" ) )
 ConOut( "Subtract : 10 - 6 = " + oTMathI:Subtract( "10" , "6" ) )
 ConOut( "Subtract : 10 - 5 = " + oTMathI:Subtract( "10" , "5" ) )
 ConOut( "Subtract : 10 - 4 = " + oTMathI:Subtract( "10" , "4" ) )
 ConOut( "Subtract : 10 - 3 = " + oTMathI:Subtract( "10" , "3" ) )
 ConOut( "Subtract : 10 - 2 = " + oTMathI:Subtract( "10" , "2" ) )
 ConOut( "Subtract : 10 - 1 = " + oTMathI:Subtract( "10" , "1" ) )
 ConOut( "Subtract : 10 - 0 = " + oTMathI:Subtract( "10" , "0" ) )

 ConOut( "Subtract : 123456789123456789123456789123456789123456789123456789123456789123456789 - 123456789123456789123456789123456789123456789123456789123456789123456789 =  " - oTMathI:Subtract( "123456789123456789123456789123456789123456789123456789123456789123456789" , "123456789123456789123456789123456789123456789123456789123456789123456789" ) )
 ConOut( "Subtract : 123456789123456789123456789123456789 - 123456789123456789123456789123456789 = " + oTMathI:Subtract( "123456789123456789123456789123456789" , "123456789123456789123456789123456789" ) )
 ConOut( "Subtract : 123456789123456789 - 123456789123456789 = " + oTMathI:Subtract( "123456789123456789" , "123456789123456789" ) )

 ConOut( "Subtract : 123456789123456789123456789123456789123456789123456789123456789123456789 - 123456789123456789123456789123456789 =  " - oTMathI:Subtract( "123456789123456789123456789123456789123456789123456789123456789123456789" , "123456789123456789123456789123456789" ) )
 ConOut( "Subtract : 123456789123456789123456789123456789 - 123456789123456789 = " + oTMathI:Subtract( "123456789123456789123456789123456789" , "123456789123456789" ) )
 ConOut( "Subtract : 123456789123456789 - 123456789 = " + oTMathI:Subtract( "123456789123456789" , "123456789" ) )

 ConOut( "Multiply : 10 * 10 = " + oTMathI:Multiply( "10" , "10" ) )
 ConOut( "Multiply : 10 * 9 = " + oTMathI:Multiply( "10" , "9" ) )
 ConOut( "Multiply : 10 * 8 = " + oTMathI:Multiply( "10" , "8" ) )
 ConOut( "Multiply : 10 * 7 = " + oTMathI:Multiply( "10" , "7" ) )
 ConOut( "Multiply : 10 * 6 = " + oTMathI:Multiply( "10" , "6" ) )
 ConOut( "Multiply : 10 * 5 = " + oTMathI:Multiply( "10" , "5" ) )
 ConOut( "Multiply : 10 * 4 = " + oTMathI:Multiply( "10" , "4" ) )
 ConOut( "Multiply : 10 * 3 = " + oTMathI:Multiply( "10" , "3" ) )
 ConOut( "Multiply : 10 * 2 = " + oTMathI:Multiply( "10" , "2" ) )
 ConOut( "Multiply : 10 * 1 = " + oTMathI:Multiply( "10" , "1" ) )
 ConOut( "Multiply : 10 * 0 = " + oTMathI:Multiply( "10" , "0" ) )

 ConOut( "Multiply : 123456789123456789123456789123456789123456789123456789123456789123456789 * 123456789123456789123456789123456789123456789123456789123456789123456789 =  " + oTMathI:Multiply( "123456789123456789123456789123456789123456789123456789123456789123456789" , "123456789123456789123456789123456789123456789123456789123456789123456789" ) )
 ConOut( "Multiply : 123456789123456789123456789123456789 * 123456789123456789123456789123456789 = " + oTMathI:Multiply( "123456789123456789123456789123456789" , "123456789123456789123456789123456789" ) )
 ConOut( "Multiply : 123456789123456789 * 123456789123456789 = " + oTMathI:Multiply( "123456789123456789" , "123456789123456789" ) )

 ConOut( "Multiply : 123456789123456789123456789123456789123456789123456789123456789123456789 * 123456789123456789123456789123456789 =  " + oTMathI:Multiply( "123456789123456789123456789123456789123456789123456789123456789123456789" , "123456789123456789123456789123456789" ) )
 ConOut( "Multiply : 123456789123456789123456789123456789 * 123456789123456789 = " + oTMathI:Multiply( "123456789123456789123456789123456789" , "123456789123456789" ) )
 ConOut( "Multiply : 123456789123456789 * 123456789 = " + oTMathI:Multiply( "123456789123456789" , "123456789" ) )

 ConOut( "Divide : 10 / 10 = " + oTMathI:Divide( "10" , "10" ) )
 ConOut( "Divide : 10 / 9 = " + oTMathI:Divide( "10" , "9" ) )
 ConOut( "Divide : 10 / 8 = " + oTMathI:Divide( "10" , "8" ) )
 ConOut( "Divide : 10 / 7 = " + oTMathI:Divide( "10" , "7" ) )
 ConOut( "Divide : 10 / 6 = " + oTMathI:Divide( "10" , "6" ) )
 ConOut( "Divide : 10 / 5 = " + oTMathI:Divide( "10" , "5" ) )
 ConOut( "Divide : 10 / 4 = " + oTMathI:Divide( "10" , "4" ) )
 ConOut( "Divide : 10 / 3 = " + oTMathI:Divide( "10" , "3" ) )
 ConOut( "Divide : 10 / 2 = " + oTMathI:Divide( "10" , "2" ) )
 ConOut( "Divide : 10 / 1 = " + oTMathI:Divide( "10" , "1" ) )
 ConOut( "Divide : 10 / 0 = " + oTMathI:Divide( "10" , "0" ) )
 
 ConOut( "Divide : 100 / 90 = " + oTMathI:Divide( "100" , "90" ) )
 ConOut( "Divide : 100 / 80 = " + oTMathI:Divide( "100" , "80" ) )
 ConOut( "Divide : 100 / 70 = " + oTMathI:Divide( "100" , "70" ) )
 ConOut( "Divide : 100 / 60 = " + oTMathI:Divide( "100" , "60" ) )
 ConOut( "Divide : 100 / 50 = " + oTMathI:Divide( "100" , "50" ) )
 ConOut( "Divide : 100 / 40 = " + oTMathI:Divide( "100" , "40" ) )
 ConOut( "Divide : 100 / 30 = " + oTMathI:Divide( "100" , "30" ) )
 ConOut( "Divide : 100 / 20 = " + oTMathI:Divide( "100" , "20" ) )

 ConOut( "Divide : 100 / 95 = " + oTMathI:Divide( "100" , "95" ) )
 ConOut( "Divide : 100 / 85 = " + oTMathI:Divide( "100" , "85" ) )
 ConOut( "Divide : 100 / 75 = " + oTMathI:Divide( "100" , "75" ) )
 ConOut( "Divide : 100 / 65 = " + oTMathI:Divide( "100" , "65" ) )
 ConOut( "Divide : 100 / 55 = " + oTMathI:Divide( "100" , "55" ) )
 ConOut( "Divide : 100 / 45 = " + oTMathI:Divide( "100" , "45" ) )
 ConOut( "Divide : 100 / 35 = " + oTMathI:Divide( "100" , "35" ) )
 ConOut( "Divide : 100 / 25 = " + oTMathI:Divide( "100" , "25" ) )
 ConOut( "Divide : 100 / 15 = " + oTMathI:Divide( "100" , "15" ) )
 ConOut( "Divide : 100 / 14 = " + oTMathI:Divide( "100" , "14" ) )
 ConOut( "Divide : 100 / 13 = " + oTMathI:Divide( "100" , "13" ) )
 ConOut( "Divide : 100 / 12 = " + oTMathI:Divide( "100" , "12" ) )
 ConOut( "Divide : 100 / 11 = " + oTMathI:Divide( "100" , "11" ) )
 ConOut( "Divide : 100 / 10 = " + oTMathI:Divide( "100" , "10" ) )
 ConOut( "Divide : 100 / 08 = " + oTMathI:Divide( "100" , "08" ) )
 ConOut( "Divide : 100 / 07 = " + oTMathI:Divide( "100" , "07" ) )
 ConOut( "Divide : 100 / 06 = " + oTMathI:Divide( "100" , "06" ) )
 ConOut( "Divide : 100 / 05 = " + oTMathI:Divide( "100" , "05" ) )
 ConOut( "Divide : 100 / 04 = " + oTMathI:Divide( "100" , "04" ) )
 ConOut( "Divide : 100 / 03 = " + oTMathI:Divide( "100" , "03" ) )
 ConOut( "Divide : 100 / 02 = " + oTMathI:Divide( "100" , "02" ) )
 ConOut( "Divide : 100 / 01 = " + oTMathI:Divide( "100" , "01" ) )

 ConOut( "Divide : 1000 / 95 = " + oTMathI:Divide( "1000" , "95" ) )
 ConOut( "Divide : 1000 / 85 = " + oTMathI:Divide( "1000" , "85" ) )
 ConOut( "Divide : 1000 / 75 = " + oTMathI:Divide( "1000" , "75" ) )
 ConOut( "Divide : 1000 / 65 = " + oTMathI:Divide( "1000" , "65" ) )
 ConOut( "Divide : 1000 / 55 = " + oTMathI:Divide( "1000" , "55" ) )
 ConOut( "Divide : 1000 / 45 = " + oTMathI:Divide( "1000" , "45" ) )
 ConOut( "Divide : 1000 / 35 = " + oTMathI:Divide( "1000" , "35" ) )
 ConOut( "Divide : 1000 / 25 = " + oTMathI:Divide( "1000" , "25" ) )
 ConOut( "Divide : 1000 / 15 = " + oTMathI:Divide( "1000" , "15" ) )
 ConOut( "Divide : 1000 / 14 = " + oTMathI:Divide( "1000" , "14" ) )
 ConOut( "Divide : 1000 / 13 = " + oTMathI:Divide( "1000" , "13" ) )
 ConOut( "Divide : 1000 / 12 = " + oTMathI:Divide( "1000" , "12" ) )
 ConOut( "Divide : 1000 / 11 = " + oTMathI:Divide( "1000" , "11" ) )
 ConOut( "Divide : 1000 / 10 = " + oTMathI:Divide( "1000" , "10" ) )
 ConOut( "Divide : 1000 / 08 = " + oTMathI:Divide( "1000" , "08" ) )
 ConOut( "Divide : 1000 / 07 = " + oTMathI:Divide( "1000" , "07" ) )
 ConOut( "Divide : 1000 / 06 = " + oTMathI:Divide( "1000" , "06" ) )
 ConOut( "Divide : 1000 / 05 = " + oTMathI:Divide( "1000" , "05" ) )
 ConOut( "Divide : 1000 / 04 = " + oTMathI:Divide( "1000" , "04" ) )
 ConOut( "Divide : 1000 / 03 = " + oTMathI:Divide( "1000" , "03" ) )
 ConOut( "Divide : 1000 / 02 = " + oTMathI:Divide( "1000" , "02" ) )
 ConOut( "Divide : 1000 / 01 = " + oTMathI:Divide( "1000" , "01" ) )

 ConOut( "Divide : 10000 / 95 = " + oTMathI:Divide( "10000" , "95" ) )
 ConOut( "Divide : 10000 / 85 = " + oTMathI:Divide( "10000" , "85" ) )
 ConOut( "Divide : 10000 / 75 = " + oTMathI:Divide( "10000" , "75" ) )
 ConOut( "Divide : 10000 / 65 = " + oTMathI:Divide( "10000" , "65" ) )
 ConOut( "Divide : 10000 / 55 = " + oTMathI:Divide( "10000" , "55" ) )
 ConOut( "Divide : 10000 / 45 = " + oTMathI:Divide( "10000" , "45" ) )
 ConOut( "Divide : 10000 / 35 = " + oTMathI:Divide( "10000" , "35" ) )
 ConOut( "Divide : 10000 / 25 = " + oTMathI:Divide( "10000" , "25" ) )
 ConOut( "Divide : 10000 / 15 = " + oTMathI:Divide( "10000" , "15" ) )
 ConOut( "Divide : 10000 / 14 = " + oTMathI:Divide( "10000" , "14" ) )
 ConOut( "Divide : 10000 / 13 = " + oTMathI:Divide( "10000" , "13" ) )
 ConOut( "Divide : 10000 / 12 = " + oTMathI:Divide( "10000" , "12" ) )
 ConOut( "Divide : 10000 / 11 = " + oTMathI:Divide( "10000" , "11" ) )
 ConOut( "Divide : 10000 / 10 = " + oTMathI:Divide( "10000" , "10" ) )
 ConOut( "Divide : 10000 / 08 = " + oTMathI:Divide( "10000" , "08" ) )
 ConOut( "Divide : 10000 / 07 = " + oTMathI:Divide( "10000" , "07" ) )
 ConOut( "Divide : 10000 / 06 = " + oTMathI:Divide( "10000" , "06" ) )
 ConOut( "Divide : 10000 / 05 = " + oTMathI:Divide( "10000" , "05" ) )
 ConOut( "Divide : 10000 / 04 = " + oTMathI:Divide( "10000" , "04" ) )
 ConOut( "Divide : 10000 / 03 = " + oTMathI:Divide( "10000" , "03" ) )
 ConOut( "Divide : 10000 / 02 = " + oTMathI:Divide( "10000" , "02" ) )
 ConOut( "Divide : 10000 / 01 = " + oTMathI:Divide( "10000" , "01" ) )

 ConOut( "Divide : 100000 / 95 = " + oTMathI:Divide( "100000" , "95" ) )
 ConOut( "Divide : 100000 / 85 = " + oTMathI:Divide( "100000" , "85" ) )
 ConOut( "Divide : 100000 / 75 = " + oTMathI:Divide( "100000" , "75" ) )
 ConOut( "Divide : 100000 / 65 = " + oTMathI:Divide( "100000" , "65" ) )
 ConOut( "Divide : 100000 / 55 = " + oTMathI:Divide( "100000" , "55" ) )
 ConOut( "Divide : 100000 / 45 = " + oTMathI:Divide( "100000" , "45" ) )
 ConOut( "Divide : 100000 / 35 = " + oTMathI:Divide( "100000" , "35" ) )
 ConOut( "Divide : 100000 / 25 = " + oTMathI:Divide( "100000" , "25" ) )
 ConOut( "Divide : 100000 / 15 = " + oTMathI:Divide( "100000" , "15" ) )
 ConOut( "Divide : 100000 / 14 = " + oTMathI:Divide( "100000" , "14" ) )
 ConOut( "Divide : 100000 / 13 = " + oTMathI:Divide( "100000" , "13" ) )
 ConOut( "Divide : 100000 / 12 = " + oTMathI:Divide( "100000" , "12" ) )
 ConOut( "Divide : 100000 / 11 = " + oTMathI:Divide( "100000" , "11" ) )
 ConOut( "Divide : 100000 / 10 = " + oTMathI:Divide( "100000" , "10" ) )
 ConOut( "Divide : 100000 / 08 = " + oTMathI:Divide( "100000" , "08" ) )
 ConOut( "Divide : 100000 / 07 = " + oTMathI:Divide( "100000" , "07" ) )
 ConOut( "Divide : 100000 / 06 = " + oTMathI:Divide( "100000" , "06" ) )
 ConOut( "Divide : 100000 / 05 = " + oTMathI:Divide( "100000" , "05" ) )
 ConOut( "Divide : 100000 / 04 = " + oTMathI:Divide( "100000" , "04" ) )
 ConOut( "Divide : 100000 / 03 = " + oTMathI:Divide( "100000" , "03" ) )
 ConOut( "Divide : 100000 / 02 = " + oTMathI:Divide( "100000" , "02" ) )
 ConOut( "Divide : 100000 / 01 = " + oTMathI:Divide( "100000" , "01" ) )

 ConOut( "Divide : 1000000 / 95 = " + oTMathI:Divide( "1000000" , "95" ) )
 ConOut( "Divide : 1000000 / 85 = " + oTMathI:Divide( "1000000" , "85" ) )
 ConOut( "Divide : 1000000 / 75 = " + oTMathI:Divide( "1000000" , "75" ) )
 ConOut( "Divide : 1000000 / 65 = " + oTMathI:Divide( "1000000" , "65" ) )
 ConOut( "Divide : 1000000 / 55 = " + oTMathI:Divide( "1000000" , "55" ) )
 ConOut( "Divide : 1000000 / 45 = " + oTMathI:Divide( "1000000" , "45" ) )
 ConOut( "Divide : 1000000 / 35 = " + oTMathI:Divide( "1000000" , "35" ) )
 ConOut( "Divide : 1000000 / 25 = " + oTMathI:Divide( "1000000" , "25" ) )
 ConOut( "Divide : 1000000 / 15 = " + oTMathI:Divide( "1000000" , "15" ) )
 ConOut( "Divide : 1000000 / 14 = " + oTMathI:Divide( "1000000" , "14" ) )
 ConOut( "Divide : 1000000 / 13 = " + oTMathI:Divide( "1000000" , "13" ) )
 ConOut( "Divide : 1000000 / 12 = " + oTMathI:Divide( "1000000" , "12" ) )
 ConOut( "Divide : 1000000 / 11 = " + oTMathI:Divide( "1000000" , "11" ) )
 ConOut( "Divide : 1000000 / 10 = " + oTMathI:Divide( "1000000" , "10" ) )
 ConOut( "Divide : 1000000 / 08 = " + oTMathI:Divide( "1000000" , "08" ) )
 ConOut( "Divide : 1000000 / 07 = " + oTMathI:Divide( "1000000" , "07" ) )
 ConOut( "Divide : 1000000 / 06 = " + oTMathI:Divide( "1000000" , "06" ) )
 ConOut( "Divide : 1000000 / 05 = " + oTMathI:Divide( "1000000" , "05" ) )
 ConOut( "Divide : 1000000 / 04 = " + oTMathI:Divide( "1000000" , "04" ) )
 ConOut( "Divide : 1000000 / 03 = " + oTMathI:Divide( "1000000" , "03" ) )
 ConOut( "Divide : 1000000 / 02 = " + oTMathI:Divide( "1000000" , "02" ) )
 ConOut( "Divide : 1000000 / 01 = " + oTMathI:Divide( "1000000" , "01" ) )

 ConOut( "Divide : 10000000 / 95 = " + oTMathI:Divide( "10000000" , "95" ) )
 ConOut( "Divide : 10000000 / 85 = " + oTMathI:Divide( "10000000" , "85" ) )
 ConOut( "Divide : 10000000 / 75 = " + oTMathI:Divide( "10000000" , "75" ) )
 ConOut( "Divide : 10000000 / 65 = " + oTMathI:Divide( "10000000" , "65" ) )
 ConOut( "Divide : 10000000 / 55 = " + oTMathI:Divide( "10000000" , "55" ) )
 ConOut( "Divide : 10000000 / 45 = " + oTMathI:Divide( "10000000" , "45" ) )
 ConOut( "Divide : 10000000 / 35 = " + oTMathI:Divide( "10000000" , "35" ) )
 ConOut( "Divide : 10000000 / 25 = " + oTMathI:Divide( "10000000" , "25" ) )
 ConOut( "Divide : 10000000 / 15 = " + oTMathI:Divide( "10000000" , "15" ) )
 ConOut( "Divide : 10000000 / 14 = " + oTMathI:Divide( "10000000" , "14" ) )
 ConOut( "Divide : 10000000 / 13 = " + oTMathI:Divide( "10000000" , "13" ) )
 ConOut( "Divide : 10000000 / 12 = " + oTMathI:Divide( "10000000" , "12" ) )
 ConOut( "Divide : 10000000 / 11 = " + oTMathI:Divide( "10000000" , "11" ) )
 ConOut( "Divide : 10000000 / 10 = " + oTMathI:Divide( "10000000" , "10" ) )
 ConOut( "Divide : 10000000 / 08 = " + oTMathI:Divide( "10000000" , "08" ) )
 ConOut( "Divide : 10000000 / 07 = " + oTMathI:Divide( "10000000" , "07" ) )
 ConOut( "Divide : 10000000 / 06 = " + oTMathI:Divide( "10000000" , "06" ) )
 ConOut( "Divide : 10000000 / 05 = " + oTMathI:Divide( "10000000" , "05" ) )
 ConOut( "Divide : 10000000 / 04 = " + oTMathI:Divide( "10000000" , "04" ) )
 ConOut( "Divide : 10000000 / 03 = " + oTMathI:Divide( "10000000" , "03" ) )
 ConOut( "Divide : 10000000 / 02 = " + oTMathI:Divide( "10000000" , "02" ) )
 ConOut( "Divide : 10000000 / 01 = " + oTMathI:Divide( "10000000" , "01" ) )

 ConOut( "Divide : 100000000 / 95 = " + oTMathI:Divide( "100000000" , "95" ) )
 ConOut( "Divide : 100000000 / 85 = " + oTMathI:Divide( "100000000" , "85" ) )
 ConOut( "Divide : 100000000 / 75 = " + oTMathI:Divide( "100000000" , "75" ) )
 ConOut( "Divide : 100000000 / 65 = " + oTMathI:Divide( "100000000" , "65" ) )
 ConOut( "Divide : 100000000 / 55 = " + oTMathI:Divide( "100000000" , "55" ) )
 ConOut( "Divide : 100000000 / 45 = " + oTMathI:Divide( "100000000" , "45" ) )
 ConOut( "Divide : 100000000 / 35 = " + oTMathI:Divide( "100000000" , "35" ) )
 ConOut( "Divide : 100000000 / 25 = " + oTMathI:Divide( "100000000" , "25" ) )
 ConOut( "Divide : 100000000 / 15 = " + oTMathI:Divide( "100000000" , "15" ) )
 ConOut( "Divide : 100000000 / 14 = " + oTMathI:Divide( "100000000" , "14" ) )
 ConOut( "Divide : 100000000 / 13 = " + oTMathI:Divide( "100000000" , "13" ) )
 ConOut( "Divide : 100000000 / 12 = " + oTMathI:Divide( "100000000" , "12" ) )
 ConOut( "Divide : 100000000 / 11 = " + oTMathI:Divide( "100000000" , "11" ) )
 ConOut( "Divide : 100000000 / 10 = " + oTMathI:Divide( "100000000" , "10" ) )
 ConOut( "Divide : 100000000 / 08 = " + oTMathI:Divide( "100000000" , "08" ) )
 ConOut( "Divide : 100000000 / 07 = " + oTMathI:Divide( "100000000" , "07" ) )
 ConOut( "Divide : 100000000 / 06 = " + oTMathI:Divide( "100000000" , "06" ) )
 ConOut( "Divide : 100000000 / 05 = " + oTMathI:Divide( "100000000" , "05" ) )
 ConOut( "Divide : 100000000 / 04 = " + oTMathI:Divide( "100000000" , "04" ) )
 ConOut( "Divide : 100000000 / 03 = " + oTMathI:Divide( "100000000" , "03" ) )
 ConOut( "Divide : 100000000 / 02 = " + oTMathI:Divide( "100000000" , "02" ) )
 ConOut( "Divide : 100000000 / 01 = " + oTMathI:Divide( "100000000" , "01" ) )

 ConOut( "Divide : 1000000000 / 95 = " + oTMathI:Divide( "1000000000" , "95" ) )
 ConOut( "Divide : 1000000000 / 85 = " + oTMathI:Divide( "1000000000" , "85" ) )
 ConOut( "Divide : 1000000000 / 75 = " + oTMathI:Divide( "1000000000" , "75" ) )
 ConOut( "Divide : 1000000000 / 65 = " + oTMathI:Divide( "1000000000" , "65" ) )
 ConOut( "Divide : 1000000000 / 55 = " + oTMathI:Divide( "1000000000" , "55" ) )
 ConOut( "Divide : 1000000000 / 45 = " + oTMathI:Divide( "1000000000" , "45" ) )
 ConOut( "Divide : 1000000000 / 35 = " + oTMathI:Divide( "1000000000" , "35" ) )
 ConOut( "Divide : 1000000000 / 25 = " + oTMathI:Divide( "1000000000" , "25" ) )
 ConOut( "Divide : 1000000000 / 15 = " + oTMathI:Divide( "1000000000" , "15" ) )
 ConOut( "Divide : 1000000000 / 14 = " + oTMathI:Divide( "1000000000" , "14" ) )
 ConOut( "Divide : 1000000000 / 13 = " + oTMathI:Divide( "1000000000" , "13" ) )
 ConOut( "Divide : 1000000000 / 12 = " + oTMathI:Divide( "1000000000" , "12" ) )
 ConOut( "Divide : 1000000000 / 11 = " + oTMathI:Divide( "1000000000" , "11" ) )
 ConOut( "Divide : 1000000000 / 10 = " + oTMathI:Divide( "1000000000" , "10" ) )
 ConOut( "Divide : 1000000000 / 08 = " + oTMathI:Divide( "1000000000" , "08" ) )
 ConOut( "Divide : 1000000000 / 07 = " + oTMathI:Divide( "1000000000" , "07" ) )
 ConOut( "Divide : 1000000000 / 06 = " + oTMathI:Divide( "1000000000" , "06" ) )
 ConOut( "Divide : 1000000000 / 05 = " + oTMathI:Divide( "1000000000" , "05" ) )
 ConOut( "Divide : 1000000000 / 04 = " + oTMathI:Divide( "1000000000" , "04" ) )
 ConOut( "Divide : 1000000000 / 03 = " + oTMathI:Divide( "1000000000" , "03" ) )
 ConOut( "Divide : 1000000000 / 02 = " + oTMathI:Divide( "1000000000" , "02" ) )
 ConOut( "Divide : 1000000000 / 01 = " + oTMathI:Divide( "1000000000" , "01" ) )

 ConOut( "Divide : 10000000000 / 95 = " + oTMathI:Divide( "10000000000" , "95" ) )
 ConOut( "Divide : 10000000000 / 85 = " + oTMathI:Divide( "10000000000" , "85" ) )
 ConOut( "Divide : 10000000000 / 75 = " + oTMathI:Divide( "10000000000" , "75" ) )
 ConOut( "Divide : 10000000000 / 65 = " + oTMathI:Divide( "10000000000" , "65" ) )
 ConOut( "Divide : 10000000000 / 55 = " + oTMathI:Divide( "10000000000" , "55" ) )
 ConOut( "Divide : 10000000000 / 45 = " + oTMathI:Divide( "10000000000" , "45" ) )
 ConOut( "Divide : 10000000000 / 35 = " + oTMathI:Divide( "10000000000" , "35" ) )
 ConOut( "Divide : 10000000000 / 25 = " + oTMathI:Divide( "10000000000" , "25" ) )
 ConOut( "Divide : 10000000000 / 15 = " + oTMathI:Divide( "10000000000" , "15" ) )
 ConOut( "Divide : 10000000000 / 14 = " + oTMathI:Divide( "10000000000" , "14" ) )
 ConOut( "Divide : 10000000000 / 13 = " + oTMathI:Divide( "10000000000" , "13" ) )
 ConOut( "Divide : 10000000000 / 12 = " + oTMathI:Divide( "10000000000" , "12" ) )
 ConOut( "Divide : 10000000000 / 11 = " + oTMathI:Divide( "10000000000" , "11" ) )
 ConOut( "Divide : 10000000000 / 10 = " + oTMathI:Divide( "10000000000" , "10" ) )
 ConOut( "Divide : 10000000000 / 08 = " + oTMathI:Divide( "10000000000" , "08" ) )
 ConOut( "Divide : 10000000000 / 07 = " + oTMathI:Divide( "10000000000" , "07" ) )
 ConOut( "Divide : 10000000000 / 06 = " + oTMathI:Divide( "10000000000" , "06" ) )
 ConOut( "Divide : 10000000000 / 05 = " + oTMathI:Divide( "10000000000" , "05" ) )
 ConOut( "Divide : 10000000000 / 04 = " + oTMathI:Divide( "10000000000" , "04" ) )
 ConOut( "Divide : 10000000000 / 03 = " + oTMathI:Divide( "10000000000" , "03" ) )
 ConOut( "Divide : 10000000000 / 02 = " + oTMathI:Divide( "10000000000" , "02" ) )
 ConOut( "Divide : 10000000000 / 01 = " + oTMathI:Divide( "10000000000" , "01" ) )

 ConOut( "Divide : 100000000000 / 95 = " + oTMathI:Divide( "100000000000" , "95" ) )
 ConOut( "Divide : 100000000000 / 85 = " + oTMathI:Divide( "100000000000" , "85" ) )
 ConOut( "Divide : 100000000000 / 75 = " + oTMathI:Divide( "100000000000" , "75" ) )
 ConOut( "Divide : 100000000000 / 65 = " + oTMathI:Divide( "100000000000" , "65" ) )
 ConOut( "Divide : 100000000000 / 55 = " + oTMathI:Divide( "100000000000" , "55" ) )
 ConOut( "Divide : 100000000000 / 45 = " + oTMathI:Divide( "100000000000" , "45" ) )
 ConOut( "Divide : 100000000000 / 35 = " + oTMathI:Divide( "100000000000" , "35" ) )
 ConOut( "Divide : 100000000000 / 25 = " + oTMathI:Divide( "100000000000" , "25" ) )
 ConOut( "Divide : 100000000000 / 15 = " + oTMathI:Divide( "100000000000" , "15" ) )
 ConOut( "Divide : 100000000000 / 14 = " + oTMathI:Divide( "100000000000" , "14" ) )
 ConOut( "Divide : 100000000000 / 13 = " + oTMathI:Divide( "100000000000" , "13" ) )
 ConOut( "Divide : 100000000000 / 12 = " + oTMathI:Divide( "100000000000" , "12" ) )
 ConOut( "Divide : 100000000000 / 11 = " + oTMathI:Divide( "100000000000" , "11" ) )
 ConOut( "Divide : 100000000000 / 10 = " + oTMathI:Divide( "100000000000" , "10" ) )
 ConOut( "Divide : 100000000000 / 08 = " + oTMathI:Divide( "100000000000" , "08" ) )
 ConOut( "Divide : 100000000000 / 07 = " + oTMathI:Divide( "100000000000" , "07" ) )
 ConOut( "Divide : 100000000000 / 06 = " + oTMathI:Divide( "100000000000" , "06" ) )
 ConOut( "Divide : 100000000000 / 05 = " + oTMathI:Divide( "100000000000" , "05" ) )
 ConOut( "Divide : 100000000000 / 04 = " + oTMathI:Divide( "100000000000" , "04" ) )
 ConOut( "Divide : 100000000000 / 03 = " + oTMathI:Divide( "100000000000" , "03" ) )
 ConOut( "Divide : 100000000000 / 02 = " + oTMathI:Divide( "100000000000" , "02" ) )
 ConOut( "Divide : 100000000000 / 01 = " + oTMathI:Divide( "100000000000" , "01" ) )

 ConOut( "Divide : 1000000000000 / 95 = " + oTMathI:Divide( "1000000000000" , "95" ) )
 ConOut( "Divide : 1000000000000 / 85 = " + oTMathI:Divide( "1000000000000" , "85" ) )
 ConOut( "Divide : 1000000000000 / 75 = " + oTMathI:Divide( "1000000000000" , "75" ) )
 ConOut( "Divide : 1000000000000 / 65 = " + oTMathI:Divide( "1000000000000" , "65" ) )
 ConOut( "Divide : 1000000000000 / 55 = " + oTMathI:Divide( "1000000000000" , "55" ) )
 ConOut( "Divide : 1000000000000 / 45 = " + oTMathI:Divide( "1000000000000" , "45" ) )
 ConOut( "Divide : 1000000000000 / 35 = " + oTMathI:Divide( "1000000000000" , "35" ) )
 ConOut( "Divide : 1000000000000 / 25 = " + oTMathI:Divide( "1000000000000" , "25" ) )
 ConOut( "Divide : 1000000000000 / 15 = " + oTMathI:Divide( "1000000000000" , "15" ) )
 ConOut( "Divide : 1000000000000 / 14 = " + oTMathI:Divide( "1000000000000" , "14" ) )
 ConOut( "Divide : 1000000000000 / 13 = " + oTMathI:Divide( "1000000000000" , "13" ) )
 ConOut( "Divide : 1000000000000 / 12 = " + oTMathI:Divide( "1000000000000" , "12" ) )
 ConOut( "Divide : 1000000000000 / 11 = " + oTMathI:Divide( "1000000000000" , "11" ) )
 ConOut( "Divide : 1000000000000 / 10 = " + oTMathI:Divide( "1000000000000" , "10" ) )
 ConOut( "Divide : 1000000000000 / 08 = " + oTMathI:Divide( "1000000000000" , "08" ) )
 ConOut( "Divide : 1000000000000 / 07 = " + oTMathI:Divide( "1000000000000" , "07" ) )
 ConOut( "Divide : 1000000000000 / 06 = " + oTMathI:Divide( "1000000000000" , "06" ) )
 ConOut( "Divide : 1000000000000 / 05 = " + oTMathI:Divide( "1000000000000" , "05" ) )
 ConOut( "Divide : 1000000000000 / 04 = " + oTMathI:Divide( "1000000000000" , "04" ) )
 ConOut( "Divide : 1000000000000 / 03 = " + oTMathI:Divide( "1000000000000" , "03" ) )
 ConOut( "Divide : 1000000000000 / 02 = " + oTMathI:Divide( "1000000000000" , "02" ) )
 ConOut( "Divide : 1000000000000 / 01 = " + oTMathI:Divide( "1000000000000" , "01" ) )

 ConOut( "Divide : 10000000000000 / 95 = " + oTMathI:Divide( "10000000000000" , "95" ) )
 ConOut( "Divide : 10000000000000 / 85 = " + oTMathI:Divide( "10000000000000" , "85" ) )
 ConOut( "Divide : 10000000000000 / 75 = " + oTMathI:Divide( "10000000000000" , "75" ) )
 ConOut( "Divide : 10000000000000 / 65 = " + oTMathI:Divide( "10000000000000" , "65" ) )
 ConOut( "Divide : 10000000000000 / 55 = " + oTMathI:Divide( "10000000000000" , "55" ) )
 ConOut( "Divide : 10000000000000 / 45 = " + oTMathI:Divide( "10000000000000" , "45" ) )
 ConOut( "Divide : 10000000000000 / 35 = " + oTMathI:Divide( "10000000000000" , "35" ) )
 ConOut( "Divide : 10000000000000 / 25 = " + oTMathI:Divide( "10000000000000" , "25" ) )
 ConOut( "Divide : 10000000000000 / 15 = " + oTMathI:Divide( "10000000000000" , "15" ) )
 ConOut( "Divide : 10000000000000 / 14 = " + oTMathI:Divide( "10000000000000" , "14" ) )
 ConOut( "Divide : 10000000000000 / 13 = " + oTMathI:Divide( "10000000000000" , "13" ) )
 ConOut( "Divide : 10000000000000 / 12 = " + oTMathI:Divide( "10000000000000" , "12" ) )
 ConOut( "Divide : 10000000000000 / 11 = " + oTMathI:Divide( "10000000000000" , "11" ) )
 ConOut( "Divide : 10000000000000 / 10 = " + oTMathI:Divide( "10000000000000" , "10" ) )
 ConOut( "Divide : 10000000000000 / 08 = " + oTMathI:Divide( "10000000000000" , "08" ) )
 ConOut( "Divide : 10000000000000 / 07 = " + oTMathI:Divide( "10000000000000" , "07" ) )
 ConOut( "Divide : 10000000000000 / 06 = " + oTMathI:Divide( "10000000000000" , "06" ) )
 ConOut( "Divide : 10000000000000 / 05 = " + oTMathI:Divide( "10000000000000" , "05" ) )
 ConOut( "Divide : 10000000000000 / 04 = " + oTMathI:Divide( "10000000000000" , "04" ) )
 ConOut( "Divide : 10000000000000 / 03 = " + oTMathI:Divide( "10000000000000" , "03" ) )
 ConOut( "Divide : 10000000000000 / 02 = " + oTMathI:Divide( "10000000000000" , "02" ) )
 ConOut( "Divide : 10000000000000 / 01 = " + oTMathI:Divide( "10000000000000" , "01" ) )

 ConOut( "Divide : 100000000000000 / 95 = " + oTMathI:Divide( "100000000000000" , "95" ) )
 ConOut( "Divide : 100000000000000 / 85 = " + oTMathI:Divide( "100000000000000" , "85" ) )
 ConOut( "Divide : 100000000000000 / 75 = " + oTMathI:Divide( "100000000000000" , "75" ) )
 ConOut( "Divide : 100000000000000 / 65 = " + oTMathI:Divide( "100000000000000" , "65" ) )
 ConOut( "Divide : 100000000000000 / 55 = " + oTMathI:Divide( "100000000000000" , "55" ) )
 ConOut( "Divide : 100000000000000 / 45 = " + oTMathI:Divide( "100000000000000" , "45" ) )
 ConOut( "Divide : 100000000000000 / 35 = " + oTMathI:Divide( "100000000000000" , "35" ) )
 ConOut( "Divide : 100000000000000 / 25 = " + oTMathI:Divide( "100000000000000" , "25" ) )
 ConOut( "Divide : 100000000000000 / 15 = " + oTMathI:Divide( "100000000000000" , "15" ) )
 ConOut( "Divide : 100000000000000 / 14 = " + oTMathI:Divide( "100000000000000" , "14" ) )
 ConOut( "Divide : 100000000000000 / 13 = " + oTMathI:Divide( "100000000000000" , "13" ) )
 ConOut( "Divide : 100000000000000 / 12 = " + oTMathI:Divide( "100000000000000" , "12" ) )
 ConOut( "Divide : 100000000000000 / 11 = " + oTMathI:Divide( "100000000000000" , "11" ) )
 ConOut( "Divide : 100000000000000 / 10 = " + oTMathI:Divide( "100000000000000" , "10" ) )
 ConOut( "Divide : 100000000000000 / 08 = " + oTMathI:Divide( "100000000000000" , "08" ) )
 ConOut( "Divide : 100000000000000 / 07 = " + oTMathI:Divide( "100000000000000" , "07" ) )
 ConOut( "Divide : 100000000000000 / 06 = " + oTMathI:Divide( "100000000000000" , "06" ) )
 ConOut( "Divide : 100000000000000 / 05 = " + oTMathI:Divide( "100000000000000" , "05" ) )
 ConOut( "Divide : 100000000000000 / 04 = " + oTMathI:Divide( "100000000000000" , "04" ) )
 ConOut( "Divide : 100000000000000 / 03 = " + oTMathI:Divide( "100000000000000" , "03" ) )
 ConOut( "Divide : 100000000000000 / 02 = " + oTMathI:Divide( "100000000000000" , "02" ) )
 ConOut( "Divide : 100000000000000 / 01 = " + oTMathI:Divide( "100000000000000" , "01" ) )

 ConOut( "Divide : 1000000000000000 / 95 = " + oTMathI:Divide( "1000000000000000" , "95" ) )
 ConOut( "Divide : 1000000000000000 / 85 = " + oTMathI:Divide( "1000000000000000" , "85" ) )
 ConOut( "Divide : 1000000000000000 / 75 = " + oTMathI:Divide( "1000000000000000" , "75" ) )
 ConOut( "Divide : 1000000000000000 / 65 = " + oTMathI:Divide( "1000000000000000" , "65" ) )
 ConOut( "Divide : 1000000000000000 / 55 = " + oTMathI:Divide( "1000000000000000" , "55" ) )
 ConOut( "Divide : 1000000000000000 / 45 = " + oTMathI:Divide( "1000000000000000" , "45" ) )
 ConOut( "Divide : 1000000000000000 / 35 = " + oTMathI:Divide( "1000000000000000" , "35" ) )
 ConOut( "Divide : 1000000000000000 / 25 = " + oTMathI:Divide( "1000000000000000" , "25" ) )
 ConOut( "Divide : 1000000000000000 / 15 = " + oTMathI:Divide( "1000000000000000" , "15" ) )
 ConOut( "Divide : 1000000000000000 / 14 = " + oTMathI:Divide( "1000000000000000" , "14" ) )
 ConOut( "Divide : 1000000000000000 / 13 = " + oTMathI:Divide( "1000000000000000" , "13" ) )
 ConOut( "Divide : 1000000000000000 / 12 = " + oTMathI:Divide( "1000000000000000" , "12" ) )
 ConOut( "Divide : 1000000000000000 / 11 = " + oTMathI:Divide( "1000000000000000" , "11" ) )
 ConOut( "Divide : 1000000000000000 / 10 = " + oTMathI:Divide( "1000000000000000" , "10" ) )
 ConOut( "Divide : 1000000000000000 / 08 = " + oTMathI:Divide( "1000000000000000" , "08" ) )
 ConOut( "Divide : 1000000000000000 / 07 = " + oTMathI:Divide( "1000000000000000" , "07" ) )
 ConOut( "Divide : 1000000000000000 / 06 = " + oTMathI:Divide( "1000000000000000" , "06" ) )
 ConOut( "Divide : 1000000000000000 / 05 = " + oTMathI:Divide( "1000000000000000" , "05" ) )
 ConOut( "Divide : 1000000000000000 / 04 = " + oTMathI:Divide( "1000000000000000" , "04" ) )
 ConOut( "Divide : 1000000000000000 / 03 = " + oTMathI:Divide( "1000000000000000" , "03" ) )
 ConOut( "Divide : 1000000000000000 / 02 = " + oTMathI:Divide( "1000000000000000" , "02" ) )
 ConOut( "Divide : 1000000000000000 / 01 = " + oTMathI:Divide( "1000000000000000" , "01" ) )

 ConOut( "Divide : 10000000000000000 / 95 = " + oTMathI:Divide( "10000000000000000" , "95" ) )
 ConOut( "Divide : 10000000000000000 / 85 = " + oTMathI:Divide( "10000000000000000" , "85" ) )
 ConOut( "Divide : 10000000000000000 / 75 = " + oTMathI:Divide( "10000000000000000" , "75" ) )
 ConOut( "Divide : 10000000000000000 / 65 = " + oTMathI:Divide( "10000000000000000" , "65" ) )
 ConOut( "Divide : 10000000000000000 / 55 = " + oTMathI:Divide( "10000000000000000" , "55" ) )
 ConOut( "Divide : 10000000000000000 / 45 = " + oTMathI:Divide( "10000000000000000" , "45" ) )
 ConOut( "Divide : 10000000000000000 / 35 = " + oTMathI:Divide( "10000000000000000" , "35" ) )
 ConOut( "Divide : 10000000000000000 / 25 = " + oTMathI:Divide( "10000000000000000" , "25" ) )
 ConOut( "Divide : 10000000000000000 / 15 = " + oTMathI:Divide( "10000000000000000" , "15" ) )
 ConOut( "Divide : 10000000000000000 / 14 = " + oTMathI:Divide( "10000000000000000" , "14" ) )
 ConOut( "Divide : 10000000000000000 / 13 = " + oTMathI:Divide( "10000000000000000" , "13" ) )
 ConOut( "Divide : 10000000000000000 / 12 = " + oTMathI:Divide( "10000000000000000" , "12" ) )
 ConOut( "Divide : 10000000000000000 / 11 = " + oTMathI:Divide( "10000000000000000" , "11" ) )
 ConOut( "Divide : 10000000000000000 / 10 = " + oTMathI:Divide( "10000000000000000" , "10" ) )
 ConOut( "Divide : 10000000000000000 / 08 = " + oTMathI:Divide( "10000000000000000" , "08" ) )
 ConOut( "Divide : 10000000000000000 / 07 = " + oTMathI:Divide( "10000000000000000" , "07" ) )
 ConOut( "Divide : 10000000000000000 / 06 = " + oTMathI:Divide( "10000000000000000" , "06" ) )
 ConOut( "Divide : 10000000000000000 / 05 = " + oTMathI:Divide( "10000000000000000" , "05" ) )
 ConOut( "Divide : 10000000000000000 / 04 = " + oTMathI:Divide( "10000000000000000" , "04" ) )
 ConOut( "Divide : 10000000000000000 / 03 = " + oTMathI:Divide( "10000000000000000" , "03" ) )
 ConOut( "Divide : 10000000000000000 / 02 = " + oTMathI:Divide( "10000000000000000" , "02" ) )
 ConOut( "Divide : 10000000000000000 / 01 = " + oTMathI:Divide( "10000000000000000" , "01" ) )

 ConOut( "Divide : 10000000000000000000000 / 95 = " + oTMathI:Divide( "10000000000000000000000" , "95" ) )
 ConOut( "Divide : 10000000000000000000000 / 85 = " + oTMathI:Divide( "10000000000000000000000" , "85" ) )
 ConOut( "Divide : 10000000000000000000000 / 75 = " + oTMathI:Divide( "10000000000000000000000" , "75" ) )
 ConOut( "Divide : 10000000000000000000000 / 65 = " + oTMathI:Divide( "10000000000000000000000" , "65" ) )
 ConOut( "Divide : 10000000000000000000000 / 55 = " + oTMathI:Divide( "10000000000000000000000" , "55" ) )
 ConOut( "Divide : 10000000000000000000000 / 45 = " + oTMathI:Divide( "10000000000000000000000" , "45" ) )
 ConOut( "Divide : 10000000000000000000000 / 35 = " + oTMathI:Divide( "10000000000000000000000" , "35" ) )
 ConOut( "Divide : 10000000000000000000000 / 25 = " + oTMathI:Divide( "10000000000000000000000" , "25" ) )
 ConOut( "Divide : 10000000000000000000000 / 15 = " + oTMathI:Divide( "10000000000000000000000" , "15" ) )
 ConOut( "Divide : 10000000000000000000000 / 14 = " + oTMathI:Divide( "10000000000000000000000" , "14" ) )
 ConOut( "Divide : 10000000000000000000000 / 13 = " + oTMathI:Divide( "10000000000000000000000" , "13" ) )
 ConOut( "Divide : 10000000000000000000000 / 12 = " + oTMathI:Divide( "10000000000000000000000" , "12" ) )
 ConOut( "Divide : 10000000000000000000000 / 11 = " + oTMathI:Divide( "10000000000000000000000" , "11" ) )
 ConOut( "Divide : 10000000000000000000000 / 10 = " + oTMathI:Divide( "10000000000000000000000" , "10" ) )
 ConOut( "Divide : 10000000000000000000000 / 08 = " + oTMathI:Divide( "10000000000000000000000" , "08" ) )
 ConOut( "Divide : 10000000000000000000000 / 07 = " + oTMathI:Divide( "10000000000000000000000" , "07" ) )
 ConOut( "Divide : 10000000000000000000000 / 06 = " + oTMathI:Divide( "10000000000000000000000" , "06" ) )
 ConOut( "Divide : 10000000000000000000000 / 05 = " + oTMathI:Divide( "10000000000000000000000" , "05" ) )
 ConOut( "Divide : 10000000000000000000000 / 04 = " + oTMathI:Divide( "10000000000000000000000" , "04" ) )
 ConOut( "Divide : 10000000000000000000000 / 03 = " + oTMathI:Divide( "10000000000000000000000" , "03" ) )
 ConOut( "Divide : 10000000000000000000000 / 02 = " + oTMathI:Divide( "10000000000000000000000" , "02" ) )
 ConOut( "Divide : 10000000000000000000000 / 01 = " + oTMathI:Divide( "10000000000000000000000" , "01" ) )

 ConOut( "Divide : 98765432198765432198765 / 95 = " + oTMathI:Divide( "98765432198765432198765" , "95" ) )
 ConOut( "Divide : 98765432198765432198765 / 85 = " + oTMathI:Divide( "98765432198765432198765" , "85" ) )
 ConOut( "Divide : 98765432198765432198765 / 75 = " + oTMathI:Divide( "98765432198765432198765" , "75" ) )
 ConOut( "Divide : 98765432198765432198765 / 65 = " + oTMathI:Divide( "98765432198765432198765" , "65" ) )
 ConOut( "Divide : 98765432198765432198765 / 55 = " + oTMathI:Divide( "98765432198765432198765" , "55" ) )
 ConOut( "Divide : 98765432198765432198765 / 45 = " + oTMathI:Divide( "98765432198765432198765" , "45" ) )
 ConOut( "Divide : 98765432198765432198765 / 35 = " + oTMathI:Divide( "98765432198765432198765" , "35" ) )
 ConOut( "Divide : 98765432198765432198765 / 25 = " + oTMathI:Divide( "98765432198765432198765" , "25" ) )
 ConOut( "Divide : 98765432198765432198765 / 15 = " + oTMathI:Divide( "98765432198765432198765" , "15" ) )
 ConOut( "Divide : 98765432198765432198765 / 14 = " + oTMathI:Divide( "98765432198765432198765" , "14" ) )
 ConOut( "Divide : 98765432198765432198765 / 13 = " + oTMathI:Divide( "98765432198765432198765" , "13" ) )
 ConOut( "Divide : 98765432198765432198765 / 12 = " + oTMathI:Divide( "98765432198765432198765" , "12" ) )
 ConOut( "Divide : 98765432198765432198765 / 11 = " + oTMathI:Divide( "98765432198765432198765" , "11" ) )
 ConOut( "Divide : 98765432198765432198765 / 10 = " + oTMathI:Divide( "98765432198765432198765" , "10" ) )
 ConOut( "Divide : 98765432198765432198765 / 08 = " + oTMathI:Divide( "98765432198765432198765" , "08" ) )
 ConOut( "Divide : 98765432198765432198765 / 07 = " + oTMathI:Divide( "98765432198765432198765" , "07" ) )
 ConOut( "Divide : 98765432198765432198765 / 06 = " + oTMathI:Divide( "98765432198765432198765" , "06" ) )
 ConOut( "Divide : 98765432198765432198765 / 05 = " + oTMathI:Divide( "98765432198765432198765" , "05" ) )
 ConOut( "Divide : 98765432198765432198765 / 04 = " + oTMathI:Divide( "98765432198765432198765" , "04" ) )
 ConOut( "Divide : 98765432198765432198765 / 03 = " + oTMathI:Divide( "98765432198765432198765" , "03" ) )
 ConOut( "Divide : 98765432198765432198765 / 02 = " + oTMathI:Divide( "98765432198765432198765" , "02" ) )
 ConOut( "Divide : 98765432198765432198765 / 01 = " + oTMathI:Divide( "98765432198765432198765" , "01" ) )

 ConOut( "Divide : 123456789123456789 / 123456789 = " + oTMathI:Divide( "123456789123456789" , "123456789" ) )
 ConOut( "Divide : 123456789123456789 / 123456789123456789 = " + oTMathI:Divide( "123456789123456789" , "123456789123456789" ) )
 ConOut( "Divide : 123456789123456789123456789123456789 / 123456789123456789 = " + oTMathI:Divide( "123456789123456789123456789123456789" , "123456789123456789" ) )
 ConOut( "Divide : 123456789123456789123456789123456789123456789123456789123456789123456789 / 123456789123456789123456789123456789 =  " + oTMathI:Divide( "123456789123456789123456789123456789123456789123456789123456789123456789" , "123456789123456789123456789123456789" ) )
 ConOut( "Divide : 123456789123456789123456789123456789123456789123456789123456789123456789 / 123456789123456789123456789123456789123456789123456789123456789123456789 =  " + oTMathI:Divide( "123456789123456789123456789123456789123456789123456789123456789123456789" , "123456789123456789123456789123456789123456789123456789123456789123456789" ) )
 ConOut( "Divide : 123456789123456789123456789123456789 / 123456789123456789123456789123456789 = " + oTMathI:Divide( "123456789123456789123456789123456789" , "123456789123456789123456789123456789" ) )

 ConOut( "Add  MATHC : 1 + 1 = " + oTMathI:MathC( "1" , "+" , "1" ) )
 ConOut( "Add  MATHC : 12 + 12 = " + oTMathI:MathC( "12" , "+" , "12" ) )
 ConOut( "Add  MATHC : 123 + 123 = " + oTMathI:MathC( "123" , "+" , "123" ) )
 ConOut( "Add  MATHC : 1234 + 1234 = " + oTMathI:MathC( "1234" , "+" , "1234" ) )
 ConOut( "Add  MATHC : 12345 + 12345 = " + oTMathI:MathC( "12345" , "+" , "12345" ) )
 ConOut( "Add  MATHC : 123456 + 123456 = " + oTMathI:MathC( "123456" , "+" , "123456" ) )
 ConOut( "Add  MATHC : 1234567 + 1234567 = " + oTMathI:MathC( "1234567" , "+" , "1234567" ) )
 ConOut( "Add  MATHC : 12345678 + 12345678 = " + oTMathI:MathC( "12345678" , "+" , "12345678" ) )
 ConOut( "Add  MATHC : 123456789 + 123456789 = " + oTMathI:MathC( "123456789" , "+" , "123456789" ) )
 ConOut( "Add  MATHC : 123456789123456789 + 123456789123456789 = " + oTMathI:MathC( "123456789123456789" , "+" , "123456789123456789" ) )
 ConOut( "Add  MATHC : 123456789123456789123456789123456789 + 123456789123456789123456789123456789 = " + oTMathI:MathC( "123456789123456789123456789123456789" , "+" , "123456789123456789123456789123456789" ) )
 ConOut( "Add  MATHC : 123456789123456789123456789123456789123456789123456789123456789123456789 + 123456789123456789123456789123456789123456789123456789123456789123456789 =  " + oTMathI:MathC( "123456789123456789123456789123456789123456789123456789123456789123456789" , "+" , "123456789123456789123456789123456789123456789123456789123456789123456789" ) )

 ConOut( "Subtract  MATHC : 10 - 10 = " + oTMathI:MathC( "10" , "-" , "10" ) )
 ConOut( "Subtract  MATHC : 10 - 9 = " + oTMathI:MathC( "10" , "-" , "9" ) )
 ConOut( "Subtract  MATHC : 10 - 8 = " + oTMathI:MathC( "10" , "-" , "8" ) )
 ConOut( "Subtract  MATHC : 10 - 7 = " + oTMathI:MathC( "10" , "-" , "7" ) )
 ConOut( "Subtract  MATHC : 10 - 6 = " + oTMathI:MathC( "10" , "-" , "6" ) )
 ConOut( "Subtract  MATHC : 10 - 5 = " + oTMathI:MathC( "10" , "-" , "5" ) )
 ConOut( "Subtract  MATHC : 10 - 4 = " + oTMathI:MathC( "10" , "-" , "4" ) )
 ConOut( "Subtract  MATHC : 10 - 3 = " + oTMathI:MathC( "10" , "-" , "3" ) )
 ConOut( "Subtract  MATHC : 10 - 2 = " + oTMathI:MathC( "10" , "-" , "2" ) )
 ConOut( "Subtract  MATHC : 10 - 1 = " + oTMathI:MathC( "10" , "-" , "1" ) )
 ConOut( "Subtract  MATHC : 10 - 0 = " + oTMathI:MathC( "10" , "-" , "0" ) )

 ConOut( "Subtract  MATHC : 123456789123456789123456789123456789123456789123456789123456789123456789 - 123456789123456789123456789123456789123456789123456789123456789123456789 =  " - oTMathI:MathC( "123456789123456789123456789123456789123456789123456789123456789123456789" , "-" , "123456789123456789123456789123456789123456789123456789123456789123456789" ) )
 ConOut( "Subtract  MATHC : 123456789123456789123456789123456789 - 123456789123456789123456789123456789 = " + oTMathI:MathC( "123456789123456789123456789123456789" , "-" , "123456789123456789123456789123456789" ) )
 ConOut( "Subtract  MATHC : 123456789123456789 - 123456789123456789 = " + oTMathI:MathC( "123456789123456789" , "-" , "123456789123456789" ) )

 ConOut( "Subtract  MATHC : 123456789123456789123456789123456789123456789123456789123456789123456789 - 123456789123456789123456789123456789 =  " - oTMathI:MathC( "123456789123456789123456789123456789123456789123456789123456789123456789" , "-" , "123456789123456789123456789123456789" ) )
 ConOut( "Subtract  MATHC : 123456789123456789123456789123456789 - 123456789123456789 = " + oTMathI:MathC( "123456789123456789123456789123456789" , "-" , "123456789123456789" ) )
 ConOut( "Subtract  MATHC : 123456789123456789 - 123456789 = " + oTMathI:MathC( "123456789123456789" , "-" , "123456789" ) )

 ConOut( "Multiply  MATHC : 10 * 10 = " + oTMathI:MathC( "10" , "*" , "10" ) )
 ConOut( "Multiply  MATHC : 10 * 9 = " + oTMathI:MathC( "10" , "*" , "9" ) )
 ConOut( "Multiply  MATHC : 10 * 8 = " + oTMathI:MathC( "10" , "*" , "8" ) )
 ConOut( "Multiply  MATHC : 10 * 7 = " + oTMathI:MathC( "10" , "*" , "7" ) )
 ConOut( "Multiply  MATHC : 10 * 6 = " + oTMathI:MathC( "10" , "*" , "6" ) )
 ConOut( "Multiply  MATHC : 10 * 5 = " + oTMathI:MathC( "10" , "*" , "5" ) )
 ConOut( "Multiply  MATHC : 10 * 4 = " + oTMathI:MathC( "10" , "*" , "4" ) )
 ConOut( "Multiply  MATHC : 10 * 3 = " + oTMathI:MathC( "10" , "*" , "3" ) )
 ConOut( "Multiply  MATHC : 10 * 2 = " + oTMathI:MathC( "10" , "*" , "2" ) )
 ConOut( "Multiply  MATHC : 10 * 1 = " + oTMathI:MathC( "10" , "*" , "1" ) )
 ConOut( "Multiply  MATHC : 10 * 0 = " + oTMathI:MathC( "10" , "*" , "0" ) )

 ConOut( "Multiply  MATHC : 123456789123456789123456789123456789123456789123456789123456789123456789 * 123456789123456789123456789123456789123456789123456789123456789123456789 =  " + oTMathI:MathC( "123456789123456789123456789123456789123456789123456789123456789123456789" , "*" , "123456789123456789123456789123456789123456789123456789123456789123456789" ) )
 ConOut( "Multiply  MATHC : 123456789123456789123456789123456789 * 123456789123456789123456789123456789 = " + oTMathI:MathC( "123456789123456789123456789123456789" , "*" , "123456789123456789123456789123456789" ) )
 ConOut( "Multiply  MATHC : 123456789123456789 * 123456789123456789 = " + oTMathI:MathC( "123456789123456789" , "*" , "123456789123456789" ) )

 ConOut( "Multiply  MATHC : 123456789123456789123456789123456789123456789123456789123456789123456789 * 123456789123456789123456789123456789 =  " + oTMathI:MathC( "123456789123456789123456789123456789123456789123456789123456789123456789" , "*" , "123456789123456789123456789123456789" ) )
 ConOut( "Multiply  MATHC : 123456789123456789123456789123456789 * 123456789123456789 = " + oTMathI:MathC( "123456789123456789123456789123456789" , "*" , "123456789123456789" ) )
 ConOut( "Multiply  MATHC : 123456789123456789 * 123456789 = " + oTMathI:MathC( "123456789123456789" , "*" , "123456789" ) )
 
 ConOut( "POW  MATHC : 10 ^ 10 = " + oTMathI:MathC( "10" , "^" , "10" ) )
 ConOut( "POW  MATHC : 10 ^ 9 = " + oTMathI:MathC( "10" , "^" , "9" ) )
 ConOut( "POW  MATHC : 10 ^ 8 = " + oTMathI:MathC( "10" , "^" , "8" ) )
 ConOut( "POW  MATHC : 10 ^ 7 = " + oTMathI:MathC( "10" , "^" , "7" ) )
 ConOut( "POW  MATHC : 10 ^ 6 = " + oTMathI:MathC( "10" , "^" , "6" ) )
 ConOut( "POW  MATHC : 10 ^ 5 = " + oTMathI:MathC( "10" , "^" , "5" ) )
 ConOut( "POW  MATHC : 10 ^ 4 = " + oTMathI:MathC( "10" , "^" , "4" ) )
 ConOut( "POW  MATHC : 10 ^ 3 = " + oTMathI:MathC( "10" , "^" , "3" ) )
 ConOut( "POW  MATHC : 10 ^ 2 = " + oTMathI:MathC( "10" , "^" , "2" ) )
 ConOut( "POW  MATHC : 10 ^ 1 = " + oTMathI:MathC( "10" , "^" , "1" ) )
 ConOut( "POW  MATHC : 10 ^ 0 = " + oTMathI:MathC( "10" , "^" , "0" ) )

 ConOut( "Divide  MATHC : 10 / 10 = " + oTMathI:MathC( "10" , "/" , "10" ) )
 ConOut( "Divide  MATHC : 10 / 9 = " + oTMathI:MathC( "10" , "/" , "9" ) )
 ConOut( "Divide  MATHC : 10 / 8 = " + oTMathI:MathC( "10" , "/" , "8" ) )
 ConOut( "Divide  MATHC : 10 / 7 = " + oTMathI:MathC( "10" , "/" , "7" ) )
 ConOut( "Divide  MATHC : 10 / 6 = " + oTMathI:MathC( "10" , "/" , "6" ) )
 ConOut( "Divide  MATHC : 10 / 5 = " + oTMathI:MathC( "10" , "/" , "5" ) )
 ConOut( "Divide  MATHC : 10 / 4 = " + oTMathI:MathC( "10" , "/" , "4" ) )
 ConOut( "Divide  MATHC : 10 / 3 = " + oTMathI:MathC( "10" , "/" , "3" ) )
 ConOut( "Divide  MATHC : 10 / 2 = " + oTMathI:MathC( "10" , "/" , "2" ) )
 ConOut( "Divide  MATHC : 10 / 1 = " + oTMathI:MathC( "10" , "/" , "1" ) )
 ConOut( "Divide  MATHC : 10 / 0 = " + oTMathI:MathC( "10" , "/" , "0" ) )

 ConOut( "Divide  MATHC : 123456789123456789123456789123456789123456789123456789123456789123456789 / 123456789123456789123456789123456789123456789123456789123456789123456789 =  " + oTMathI:MathC( "123456789123456789123456789123456789123456789123456789123456789123456789" , "/" , "123456789123456789123456789123456789123456789123456789123456789123456789" ) )
 ConOut( "Divide  MATHC : 123456789123456789123456789123456789 / 123456789123456789123456789123456789 = " + oTMathI:MathC( "123456789123456789123456789123456789" , "/" , "123456789123456789123456789123456789" ) )
 ConOut( "Divide  MATHC : 123456789123456789 / 123456789123456789 = " + oTMathI:MathC( "123456789123456789" , "/" , "123456789123456789" ) )

 ConOut( "Divide  MATHC : 123456789123456789123456789123456789123456789123456789123456789123456789 / 123456789123456789123456789123456789 =  " + oTMathI:MathC( "123456789123456789123456789123456789123456789123456789123456789123456789" , "/" , "123456789123456789123456789123456789" ) )
 ConOut( "Divide  MATHC : 123456789123456789123456789123456789 / 123456789123456789 = " + oTMathI:MathC( "123456789123456789123456789123456789" , "/" , "123456789123456789" ) )
 ConOut( "Divide  MATHC : 123456789123456789 / 123456789 = " + oTMathI:MathC( "123456789123456789" , "/" , "123456789" ) )

 ConOut( "POW  MATHC : 10 ^ 20 = " + oTMathI:MathC( "10" , "^" , "20" ) )
 ConOut( "POW  MATHC : 10 ^ 30 = " + oTMathI:MathC( "10" , "^" , "30" ) )
 ConOut( "POW  MATHC : 10 ^ 40 = " + oTMathI:MathC( "10" , "^" , "40" ) )
 ConOut( "POW  MATHC : 10 ^ 50 = " + oTMathI:MathC( "10" , "^" , "50" ) )
 ConOut( "POW  MATHC : 10 ^ 60 = " + oTMathI:MathC( "10" , "^" , "60" ) )
 ConOut( "POW  MATHC : 10 ^ 70 = " + oTMathI:MathC( "10" , "^" , "70" ) )
 ConOut( "POW  MATHC : 10 ^ 80 = " + oTMathI:MathC( "10" , "^" , "80" ) )
 ConOut( "POW  MATHC : 10 ^ 90 = " + oTMathI:MathC( "10" , "^" , "90" ) )
 ConOut( "POW  MATHC : 10 ^ 100 = " + oTMathI:MathC( "10" , "^" , "100" ) )
 ConOut( "POW  MATHC : 10 ^ 1000 = " + oTMathI:MathC( "10" , "^" , "1000" ) )
 ConOut( "POW  MATHC : 10 ^ 10000 = " + oTMathI:MathC( "10" , "^" , "10000" ) )
 ConOut( "POW  MATHC : 10 ^ 100000 = " + oTMathI:MathC( "10" , "^" , "100000" ) )
 
Return( oTMathI )

User Function TMathF()

 Local oTMathF := U_MathFloatStr()

 oTMathF:SetDecimals( 100 )

 ConOut( "Add : 1.5 + 1.5 = " + oTMathF:Add( "1.5" , "1.5" ) )
 ConOut( "Add : 12.12 + 12.12 = " + oTMathF:Add( "12.12" , "12.12" ) )
 ConOut( "Add : 123.123 + 123.123 = " + oTMathF:Add( "123.123" , "123.123" ) )
 ConOut( "Add : 1234.1234 + 1234.1234 = " + oTMathF:Add( "1234.1234" , "1234.1234" ) )
 ConOut( "Add : 12345.12345 + 12345.12345 = " + oTMathF:Add( "12345.12345" , "12345.12345" ) )
 ConOut( "Add : 123456.123456 + 123456.123456 = " + oTMathF:Add( "123456.123456" , "123456.123456" ) )
 ConOut( "Add : 1234567.1234567 + 1234567.1234567 = " + oTMathF:Add( "1234567.1234567" , "1234567.1234567" ) )
 ConOut( "Add : 12345678.12345678 + 12345678.12345678 = " + oTMathF:Add( "12345678.12345678" , "12345678.12345678" ) )
 ConOut( "Add : 123456789.123456789 + 123456789.123456789 = " + oTMathF:Add( "123456789.123456789" , "123456789.123456789" ) )
 ConOut( "Add : 123456789123456789.123456789123456789 + 123456789123456789.123456789123456789 = " + oTMathF:Add( "123456789123456789.123456789123456789" , "123456789123456789.123456789123456789" ) )
 ConOut( "Add : 123456789123456789123456789123456789.123456789123456789123456789123456789 + 123456789123456789123456789123456789.123456789123456789123456789123456789 = " + oTMathF:Add( "123456789123456789123456789123456789.123456789123456789123456789123456789" , "123456789123456789123456789123456789.123456789123456789123456789123456789" ) )
 ConOut( "Add : 123456789123456789123456789123456789123456789123456789123456789123456789.123456789123456789123456789123456789123456789123456789123456789123456789 + 123456789123456789123456789123456789123456789123456789123456789123456789.123456789123456789123456789123456789123456789123456789123456789123456789 =  " + oTMathF:Add( "123456789123456789123456789123456789123456789123456789123456789123456789.123456789123456789123456789123456789123456789123456789123456789123456789" , "123456789123456789123456789123456789123456789123456789123456789123456789.123456789123456789123456789123456789123456789123456789123456789123456789" ) )

 ConOut( "Subtract : 10.07865 - 10.07865 = " + oTMathF:Subtract( "10.07865" , "10.07865" ) )
 ConOut( "Subtract : 10.07865 - 9.07865 = " + oTMathF:Subtract( "10.07865" , "9.07865" ) )
 ConOut( "Subtract : 10.07865 - 8.07865 = " + oTMathF:Subtract( "10.07865" , "8.07865" ) )
 ConOut( "Subtract : 10.07865 - 7.07865 = " + oTMathF:Subtract( "10.07865" , "7.07865" ) )
 ConOut( "Subtract : 10.07865 - 6.07865 = " + oTMathF:Subtract( "10.07865" , "6.07865" ) )
 ConOut( "Subtract : 10.07865 - 5.07865 = " + oTMathF:Subtract( "10.07865" , "5.07865" ) )
 ConOut( "Subtract : 10.07865 - 4.07865 = " + oTMathF:Subtract( "10.07865" , "4.07865" ) )
 ConOut( "Subtract : 10.07865 - 3.07865 = " + oTMathF:Subtract( "10.07865" , "3.07865" ) )
 ConOut( "Subtract : 10.07865 - 2.07865 = " + oTMathF:Subtract( "10.07865" , "2.07865" ) )
 ConOut( "Subtract : 10.07865 - 1.07865 = " + oTMathF:Subtract( "10.07865" , "1.07865" ) )
 ConOut( "Subtract : 10.07865 - 0.07865 = " + oTMathF:Subtract( "10.07865" , "0.07865" ) )
 ConOut( "Subtract : 10.07865 - 0 = " + oTMathF:Subtract( "10.07865" , "0" ) )

 ConOut( "Subtract : 123456789123456789123456789123456789.123456789123456789123456789123456789 - 123456789123456789123456789.123456789123456789123456789123456789123456789 =  " - oTMathF:Subtract( "123456789123456789123456789123456789.123456789123456789123456789123456789" , "123456789123456789123456789.123456789123456789123456789123456789123456789" ) )
 ConOut( "Subtract : 12345678912345678.9123456789123456789 - 123456789123.456789123456789123456789 = " + oTMathF:Subtract( "12345678912345678.9123456789123456789" , "123456789123.456789123456789123456789" ) )
 ConOut( "Subtract : 123456789123.456789 - 12345678912345.6789 = " + oTMathF:Subtract( "123456789123.456789" , "12345678912345.6789" ) )

 ConOut( "Subtract : 12.3456789123456789123456789123456789123456789123456789123456789123456789 - 1.23456789123456789123456789123456789 =  " - oTMathF:Subtract( "12.3456789123456789123456789123456789123456789123456789123456789123456789" , "1.23456789123456789123456789123456789" ) )
 ConOut( "Subtract : 1234567891234567891234567891234.56789 - 12345678912.3456789 = " + oTMathF:Subtract( "1234567891234567891234567891234.56789" , "12345678912.3456789" ) )
 ConOut( "Subtract : 123456789123.456789 - 12345.6789 = " + oTMathF:Subtract( "123456789123.456789" , "12345.6789" ) )

 ConOut( "Multiply : 10.5 * 10.5 = " + oTMathF:Multiply( "10.5" , "10.5" ) )
 ConOut( "Multiply : 10.2 * 10.2 = " + oTMathF:Multiply( "10.2" , "10.2" ) )
 ConOut( "Multiply : 10.1234567890 * 10.0987654321 = " + oTMathF:Multiply( "10.1234567890" , "10.0987654321" ) )
 ConOut( "Multiply : 10.56789 * 9.56789 = " + oTMathF:Multiply( "10.56789" , "9.56789" ) )
 ConOut( "Multiply : 10.56789 * 8.56789 = " + oTMathF:Multiply( "10.56789" , "8.56789" ) )
 ConOut( "Multiply : 10.56789 * 7.56789 = " + oTMathF:Multiply( "10.56789" , "7.56789" ) )
 ConOut( "Multiply : 10.56789 * 6.56789 = " + oTMathF:Multiply( "10.56789" , "6.56789" ) )
 ConOut( "Multiply : 10.56789 * 5.56789 = " + oTMathF:Multiply( "10.56789" , "5.56789" ) )
 ConOut( "Multiply : 10.56789 * 4.56789 = " + oTMathF:Multiply( "10.56789" , "4.56789" ) )
 ConOut( "Multiply : 10.56789 * 3.56789 = " + oTMathF:Multiply( "10.56789" , "3.56789" ) )
 ConOut( "Multiply : 10.56789 * 2.56789 = " + oTMathF:Multiply( "10.56789" , "2.56789" ) )
 ConOut( "Multiply : 10.56789 * 1.56789 = " + oTMathF:Multiply( "10.56789" , "1.56789" ) )
 ConOut( "Multiply : 10.56789 * 0.56789 = " + oTMathF:Multiply( "10.56789" , "0.56789" ) )

 ConOut( "Multiply : 123456789123456789123456789123456789123.456789123456789123456789123456789 * 123456789123456789123.456789123456789123456789123456789123456789123456789 =  " + oTMathF:Multiply( "123456789123456789123456789123456789123.456789123456789123456789123456789" , "123456789123456789123.456789123456789123456789123456789123456789123456789" ) )
 ConOut( "Multiply : 123456789123456.789123456789123456789 * 12345678912345678912345678.9123456789 = " + oTMathF:Multiply( "123456789123456.789123456789123456789" , "12345678912345678912345678.9123456789" ) )
 ConOut( "Multiply : 1234.56789123456789 * 12.3456789123456789 = " + oTMathF:Multiply( "1234.56789123456789" , "12.3456789123456789" ) )

 ConOut( "Multiply : 123456789123456789123456789123456.789123456789123456789123456789123456789 * 123456789123456789123456789123456789 =  " + oTMathF:Multiply( "123456789123456789123456789123456.789123456789123456789123456789123456789" , "123456789123456789123456789123456789" ) )
 ConOut( "Multiply : 123456789123456789123456789123456789 * 123456789.123456789 = " + oTMathF:Multiply( "123456789123456789123456789123456789" , "123456789.123456789" ) )
 ConOut( "Multiply : 1.23456789123456789 * 123456789 = " + oTMathF:Multiply( "1.23456789123456789" , "123456789" ) )

 ConOut( "Divide : 10.5 / 10.5 = " + oTMathF:Divide( "10.5" , "10.5" ) )
 ConOut( "Divide : 10.55 / 10.55 = " + oTMathF:Divide( "10.55" , "10.55" ) )
 ConOut( "Divide : 10.555 / 10.555 = " + oTMathF:Divide( "10.555" , "10.555" ) )
 ConOut( "Divide : 10.5555 / 10.5555 = " + oTMathF:Divide( "10.5555" , "10.5555" ) )
 ConOut( "Divide : 10.55555 / 10.55555 = " + oTMathF:Divide( "10.55555" , "10.55555" ) )
 
 ConOut( "Divide : 10.999999999999999 / 10.99999999999999999999 = " + oTMathF:Divide( "10.999999999999999" , "10.99999999999999999999" ) )
 
 ConOut( "Divide : 10 / 9.987654321 = " + oTMathF:Divide( "10" , "9.987654321" ) )
 ConOut( "Divide : 10 / 8.987654321 = " + oTMathF:Divide( "10" , "8.987654321" ) )
 ConOut( "Divide : 10 / 7.987654321 = " + oTMathF:Divide( "10" , "7.987654321" ) )
 ConOut( "Divide : 10 / 6.987654321 = " + oTMathF:Divide( "10" , "6.987654321" ) )
 ConOut( "Divide : 10 / 5.987654321 = " + oTMathF:Divide( "10" , "5.987654321" ) )
 ConOut( "Divide : 10 / 4.987654321 = " + oTMathF:Divide( "10" , "4.987654321" ) )
 ConOut( "Divide : 10 / 3.987654321 = " + oTMathF:Divide( "10" , "3.987654321" ) )
 ConOut( "Divide : 10 / 2.987654321 = " + oTMathF:Divide( "10" , "2.987654321" ) )
 ConOut( "Divide : 10 / 1.987654321 = " + oTMathF:Divide( "10" , "1.987654321" ) )
 ConOut( "Divide : 10 / 0.987654321 = " + oTMathF:Divide( "10" , "0.987654321" ) )
 
 ConOut( "Divide : 100 / 90.987654321 = " + oTMathF:Divide( "100" , "90.987654321" ) )
 ConOut( "Divide : 100 / 80.987654321 = " + oTMathF:Divide( "100" , "80.987654321" ) )
 ConOut( "Divide : 100 / 70.987654321 = " + oTMathF:Divide( "100" , "70.987654321" ) )
 ConOut( "Divide : 100 / 60.987654321 = " + oTMathF:Divide( "100" , "60.987654321" ) )
 ConOut( "Divide : 100 / 50.987654321 = " + oTMathF:Divide( "100" , "50.987654321" ) )
 ConOut( "Divide : 100 / 40.987654321 = " + oTMathF:Divide( "100" , "40.987654321" ) )
 ConOut( "Divide : 100 / 30.987654321 = " + oTMathF:Divide( "100" , "30.987654321" ) )
 ConOut( "Divide : 100 / 20.987654321 = " + oTMathF:Divide( "100" , "20.987654321" ) )

 ConOut( "Divide : 100 / 100.987654321987654321987654321 = " + oTMathF:Divide( "100" , "100.987654321987654321987654321" ) )

 ConOut( "Divide : 100 / 95.987654321987654321987654321 = " + oTMathF:Divide( "100" , "95.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 85.987654321987654321987654321 = " + oTMathF:Divide( "100" , "85.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 75.987654321987654321987654321 = " + oTMathF:Divide( "100" , "75.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 65.987654321987654321987654321 = " + oTMathF:Divide( "100" , "65.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 55.987654321987654321987654321 = " + oTMathF:Divide( "100" , "55.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 45.987654321987654321987654321 = " + oTMathF:Divide( "100" , "45.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 35.987654321987654321987654321 = " + oTMathF:Divide( "100" , "35.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 25.987654321987654321987654321 = " + oTMathF:Divide( "100" , "25.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 15.987654321987654321987654321 = " + oTMathF:Divide( "100" , "15.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 14.987654321987654321987654321 = " + oTMathF:Divide( "100" , "14.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 13.987654321987654321987654321 = " + oTMathF:Divide( "100" , "13.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 12.987654321987654321987654321 = " + oTMathF:Divide( "100" , "12.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 11.987654321987654321987654321 = " + oTMathF:Divide( "100" , "11.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 10.987654321987654321987654321 = " + oTMathF:Divide( "100" , "10.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 08.987654321987654321987654321 = " + oTMathF:Divide( "100" , "08.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 07.987654321987654321987654321 = " + oTMathF:Divide( "100" , "07.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 06.987654321987654321987654321 = " + oTMathF:Divide( "100" , "06.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 05.987654321987654321987654321 = " + oTMathF:Divide( "100" , "05.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 04.987654321987654321987654321 = " + oTMathF:Divide( "100" , "04.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 03.987654321987654321987654321 = " + oTMathF:Divide( "100" , "03.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 02.987654321987654321987654321 = " + oTMathF:Divide( "100" , "02.987654321987654321987654321" ) )
 ConOut( "Divide : 100 / 01.987654321987654321987654321 = " + oTMathF:Divide( "100" , "01.987654321987654321987654321" ) )

 ConOut( "Divide : 1000 / 95.987654321987654321987654321 = " + oTMathF:Divide( "1000" , "95.987654321987654321987654321" ) )
 ConOut( "Divide : 1000 / 85.987654321987654321987654321 = " + oTMathF:Divide( "1000" , "85.987654321987654321987654321" ) )
 ConOut( "Divide : 1000 / 75.987654321987654321987654321 = " + oTMathF:Divide( "1000" , "75.987654321987654321987654321" ) )
 ConOut( "Divide : 1000 / 65.987654321987654321987654321 = " + oTMathF:Divide( "1000" , "65.987654321987654321987654321" ) )
 ConOut( "Divide : 1000 / 55.987654321987654321987654321 = " + oTMathF:Divide( "1000" , "55.987654321987654321987654321" ) )
 ConOut( "Divide : 1000 / 45.987654321987654321987654321 = " + oTMathF:Divide( "1000" , "45.987654321987654321987654321" ) )
 ConOut( "Divide : 1000 / 35.987654321987654321987654321 = " + oTMathF:Divide( "1000" , "35.987654321987654321987654321" ) )
 ConOut( "Divide : 1000 / 25.987654321987654321987654321 = " + oTMathF:Divide( "1000" , "25.987654321987654321987654321" ) )
 ConOut( "Divide : 1000 / 15.987654321987654321987654321 = " + oTMathF:Divide( "1000" , "15.987654321987654321987654321" ) )
 ConOut( "Divide : 1000 / 14.987654321987654321987654321 = " + oTMathF:Divide( "1000" , "14.987654321987654321987654321" ) )
 ConOut( "Divide : 1000 / 13.987654321987654321987654321 = " + oTMathF:Divide( "1000" , "13.987654321987654321987654321" ) )
 ConOut( "Divide : 1000 / 12.987654321987654321987654321 = " + oTMathF:Divide( "1000" , "12.987654321987654321987654321" ) )

 ConOut( "Divide : 1000.987654321987654321987654321 / 11 = " + oTMathF:Divide( "1000.987654321987654321987654321" , "11" ) )
 ConOut( "Divide : 1000.987654321987654321987654321 / 10 = " + oTMathF:Divide( "1000.987654321987654321987654321" , "10" ) )
 ConOut( "Divide : 1000.987654321987654321987654321 / 08 = " + oTMathF:Divide( "1000.987654321987654321987654321" , "08" ) )
 ConOut( "Divide : 1000.987654321987654321987654321 / 07 = " + oTMathF:Divide( "1000.987654321987654321987654321" , "07" ) )
 ConOut( "Divide : 1000.987654321987654321987654321 / 06 = " + oTMathF:Divide( "1000.987654321987654321987654321" , "06" ) )
 ConOut( "Divide : 1000.987654321987654321987654321 / 05 = " + oTMathF:Divide( "1000.987654321987654321987654321" , "05" ) )
 ConOut( "Divide : 1000.987654321987654321987654321 / 04 = " + oTMathF:Divide( "1000.987654321987654321987654321" , "04" ) )
 ConOut( "Divide : 1000.987654321987654321987654321 / 03 = " + oTMathF:Divide( "1000.987654321987654321987654321" , "03" ) )
 ConOut( "Divide : 1000.987654321987654321987654321 / 02 = " + oTMathF:Divide( "1000.987654321987654321987654321" , "02" ) )
 ConOut( "Divide : 1000.987654321987654321987654321 / 01 = " + oTMathF:Divide( "1000.987654321987654321987654321" , "01" ) )

 ConOut( "Divide : 10000 / 95 = " + oTMathF:Divide( "10000" , "95" ) )
 ConOut( "Divide : 10000 / 85 = " + oTMathF:Divide( "10000" , "85" ) )
 ConOut( "Divide : 10000 / 75 = " + oTMathF:Divide( "10000" , "75" ) )
 ConOut( "Divide : 10000 / 65 = " + oTMathF:Divide( "10000" , "65" ) )
 ConOut( "Divide : 10000 / 55 = " + oTMathF:Divide( "10000" , "55" ) )
 ConOut( "Divide : 10000 / 45 = " + oTMathF:Divide( "10000" , "45" ) )
 ConOut( "Divide : 10000 / 35 = " + oTMathF:Divide( "10000" , "35" ) )

 ConOut( "Divide : 10000 / 25 = " + oTMathF:Divide( "10000" , "25" ) )
 ConOut( "Divide : 10000 / 15 = " + oTMathF:Divide( "10000" , "15" ) )
 ConOut( "Divide : 10000 / 14 = " + oTMathF:Divide( "10000" , "14" ) )
 ConOut( "Divide : 10000 / 13 = " + oTMathF:Divide( "10000" , "13" ) )
 ConOut( "Divide : 10000 / 12 = " + oTMathF:Divide( "10000" , "12" ) )
 ConOut( "Divide : 10000 / 11 = " + oTMathF:Divide( "10000" , "11" ) )
 ConOut( "Divide : 10000 / 10 = " + oTMathF:Divide( "10000" , "10" ) )
 ConOut( "Divide : 10000 / 08 = " + oTMathF:Divide( "10000" , "08" ) )
 ConOut( "Divide : 10000 / 07 = " + oTMathF:Divide( "10000" , "07" ) )
 ConOut( "Divide : 10000 / 06 = " + oTMathF:Divide( "10000" , "06" ) )
 ConOut( "Divide : 10000 / 05 = " + oTMathF:Divide( "10000" , "05" ) )
 ConOut( "Divide : 10000 / 04 = " + oTMathF:Divide( "10000" , "04" ) )
 ConOut( "Divide : 10000 / 03 = " + oTMathF:Divide( "10000" , "03" ) )
 ConOut( "Divide : 10000 / 02 = " + oTMathF:Divide( "10000" , "02" ) )
 ConOut( "Divide : 10000 / 01 = " + oTMathF:Divide( "10000" , "01" ) )

 ConOut( "Divide : 100000 / 95 = " + oTMathF:Divide( "100000" , "95" ) )
 ConOut( "Divide : 100000 / 85 = " + oTMathF:Divide( "100000" , "85" ) )
 ConOut( "Divide : 100000 / 75 = " + oTMathF:Divide( "100000" , "75" ) )
 ConOut( "Divide : 100000 / 65 = " + oTMathF:Divide( "100000" , "65" ) )
 ConOut( "Divide : 100000 / 55 = " + oTMathF:Divide( "100000" , "55" ) )
 ConOut( "Divide : 100000 / 45 = " + oTMathF:Divide( "100000" , "45" ) )
 ConOut( "Divide : 100000 / 35 = " + oTMathF:Divide( "100000" , "35" ) )
 ConOut( "Divide : 100000 / 25 = " + oTMathF:Divide( "100000" , "25" ) )
 ConOut( "Divide : 100000 / 15 = " + oTMathF:Divide( "100000" , "15" ) )
 ConOut( "Divide : 100000 / 14 = " + oTMathF:Divide( "100000" , "14" ) )
 ConOut( "Divide : 100000 / 13 = " + oTMathF:Divide( "100000" , "13" ) )
 ConOut( "Divide : 100000 / 12 = " + oTMathF:Divide( "100000" , "12" ) )
 ConOut( "Divide : 100000 / 11 = " + oTMathF:Divide( "100000" , "11" ) )
 ConOut( "Divide : 100000 / 10 = " + oTMathF:Divide( "100000" , "10" ) )
 ConOut( "Divide : 100000 / 08 = " + oTMathF:Divide( "100000" , "08" ) )
 ConOut( "Divide : 100000 / 07 = " + oTMathF:Divide( "100000" , "07" ) )
 ConOut( "Divide : 100000 / 06 = " + oTMathF:Divide( "100000" , "06" ) )
 ConOut( "Divide : 100000 / 05 = " + oTMathF:Divide( "100000" , "05" ) )
 ConOut( "Divide : 100000 / 04 = " + oTMathF:Divide( "100000" , "04" ) )
 ConOut( "Divide : 100000 / 03 = " + oTMathF:Divide( "100000" , "03" ) )
 ConOut( "Divide : 100000 / 02 = " + oTMathF:Divide( "100000" , "02" ) )
 ConOut( "Divide : 100000 / 01 = " + oTMathF:Divide( "100000" , "01" ) )

 ConOut( "Divide : 1000000 / 95 = " + oTMathF:Divide( "1000000" , "95" ) )
 ConOut( "Divide : 1000000 / 85 = " + oTMathF:Divide( "1000000" , "85" ) )
 ConOut( "Divide : 1000000 / 75 = " + oTMathF:Divide( "1000000" , "75" ) )
 ConOut( "Divide : 1000000 / 65 = " + oTMathF:Divide( "1000000" , "65" ) )
 ConOut( "Divide : 1000000 / 55 = " + oTMathF:Divide( "1000000" , "55" ) )
 ConOut( "Divide : 1000000 / 45 = " + oTMathF:Divide( "1000000" , "45" ) )
 ConOut( "Divide : 1000000 / 35 = " + oTMathF:Divide( "1000000" , "35" ) )
 ConOut( "Divide : 1000000 / 25 = " + oTMathF:Divide( "1000000" , "25" ) )
 ConOut( "Divide : 1000000 / 15 = " + oTMathF:Divide( "1000000" , "15" ) )
 ConOut( "Divide : 1000000 / 14 = " + oTMathF:Divide( "1000000" , "14" ) )
 ConOut( "Divide : 1000000 / 13 = " + oTMathF:Divide( "1000000" , "13" ) )
 ConOut( "Divide : 1000000 / 12 = " + oTMathF:Divide( "1000000" , "12" ) )
 ConOut( "Divide : 1000000 / 11 = " + oTMathF:Divide( "1000000" , "11" ) )
 ConOut( "Divide : 1000000 / 10 = " + oTMathF:Divide( "1000000" , "10" ) )
 ConOut( "Divide : 1000000 / 08 = " + oTMathF:Divide( "1000000" , "08" ) )
 ConOut( "Divide : 1000000 / 07 = " + oTMathF:Divide( "1000000" , "07" ) )
 ConOut( "Divide : 1000000 / 06 = " + oTMathF:Divide( "1000000" , "06" ) )
 ConOut( "Divide : 1000000 / 05 = " + oTMathF:Divide( "1000000" , "05" ) )
 ConOut( "Divide : 1000000 / 04 = " + oTMathF:Divide( "1000000" , "04" ) )
 ConOut( "Divide : 1000000 / 03 = " + oTMathF:Divide( "1000000" , "03" ) )
 ConOut( "Divide : 1000000 / 02 = " + oTMathF:Divide( "1000000" , "02" ) )
 ConOut( "Divide : 1000000 / 01 = " + oTMathF:Divide( "1000000" , "01" ) )

 ConOut( "Divide : 10000000 / 95 = " + oTMathF:Divide( "10000000" , "95" ) )
 ConOut( "Divide : 10000000 / 85 = " + oTMathF:Divide( "10000000" , "85" ) )
 ConOut( "Divide : 10000000 / 75 = " + oTMathF:Divide( "10000000" , "75" ) )
 ConOut( "Divide : 10000000 / 65 = " + oTMathF:Divide( "10000000" , "65" ) )
 ConOut( "Divide : 10000000 / 55 = " + oTMathF:Divide( "10000000" , "55" ) )
 ConOut( "Divide : 10000000 / 45 = " + oTMathF:Divide( "10000000" , "45" ) )
 ConOut( "Divide : 10000000 / 35 = " + oTMathF:Divide( "10000000" , "35" ) )
 ConOut( "Divide : 10000000 / 25 = " + oTMathF:Divide( "10000000" , "25" ) )
 ConOut( "Divide : 10000000 / 15 = " + oTMathF:Divide( "10000000" , "15" ) )
 ConOut( "Divide : 10000000 / 14 = " + oTMathF:Divide( "10000000" , "14" ) )
 ConOut( "Divide : 10000000 / 13 = " + oTMathF:Divide( "10000000" , "13" ) )
 ConOut( "Divide : 10000000 / 12 = " + oTMathF:Divide( "10000000" , "12" ) )
 ConOut( "Divide : 10000000 / 11 = " + oTMathF:Divide( "10000000" , "11" ) )
 ConOut( "Divide : 10000000 / 10 = " + oTMathF:Divide( "10000000" , "10" ) )
 ConOut( "Divide : 10000000 / 08 = " + oTMathF:Divide( "10000000" , "08" ) )
 ConOut( "Divide : 10000000 / 07 = " + oTMathF:Divide( "10000000" , "07" ) )
 ConOut( "Divide : 10000000 / 06 = " + oTMathF:Divide( "10000000" , "06" ) )
 ConOut( "Divide : 10000000 / 05 = " + oTMathF:Divide( "10000000" , "05" ) )
 ConOut( "Divide : 10000000 / 04 = " + oTMathF:Divide( "10000000" , "04" ) )
 ConOut( "Divide : 10000000 / 03 = " + oTMathF:Divide( "10000000" , "03" ) )
 ConOut( "Divide : 10000000 / 02 = " + oTMathF:Divide( "10000000" , "02" ) )
 ConOut( "Divide : 10000000 / 01 = " + oTMathF:Divide( "10000000" , "01" ) )

 ConOut( "Divide : 100000000 / 95 = " + oTMathF:Divide( "100000000" , "95" ) )
 ConOut( "Divide : 100000000 / 85 = " + oTMathF:Divide( "100000000" , "85" ) )
 ConOut( "Divide : 100000000 / 75 = " + oTMathF:Divide( "100000000" , "75" ) )
 ConOut( "Divide : 100000000 / 65 = " + oTMathF:Divide( "100000000" , "65" ) )
 ConOut( "Divide : 100000000 / 55 = " + oTMathF:Divide( "100000000" , "55" ) )
 ConOut( "Divide : 100000000 / 45 = " + oTMathF:Divide( "100000000" , "45" ) )
 ConOut( "Divide : 100000000 / 35 = " + oTMathF:Divide( "100000000" , "35" ) )
 ConOut( "Divide : 100000000 / 25 = " + oTMathF:Divide( "100000000" , "25" ) )
 ConOut( "Divide : 100000000 / 15 = " + oTMathF:Divide( "100000000" , "15" ) )
 ConOut( "Divide : 100000000 / 14 = " + oTMathF:Divide( "100000000" , "14" ) )
 ConOut( "Divide : 100000000 / 13 = " + oTMathF:Divide( "100000000" , "13" ) )
 ConOut( "Divide : 100000000 / 12 = " + oTMathF:Divide( "100000000" , "12" ) )
 ConOut( "Divide : 100000000 / 11 = " + oTMathF:Divide( "100000000" , "11" ) )
 ConOut( "Divide : 100000000 / 10 = " + oTMathF:Divide( "100000000" , "10" ) )
 ConOut( "Divide : 100000000 / 08 = " + oTMathF:Divide( "100000000" , "08" ) )
 ConOut( "Divide : 100000000 / 07 = " + oTMathF:Divide( "100000000" , "07" ) )
 ConOut( "Divide : 100000000 / 06 = " + oTMathF:Divide( "100000000" , "06" ) )
 ConOut( "Divide : 100000000 / 05 = " + oTMathF:Divide( "100000000" , "05" ) )
 ConOut( "Divide : 100000000 / 04 = " + oTMathF:Divide( "100000000" , "04" ) )
 ConOut( "Divide : 100000000 / 03 = " + oTMathF:Divide( "100000000" , "03" ) )
 ConOut( "Divide : 100000000 / 02 = " + oTMathF:Divide( "100000000" , "02" ) )
 ConOut( "Divide : 100000000 / 01 = " + oTMathF:Divide( "100000000" , "01" ) )

 ConOut( "Divide : 1000000000 / 95 = " + oTMathF:Divide( "1000000000" , "95" ) )
 ConOut( "Divide : 1000000000 / 85 = " + oTMathF:Divide( "1000000000" , "85" ) )
 ConOut( "Divide : 1000000000 / 75 = " + oTMathF:Divide( "1000000000" , "75" ) )
 ConOut( "Divide : 1000000000 / 65 = " + oTMathF:Divide( "1000000000" , "65" ) )
 ConOut( "Divide : 1000000000 / 55 = " + oTMathF:Divide( "1000000000" , "55" ) )
 ConOut( "Divide : 1000000000 / 45 = " + oTMathF:Divide( "1000000000" , "45" ) )
 ConOut( "Divide : 1000000000 / 35 = " + oTMathF:Divide( "1000000000" , "35" ) )
 ConOut( "Divide : 1000000000 / 25 = " + oTMathF:Divide( "1000000000" , "25" ) )
 ConOut( "Divide : 1000000000 / 15 = " + oTMathF:Divide( "1000000000" , "15" ) )
 ConOut( "Divide : 1000000000 / 14 = " + oTMathF:Divide( "1000000000" , "14" ) )
 ConOut( "Divide : 1000000000 / 13 = " + oTMathF:Divide( "1000000000" , "13" ) )
 ConOut( "Divide : 1000000000 / 12 = " + oTMathF:Divide( "1000000000" , "12" ) )
 ConOut( "Divide : 1000000000 / 11 = " + oTMathF:Divide( "1000000000" , "11" ) )
 ConOut( "Divide : 1000000000 / 10 = " + oTMathF:Divide( "1000000000" , "10" ) )
 ConOut( "Divide : 1000000000 / 08 = " + oTMathF:Divide( "1000000000" , "08" ) )
 ConOut( "Divide : 1000000000 / 07 = " + oTMathF:Divide( "1000000000" , "07" ) )
 ConOut( "Divide : 1000000000 / 06 = " + oTMathF:Divide( "1000000000" , "06" ) )
 ConOut( "Divide : 1000000000 / 05 = " + oTMathF:Divide( "1000000000" , "05" ) )
 ConOut( "Divide : 1000000000 / 04 = " + oTMathF:Divide( "1000000000" , "04" ) )
 ConOut( "Divide : 1000000000 / 03 = " + oTMathF:Divide( "1000000000" , "03" ) )
 ConOut( "Divide : 1000000000 / 02 = " + oTMathF:Divide( "1000000000" , "02" ) )
 ConOut( "Divide : 1000000000 / 01 = " + oTMathF:Divide( "1000000000" , "01" ) )

 ConOut( "Divide : 10000000000 / 95 = " + oTMathF:Divide( "10000000000" , "95" ) )
 ConOut( "Divide : 10000000000 / 85 = " + oTMathF:Divide( "10000000000" , "85" ) )
 ConOut( "Divide : 10000000000 / 75 = " + oTMathF:Divide( "10000000000" , "75" ) )
 ConOut( "Divide : 10000000000 / 65 = " + oTMathF:Divide( "10000000000" , "65" ) )
 ConOut( "Divide : 10000000000 / 55 = " + oTMathF:Divide( "10000000000" , "55" ) )
 ConOut( "Divide : 10000000000 / 45 = " + oTMathF:Divide( "10000000000" , "45" ) )
 ConOut( "Divide : 10000000000 / 35 = " + oTMathF:Divide( "10000000000" , "35" ) )
 ConOut( "Divide : 10000000000 / 25 = " + oTMathF:Divide( "10000000000" , "25" ) )
 ConOut( "Divide : 10000000000 / 15 = " + oTMathF:Divide( "10000000000" , "15" ) )
 ConOut( "Divide : 10000000000 / 14 = " + oTMathF:Divide( "10000000000" , "14" ) )
 ConOut( "Divide : 10000000000 / 13 = " + oTMathF:Divide( "10000000000" , "13" ) )
 ConOut( "Divide : 10000000000 / 12 = " + oTMathF:Divide( "10000000000" , "12" ) )
 ConOut( "Divide : 10000000000 / 11 = " + oTMathF:Divide( "10000000000" , "11" ) )
 ConOut( "Divide : 10000000000 / 10 = " + oTMathF:Divide( "10000000000" , "10" ) )
 ConOut( "Divide : 10000000000 / 08 = " + oTMathF:Divide( "10000000000" , "08" ) )
 ConOut( "Divide : 10000000000 / 07 = " + oTMathF:Divide( "10000000000" , "07" ) )
 ConOut( "Divide : 10000000000 / 06 = " + oTMathF:Divide( "10000000000" , "06" ) )
 ConOut( "Divide : 10000000000 / 05 = " + oTMathF:Divide( "10000000000" , "05" ) )
 ConOut( "Divide : 10000000000 / 04 = " + oTMathF:Divide( "10000000000" , "04" ) )
 ConOut( "Divide : 10000000000 / 03 = " + oTMathF:Divide( "10000000000" , "03" ) )
 ConOut( "Divide : 10000000000 / 02 = " + oTMathF:Divide( "10000000000" , "02" ) )
 ConOut( "Divide : 10000000000 / 01 = " + oTMathF:Divide( "10000000000" , "01" ) )

 ConOut( "Divide : 100000000000 / 95 = " + oTMathF:Divide( "100000000000" , "95" ) )
 ConOut( "Divide : 100000000000 / 85 = " + oTMathF:Divide( "100000000000" , "85" ) )
 ConOut( "Divide : 100000000000 / 75 = " + oTMathF:Divide( "100000000000" , "75" ) )
 ConOut( "Divide : 100000000000 / 65 = " + oTMathF:Divide( "100000000000" , "65" ) )
 ConOut( "Divide : 100000000000 / 55 = " + oTMathF:Divide( "100000000000" , "55" ) )
 ConOut( "Divide : 100000000000 / 45 = " + oTMathF:Divide( "100000000000" , "45" ) )
 ConOut( "Divide : 100000000000 / 35 = " + oTMathF:Divide( "100000000000" , "35" ) )
 ConOut( "Divide : 100000000000 / 25 = " + oTMathF:Divide( "100000000000" , "25" ) )
 ConOut( "Divide : 100000000000 / 15 = " + oTMathF:Divide( "100000000000" , "15" ) )
 ConOut( "Divide : 100000000000 / 14 = " + oTMathF:Divide( "100000000000" , "14" ) )
 ConOut( "Divide : 100000000000 / 13 = " + oTMathF:Divide( "100000000000" , "13" ) )
 ConOut( "Divide : 100000000000 / 12 = " + oTMathF:Divide( "100000000000" , "12" ) )
 ConOut( "Divide : 100000000000 / 11 = " + oTMathF:Divide( "100000000000" , "11" ) )
 ConOut( "Divide : 100000000000 / 10 = " + oTMathF:Divide( "100000000000" , "10" ) )
 ConOut( "Divide : 100000000000 / 08 = " + oTMathF:Divide( "100000000000" , "08" ) )
 ConOut( "Divide : 100000000000 / 07 = " + oTMathF:Divide( "100000000000" , "07" ) )
 ConOut( "Divide : 100000000000 / 06 = " + oTMathF:Divide( "100000000000" , "06" ) )
 ConOut( "Divide : 100000000000 / 05 = " + oTMathF:Divide( "100000000000" , "05" ) )
 ConOut( "Divide : 100000000000 / 04 = " + oTMathF:Divide( "100000000000" , "04" ) )
 ConOut( "Divide : 100000000000 / 03 = " + oTMathF:Divide( "100000000000" , "03" ) )
 ConOut( "Divide : 100000000000 / 02 = " + oTMathF:Divide( "100000000000" , "02" ) )
 ConOut( "Divide : 100000000000 / 01 = " + oTMathF:Divide( "100000000000" , "01" ) )

 ConOut( "Divide : 1000000000000 / 95 = " + oTMathF:Divide( "1000000000000" , "95" ) )
 ConOut( "Divide : 1000000000000 / 85 = " + oTMathF:Divide( "1000000000000" , "85" ) )
 ConOut( "Divide : 1000000000000 / 75 = " + oTMathF:Divide( "1000000000000" , "75" ) )
 ConOut( "Divide : 1000000000000 / 65 = " + oTMathF:Divide( "1000000000000" , "65" ) )
 ConOut( "Divide : 1000000000000 / 55 = " + oTMathF:Divide( "1000000000000" , "55" ) )
 ConOut( "Divide : 1000000000000 / 45 = " + oTMathF:Divide( "1000000000000" , "45" ) )
 ConOut( "Divide : 1000000000000 / 35 = " + oTMathF:Divide( "1000000000000" , "35" ) )
 ConOut( "Divide : 1000000000000 / 25 = " + oTMathF:Divide( "1000000000000" , "25" ) )
 ConOut( "Divide : 1000000000000 / 15 = " + oTMathF:Divide( "1000000000000" , "15" ) )
 ConOut( "Divide : 1000000000000 / 14 = " + oTMathF:Divide( "1000000000000" , "14" ) )
 ConOut( "Divide : 1000000000000 / 13 = " + oTMathF:Divide( "1000000000000" , "13" ) )
 ConOut( "Divide : 1000000000000 / 12 = " + oTMathF:Divide( "1000000000000" , "12" ) )
 ConOut( "Divide : 1000000000000 / 11 = " + oTMathF:Divide( "1000000000000" , "11" ) )
 ConOut( "Divide : 1000000000000 / 10 = " + oTMathF:Divide( "1000000000000" , "10" ) )
 ConOut( "Divide : 1000000000000 / 08 = " + oTMathF:Divide( "1000000000000" , "08" ) )
 ConOut( "Divide : 1000000000000 / 07 = " + oTMathF:Divide( "1000000000000" , "07" ) )
 ConOut( "Divide : 1000000000000 / 06 = " + oTMathF:Divide( "1000000000000" , "06" ) )
 ConOut( "Divide : 1000000000000 / 05 = " + oTMathF:Divide( "1000000000000" , "05" ) )
 ConOut( "Divide : 1000000000000 / 04 = " + oTMathF:Divide( "1000000000000" , "04" ) )
 ConOut( "Divide : 1000000000000 / 03 = " + oTMathF:Divide( "1000000000000" , "03" ) )
 ConOut( "Divide : 1000000000000 / 02 = " + oTMathF:Divide( "1000000000000" , "02" ) )
 ConOut( "Divide : 1000000000000 / 01 = " + oTMathF:Divide( "1000000000000" , "01" ) )

 ConOut( "Divide : 10000000000000 / 95 = " + oTMathF:Divide( "10000000000000" , "95" ) )
 ConOut( "Divide : 10000000000000 / 85 = " + oTMathF:Divide( "10000000000000" , "85" ) )
 ConOut( "Divide : 10000000000000 / 75 = " + oTMathF:Divide( "10000000000000" , "75" ) )
 ConOut( "Divide : 10000000000000 / 65 = " + oTMathF:Divide( "10000000000000" , "65" ) )
 ConOut( "Divide : 10000000000000 / 55 = " + oTMathF:Divide( "10000000000000" , "55" ) )
 ConOut( "Divide : 10000000000000 / 45 = " + oTMathF:Divide( "10000000000000" , "45" ) )
 ConOut( "Divide : 10000000000000 / 35 = " + oTMathF:Divide( "10000000000000" , "35" ) )
 ConOut( "Divide : 10000000000000 / 25 = " + oTMathF:Divide( "10000000000000" , "25" ) )
 ConOut( "Divide : 10000000000000 / 15 = " + oTMathF:Divide( "10000000000000" , "15" ) )
 ConOut( "Divide : 10000000000000 / 14 = " + oTMathF:Divide( "10000000000000" , "14" ) )
 ConOut( "Divide : 10000000000000 / 13 = " + oTMathF:Divide( "10000000000000" , "13" ) )
 ConOut( "Divide : 10000000000000 / 12 = " + oTMathF:Divide( "10000000000000" , "12" ) )
 ConOut( "Divide : 10000000000000 / 11 = " + oTMathF:Divide( "10000000000000" , "11" ) )
 ConOut( "Divide : 10000000000000 / 10 = " + oTMathF:Divide( "10000000000000" , "10" ) )
 ConOut( "Divide : 10000000000000 / 08 = " + oTMathF:Divide( "10000000000000" , "08" ) )
 ConOut( "Divide : 10000000000000 / 07 = " + oTMathF:Divide( "10000000000000" , "07" ) )
 ConOut( "Divide : 10000000000000 / 06 = " + oTMathF:Divide( "10000000000000" , "06" ) )
 ConOut( "Divide : 10000000000000 / 05 = " + oTMathF:Divide( "10000000000000" , "05" ) )
 ConOut( "Divide : 10000000000000 / 04 = " + oTMathF:Divide( "10000000000000" , "04" ) )
 ConOut( "Divide : 10000000000000 / 03 = " + oTMathF:Divide( "10000000000000" , "03" ) )
 ConOut( "Divide : 10000000000000 / 02 = " + oTMathF:Divide( "10000000000000" , "02" ) )
 ConOut( "Divide : 10000000000000 / 01 = " + oTMathF:Divide( "10000000000000" , "01" ) )

 ConOut( "Divide : 100000000000000 / 95 = " + oTMathF:Divide( "100000000000000" , "95" ) )
 ConOut( "Divide : 100000000000000 / 85 = " + oTMathF:Divide( "100000000000000" , "85" ) )
 ConOut( "Divide : 100000000000000 / 75 = " + oTMathF:Divide( "100000000000000" , "75" ) )
 ConOut( "Divide : 100000000000000 / 65 = " + oTMathF:Divide( "100000000000000" , "65" ) )
 ConOut( "Divide : 100000000000000 / 55 = " + oTMathF:Divide( "100000000000000" , "55" ) )
 ConOut( "Divide : 100000000000000 / 45 = " + oTMathF:Divide( "100000000000000" , "45" ) )
 ConOut( "Divide : 100000000000000 / 35 = " + oTMathF:Divide( "100000000000000" , "35" ) )
 ConOut( "Divide : 100000000000000 / 25 = " + oTMathF:Divide( "100000000000000" , "25" ) )
 ConOut( "Divide : 100000000000000 / 15 = " + oTMathF:Divide( "100000000000000" , "15" ) )
 ConOut( "Divide : 100000000000000 / 14 = " + oTMathF:Divide( "100000000000000" , "14" ) )
 ConOut( "Divide : 100000000000000 / 13 = " + oTMathF:Divide( "100000000000000" , "13" ) )
 ConOut( "Divide : 100000000000000 / 12 = " + oTMathF:Divide( "100000000000000" , "12" ) )
 ConOut( "Divide : 100000000000000 / 11 = " + oTMathF:Divide( "100000000000000" , "11" ) )
 ConOut( "Divide : 100000000000000 / 10 = " + oTMathF:Divide( "100000000000000" , "10" ) )
 ConOut( "Divide : 100000000000000 / 08 = " + oTMathF:Divide( "100000000000000" , "08" ) )
 ConOut( "Divide : 100000000000000 / 07 = " + oTMathF:Divide( "100000000000000" , "07" ) )
 ConOut( "Divide : 100000000000000 / 06 = " + oTMathF:Divide( "100000000000000" , "06" ) )
 ConOut( "Divide : 100000000000000 / 05 = " + oTMathF:Divide( "100000000000000" , "05" ) )
 ConOut( "Divide : 100000000000000 / 04 = " + oTMathF:Divide( "100000000000000" , "04" ) )
 ConOut( "Divide : 100000000000000 / 03 = " + oTMathF:Divide( "100000000000000" , "03" ) )
 ConOut( "Divide : 100000000000000 / 02 = " + oTMathF:Divide( "100000000000000" , "02" ) )
 ConOut( "Divide : 100000000000000 / 01 = " + oTMathF:Divide( "100000000000000" , "01" ) )

 ConOut( "Divide : 1000000000000000 / 95 = " + oTMathF:Divide( "1000000000000000" , "95" ) )
 ConOut( "Divide : 1000000000000000 / 85 = " + oTMathF:Divide( "1000000000000000" , "85" ) )
 ConOut( "Divide : 1000000000000000 / 75 = " + oTMathF:Divide( "1000000000000000" , "75" ) )
 ConOut( "Divide : 1000000000000000 / 65 = " + oTMathF:Divide( "1000000000000000" , "65" ) )
 ConOut( "Divide : 1000000000000000 / 55 = " + oTMathF:Divide( "1000000000000000" , "55" ) )
 ConOut( "Divide : 1000000000000000 / 45 = " + oTMathF:Divide( "1000000000000000" , "45" ) )
 ConOut( "Divide : 1000000000000000 / 35 = " + oTMathF:Divide( "1000000000000000" , "35" ) )
 ConOut( "Divide : 1000000000000000 / 25 = " + oTMathF:Divide( "1000000000000000" , "25" ) )
 ConOut( "Divide : 1000000000000000 / 15 = " + oTMathF:Divide( "1000000000000000" , "15" ) )
 ConOut( "Divide : 1000000000000000 / 14 = " + oTMathF:Divide( "1000000000000000" , "14" ) )
 ConOut( "Divide : 1000000000000000 / 13 = " + oTMathF:Divide( "1000000000000000" , "13" ) )
 ConOut( "Divide : 1000000000000000 / 12 = " + oTMathF:Divide( "1000000000000000" , "12" ) )
 ConOut( "Divide : 1000000000000000 / 11 = " + oTMathF:Divide( "1000000000000000" , "11" ) )
 ConOut( "Divide : 1000000000000000 / 10 = " + oTMathF:Divide( "1000000000000000" , "10" ) )
 ConOut( "Divide : 1000000000000000 / 08 = " + oTMathF:Divide( "1000000000000000" , "08" ) )
 ConOut( "Divide : 1000000000000000 / 07 = " + oTMathF:Divide( "1000000000000000" , "07" ) )
 ConOut( "Divide : 1000000000000000 / 06 = " + oTMathF:Divide( "1000000000000000" , "06" ) )
 ConOut( "Divide : 1000000000000000 / 05 = " + oTMathF:Divide( "1000000000000000" , "05" ) )
 ConOut( "Divide : 1000000000000000 / 04 = " + oTMathF:Divide( "1000000000000000" , "04" ) )
 ConOut( "Divide : 1000000000000000 / 03 = " + oTMathF:Divide( "1000000000000000" , "03" ) )
 ConOut( "Divide : 1000000000000000 / 02 = " + oTMathF:Divide( "1000000000000000" , "02" ) )
 ConOut( "Divide : 1000000000000000 / 01 = " + oTMathF:Divide( "1000000000000000" , "01" ) )

 ConOut( "Divide : 10000000000000000 / 95 = " + oTMathF:Divide( "10000000000000000" , "95" ) )
 ConOut( "Divide : 10000000000000000 / 85 = " + oTMathF:Divide( "10000000000000000" , "85" ) )
 ConOut( "Divide : 10000000000000000 / 75 = " + oTMathF:Divide( "10000000000000000" , "75" ) )
 ConOut( "Divide : 10000000000000000 / 65 = " + oTMathF:Divide( "10000000000000000" , "65" ) )
 ConOut( "Divide : 10000000000000000 / 55 = " + oTMathF:Divide( "10000000000000000" , "55" ) )
 ConOut( "Divide : 10000000000000000 / 45 = " + oTMathF:Divide( "10000000000000000" , "45" ) )
 ConOut( "Divide : 10000000000000000 / 35 = " + oTMathF:Divide( "10000000000000000" , "35" ) )
 ConOut( "Divide : 10000000000000000 / 25 = " + oTMathF:Divide( "10000000000000000" , "25" ) )
 ConOut( "Divide : 10000000000000000 / 15 = " + oTMathF:Divide( "10000000000000000" , "15" ) )
 ConOut( "Divide : 10000000000000000 / 14 = " + oTMathF:Divide( "10000000000000000" , "14" ) )
 ConOut( "Divide : 10000000000000000 / 13 = " + oTMathF:Divide( "10000000000000000" , "13" ) )
 ConOut( "Divide : 10000000000000000 / 12 = " + oTMathF:Divide( "10000000000000000" , "12" ) )
 ConOut( "Divide : 10000000000000000 / 11 = " + oTMathF:Divide( "10000000000000000" , "11" ) )
 ConOut( "Divide : 10000000000000000 / 10 = " + oTMathF:Divide( "10000000000000000" , "10" ) )
 ConOut( "Divide : 10000000000000000 / 08 = " + oTMathF:Divide( "10000000000000000" , "08" ) )
 ConOut( "Divide : 10000000000000000 / 07 = " + oTMathF:Divide( "10000000000000000" , "07" ) )
 ConOut( "Divide : 10000000000000000 / 06 = " + oTMathF:Divide( "10000000000000000" , "06" ) )
 ConOut( "Divide : 10000000000000000 / 05 = " + oTMathF:Divide( "10000000000000000" , "05" ) )
 ConOut( "Divide : 10000000000000000 / 04 = " + oTMathF:Divide( "10000000000000000" , "04" ) )
 ConOut( "Divide : 10000000000000000 / 03 = " + oTMathF:Divide( "10000000000000000" , "03" ) )
 ConOut( "Divide : 10000000000000000 / 02 = " + oTMathF:Divide( "10000000000000000" , "02" ) )
 ConOut( "Divide : 10000000000000000 / 01 = " + oTMathF:Divide( "10000000000000000" , "01" ) )

 ConOut( "Divide : 10000000000000000000000 / 95 = " + oTMathF:Divide( "10000000000000000000000" , "95" ) )
 ConOut( "Divide : 10000000000000000000000 / 85 = " + oTMathF:Divide( "10000000000000000000000" , "85" ) )
 ConOut( "Divide : 10000000000000000000000 / 75 = " + oTMathF:Divide( "10000000000000000000000" , "75" ) )
 ConOut( "Divide : 10000000000000000000000 / 65 = " + oTMathF:Divide( "10000000000000000000000" , "65" ) )
 ConOut( "Divide : 10000000000000000000000 / 55 = " + oTMathF:Divide( "10000000000000000000000" , "55" ) )
 ConOut( "Divide : 10000000000000000000000 / 45 = " + oTMathF:Divide( "10000000000000000000000" , "45" ) )
 ConOut( "Divide : 10000000000000000000000 / 35 = " + oTMathF:Divide( "10000000000000000000000" , "35" ) )
 ConOut( "Divide : 10000000000000000000000 / 25 = " + oTMathF:Divide( "10000000000000000000000" , "25" ) )
 ConOut( "Divide : 10000000000000000000000 / 15 = " + oTMathF:Divide( "10000000000000000000000" , "15" ) )
 ConOut( "Divide : 10000000000000000000000 / 14 = " + oTMathF:Divide( "10000000000000000000000" , "14" ) )
 ConOut( "Divide : 10000000000000000000000 / 13 = " + oTMathF:Divide( "10000000000000000000000" , "13" ) )
 ConOut( "Divide : 10000000000000000000000 / 12 = " + oTMathF:Divide( "10000000000000000000000" , "12" ) )
 ConOut( "Divide : 10000000000000000000000 / 11 = " + oTMathF:Divide( "10000000000000000000000" , "11" ) )
 ConOut( "Divide : 10000000000000000000000 / 10 = " + oTMathF:Divide( "10000000000000000000000" , "10" ) )
 ConOut( "Divide : 10000000000000000000000 / 08 = " + oTMathF:Divide( "10000000000000000000000" , "08" ) )
 ConOut( "Divide : 10000000000000000000000 / 07 = " + oTMathF:Divide( "10000000000000000000000" , "07" ) )
 ConOut( "Divide : 10000000000000000000000 / 06 = " + oTMathF:Divide( "10000000000000000000000" , "06" ) )
 ConOut( "Divide : 10000000000000000000000 / 05 = " + oTMathF:Divide( "10000000000000000000000" , "05" ) )
 ConOut( "Divide : 10000000000000000000000 / 04 = " + oTMathF:Divide( "10000000000000000000000" , "04" ) )
 ConOut( "Divide : 10000000000000000000000 / 03 = " + oTMathF:Divide( "10000000000000000000000" , "03" ) )
 ConOut( "Divide : 10000000000000000000000 / 02 = " + oTMathF:Divide( "10000000000000000000000" , "02" ) )
 ConOut( "Divide : 10000000000000000000000 / 01 = " + oTMathF:Divide( "10000000000000000000000" , "01" ) )

 ConOut( "Divide : 98765432198.765432198765 / 95 = " + oTMathF:Divide( "98765432198.765432198765" , "95" ) )
 ConOut( "Divide : 98765432198.765432198765 / 85 = " + oTMathF:Divide( "98765432198.765432198765" , "85" ) )
 ConOut( "Divide : 98765432198.765432198765 / 75 = " + oTMathF:Divide( "98765432198.765432198765" , "75" ) )
 ConOut( "Divide : 98765432198.765432198765 / 65 = " + oTMathF:Divide( "98765432198.765432198765" , "65" ) )
 ConOut( "Divide : 98765432198.765432198765 / 55 = " + oTMathF:Divide( "98765432198.765432198765" , "55" ) )
 ConOut( "Divide : 98765432198.765432198765 / 45 = " + oTMathF:Divide( "98765432198.765432198765" , "45" ) )
 ConOut( "Divide : 98765432198.765432198765 / 35 = " + oTMathF:Divide( "98765432198.765432198765" , "35" ) )
 ConOut( "Divide : 98765432198.765432198765 / 25 = " + oTMathF:Divide( "98765432198.765432198765" , "25" ) )
 ConOut( "Divide : 98765432198.765432198765 / 15 = " + oTMathF:Divide( "98765432198.765432198765" , "15" ) )
 ConOut( "Divide : 98765432198.765432198765 / 14 = " + oTMathF:Divide( "98765432198.765432198765" , "14" ) )
 ConOut( "Divide : 98765432198.765432198765 / 13 = " + oTMathF:Divide( "98765432198.765432198765" , "13" ) )
 ConOut( "Divide : 98765432198.765432198765 / 12 = " + oTMathF:Divide( "98765432198.765432198765" , "12" ) )
 ConOut( "Divide : 98765432198.765432198765 / 11 = " + oTMathF:Divide( "98765432198.765432198765" , "11" ) )
 ConOut( "Divide : 98765432198.765432198765 / 10 = " + oTMathF:Divide( "98765432198.765432198765" , "10" ) )
 ConOut( "Divide : 98765432198.765432198765 / 08 = " + oTMathF:Divide( "98765432198.765432198765" , "08" ) )
 ConOut( "Divide : 98765432198.765432198765 / 07 = " + oTMathF:Divide( "98765432198.765432198765" , "07" ) )
 ConOut( "Divide : 98765432198.765432198765 / 06 = " + oTMathF:Divide( "98765432198.765432198765" , "06" ) )
 ConOut( "Divide : 98765432198.765432198765 / 05 = " + oTMathF:Divide( "98765432198.765432198765" , "05" ) )
 ConOut( "Divide : 98765432198.765432198765 / 04 = " + oTMathF:Divide( "98765432198.765432198765" , "04" ) )
 ConOut( "Divide : 98765432198.765432198765 / 03 = " + oTMathF:Divide( "98765432198.765432198765" , "03" ) )
 ConOut( "Divide : 98765432198.765432198765 / 02 = " + oTMathF:Divide( "98765432198.765432198765" , "02" ) )
 ConOut( "Divide : 98765432198.765432198765 / 01 = " + oTMathF:Divide( "98765432198.765432198765" , "01" ) )

 ConOut( "Divide : 123456789.123456789 / 123456789 = " + oTMathF:Divide( "123456789.123456789" , "123456789" ) )
 ConOut( "Divide : 1234567891.23456789 / 123456789123456789 = " + oTMathF:Divide( "1234567891.23456789" , "123456789123456789" ) )
 ConOut( "Divide : 123456789123456.789123456789123456789 / 123456789123456789 = " + oTMathF:Divide( "123456789123456.789123456789123456789" , "123456789123456789" ) )
 ConOut( "Divide : 1234567891234567891234567891.23456789123456789123456789123456789123456789 / 123456789123456789123456789123456789 =  " + oTMathF:Divide( "1234567891234567891234567891.23456789123456789123456789123456789123456789" , "123456789123456789123456789123456789" ) )
 ConOut( "Divide : 12345678912345678912345678912345.6789123456789123456789123456789123456789 / 123456789123456789123456789123456789123456789123456789123456789123456789 =  " + oTMathF:Divide( "12345678912345678912345678912345.6789123456789123456789123456789123456789" , "123456789123456789123456789123456789123456789123456789123456789123456789" ) )
 ConOut( "Divide : 1234567891234567891234567891234.56789 / 123456789123456789123456789123456789 = " + oTMathF:Divide( "1234567891234567891234567891234.56789" , "123456789123456789123456789123456789" ) )

Return( oTMathF )
Bem,  ansiedade saciada, agora vou, com calma, implementar os demais métodos e buscar a Otimização dos demais. Convido-os a fazer o mesmo. Bom divertimento. Para baixar o código original, os exemplos e o "Clipper Header", Clique aqui.

[]s иαldσ dj

2 comentários:

  1. Por acaso você baixou a apostila desse canal:
    [ADVPL] - Treinamento TOTVS ADVPL (Material Oficial Certificação).rar

    http://advpl.4shared.com

    ResponderExcluir
  2. Dica Marota!

    Utilizando o exemplo

    Ex: int(80.10*100)

    Teremos como retorno o arrendondamento errado do valor para 8009.

    SOLUÇÃO: Houve uma melhoria - Aumento da precisão aritmética e arredondamento.
    A build 7.00.101202A permite uma configuração diferenciada, para configurar um tratamento enfático de precisão em cálculos com ponto flutuante, que interferem diretamente com o uso das funções de arredondamento Round(), NoRound() e INT().
    A utilização da nova implementação aritmética deve ser feita explicitamente no arquivo de configuração do TOTVSAPPSERVER, inserindo na seção [GENERAL] a chave FloatingPointPrecise=1.

    {}'s

    Podia ser criada uma seÇão no blog de dicas marotas. Seria um lugar de dicas, microsoluções usuais no dia-a-dia.
    [Fica a sugestao]

    ResponderExcluir