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