PC Toledo

Código: Selecionar todos

chcp 65001

Código: Selecionar todos

>nul 2>&1 chcp 1252

>nul 2>&1 chcp 65001

Código: Selecionar todos

#include "hbclass.ch"

CLASS Megusta
   METHOD New() CONSTRUCTOR

   METHOD rPrint( cMessage )
   METHOD rPrintln( cMessage )
   METHOD rInput( cPrompt )
   METHOD rSaveFile( cArquivo, cConteudo )
   METHOD rOpenFile( cArquivo )
   METHOD rOpenProgram( cPrograma )
   METHOD rOpenFileWeb( cArquivo )
   METHOD strReplace( cOriginal, cVar1, cVar2 )
   METHOD strLength( cString )
   METHOD strSubstring( cString, nInicio, nFim )
   METHOD strCharAt( cString, nPos )
   METHOD strIndexOf(cadeia, subcadeia)
   METHOD strLastIndexOf(cadeia, subcadeia)
   METHOD strToLowerCase( cString )
   METHOD strToUpperCase( cString )
   METHOD strEquals( c1, c2 )
   METHOD strEqualsIgnoreCase( c1, c2 )
   METHOD strCompareTo(cadeia1, cadeia2)
   METHOD strCompareToIgnoreCase(cadeia1, cadeia2)
   METHOD strConcat( ... )
   METHOD strStartsWith( cString, cPrefix )
   METHOD strEndsWith( cString, cSuffix )
   METHOD strIncludes( cString, cSub )
   METHOD strSplit( cString, cDelimiter )
   METHOD strPadStart( cString, nLen, cPad )
   METHOD strPadEnd( cString, nLen, cPad )
   METHOD strRepeat( cString, nTimes )
   METHOD strSearch( cString, cSub )
   METHOD strTrim( cString )
   METHOD strTrimStart( cString )
   METHOD strTrimEnd( cString )
   METHOD strSlice( cString, nStart, nEnd )
   METHOD dateDay()
   METHOD dateWeekDay()
   METHOD dateMonth()
   METHOD dateYear()
   METHOD dateSetWeekDay( nAno, nMes, nDia )
   METHOD dateHour24()
   METHOD dateMinute()
   METHOD dateSecond()
   METHOD xArrLength( aLista )
   METHOD arrAddAll( aLista, ... )
   METHOD arrAdd( aLista, xValor )
   METHOD arrAddPos( aLista, nPos, xValor )
   METHOD arrSet( aLista, nPos, xValor )
   METHOD arrGet( aLista, nPos )
   METHOD arrSize( aLista )
   METHOD arrRemove( aLista, nPos )
   METHOD arrClear( aLista )
   METHOD arrContains( aLista, xValor )
   METHOD arrIndexOf( aLista, xValor )
   METHOD arrLastIndexOf( aLista, xValor )
   METHOD mathInt( cNumero )
   METHOD mathNum( cNumero )
   METHOD mathBool( cValor )
   METHOD mathFloor( n )
   METHOD mathCeil( n )
   METHOD mathRound( n )
   METHOD mathDecimalFormat( nNumero, cMascara )
   METHOD mathNumberFormat( nNumero, cLocale, cCountry )
   METHOD mathRandom()
   METHOD mathAbs( n )
   METHOD mathMax( n1, n2 )
   METHOD mathMin( n1, n2 )
   METHOD mathPow( base, expo )
   METHOD mathSqrt( n )
   METHOD mathCbrt( n )
   METHOD mathSignum( n )
   METHOD mathPI()
   METHOD mathConvertToRadians( graus )
   METHOD normalizeAngle(x)
   METHOD mathSin(x)
   METHOD mathCos(x)
   METHOD mathTan(x)
   METHOD mathAsin(x)
   METHOD mathAcos(x)
   METHOD mathAtan(x)
   METHOD mathSinh(x)
   METHOD mathCosh(x)
   METHOD mathTanh(x)
   METHOD mathAsinh(x)
   METHOD mathAcosh(x)
   METHOD mathAtanh(x)
   METHOD mathLog( nNumero )
   METHOD mathLog10( nNumero )
   METHOD mathLog2( nNumero )
   METHOD mathExp( nExpoente )
   METHOD mathLog1p( n )
   METHOD mathE()
   METHOD mathLN2()
   METHOD mathLOG2E()
   METHOD mathLN10()
   METHOD mathLOG10E()
   METHOD mathSQRT1_2()
   METHOD mathSQRT2()
   METHOD mathMaxArr( ... )
   METHOD mathMinArr( ... )
ENDCLASS


METHOD New() CLASS Megusta
return Self
/*
PROCEDURE Main

LOCAL x := 1.2

? "sin:", mathSin(x)
? "cos:", mathCos(x)
? "tan:", mathTan(x)

? "log:", mathLog(10)
? "log2:", mathLog2(8)

? "exp:", mathExp(2)

RETURN
*/
/* Megusta.prg */


/* =========================
   PRINT / INPUT
   ========================= */

METHOD rPrint( cMessage ) CLASS Megusta
   ?? cMessage
RETURN NIL

METHOD rPrintln( cMessage ) CLASS Megusta
   IF cMessage != NIL
      ?? cMessage         // Com quebra de linha
      ? ""
   ELSE 
      ? ""
   ENDIF
RETURN NIL

METHOD rInput( cPrompt ) CLASS Megusta
   LOCAL cValue := ""
   ?? cPrompt         // Exibe o prompt sem quebra de linha
   ACCEPT TO cValue   // Lê a entrada do usuário
   ? ""
RETURN cValue

/* =========================
   FILE
   ========================= */

METHOD rSaveFile( cArquivo, cConteudo ) CLASS Megusta
   LOCAL nHandle := FCreate( cArquivo )

   IF nHandle < 0
      ? "Erro ao criar arquivo."
      RETURN NIL
   ENDIF

   FWrite( nHandle, cConteudo )
   FClose( nHandle )

   ? "Arquivo", cArquivo, "salvo com sucesso."
RETURN NIL

METHOD rOpenFile( cArquivo ) CLASS Megusta
   LOCAL cConteudo := ""
   LOCAL cLinha

   IF ! File( cArquivo )
      ? "Erro: arquivo não encontrado."
      RETURN ""
   ENDIF

   cConteudo := MemoRead( cArquivo )

RETURN cConteudo

METHOD rOpenProgram( cPrograma ) CLASS Megusta
   RUN ( cPrograma )
RETURN NIL

METHOD rOpenFileWeb( cArquivo ) CLASS Megusta
   SISTEMA_OPERACIONAL = lower(os())
      IF ::strIndexOf(SISTEMA_OPERACIONAL, "windows") >= 1
            RUN ('cmd /c powershell -Command "Invoke-WebRequest -Uri ' + cArquivo + ' -OutFile x0001.txt"')
      ELSEIF ::strIndexOf(SISTEMA_OPERACIONAL, "linux") >= 1
            RUN ("wget -O x0001.txt " + cArquivo)
      ENDIF
      arquivo := ::rOpenFile("x0001.txt")
      ERASE "x0001.txt"
RETURN arquivo
/* =========================
   STRING
   ========================= */

METHOD strReplace( cOriginal, cVar1, cVar2 ) CLASS Megusta
RETURN StrTran( cOriginal, cVar1, cVar2 )

METHOD strLength( cString ) CLASS Megusta
RETURN Len( cString )

METHOD strSubstring( cString, nInicio, nFim ) CLASS Megusta
RETURN SubStr( cString, nInicio + 1, nFim - nInicio )

METHOD strCharAt( cString, nPos ) CLASS Megusta
RETURN SubStr( cString, nPos + 1, 1 )

METHOD strIndexOf(cadeia, subcadeia) CLASS Megusta
LOCAL pos
LOCAL len_cadeia, len_subcadeia

len_cadeia = LEN(cadeia)
len_subcadeia = LEN(subcadeia)

FOR pos = 1 TO len_cadeia - len_subcadeia + 1
IF SUBSTR(cadeia, pos, len_subcadeia) == subcadeia
RETURN pos
ENDIF
NEXT

RETURN 0 // Retorna 0 se a subcadeia não for encontrada

METHOD strLastIndexOf(cadeia, subcadeia) CLASS Megusta
LOCAL pos
LOCAL len_cadeia, len_subcadeia

len_cadeia = LEN(cadeia)
len_subcadeia = LEN(subcadeia)

FOR pos = len_cadeia TO 1 STEP -1
IF SUBSTR(cadeia, pos, len_subcadeia) == subcadeia
RETURN pos
ENDIF
NEXT

RETURN 0 // Retorna 0 se a subcadeia não for encontrada

METHOD strToLowerCase( cString ) CLASS Megusta
RETURN Lower( cString )

METHOD strToUpperCase( cString )
RETURN Upper( cString )

METHOD strEquals( c1, c2 ) CLASS Megusta
RETURN c1 == c2

METHOD strEqualsIgnoreCase( c1, c2 ) CLASS Megusta
RETURN Upper(c1) == Upper(c2)

METHOD strCompareTo(cadeia1, cadeia2) CLASS Megusta
IF cadeia1 == cadeia2
RETURN 0 // As cadeias são iguais
ELSE
IF cadeia1 < cadeia2
RETURN -1 // cadeia1 é menor que cadeia2
ELSE
RETURN 1 // cadeia1 é maior que cadeia2
ENDIF
ENDIF

METHOD strCompareToIgnoreCase(cadeia1, cadeia2) CLASS Megusta
LOCAL lowerCadeia1, lowerCadeia2
lowerCadeia1 = LOWER(cadeia1)
lowerCadeia2 = LOWER(cadeia2)

IF lowerCadeia1 == lowerCadeia2
RETURN 0 // As cadeias são iguais sem distinção entre maiúsculas e minúsculas
ELSE
IF lowerCadeia1 < lowerCadeia2
RETURN -1 // cadeia1 é menor que cadeia2 sem distinção entre maiúsculas e minúsculas
ELSE
RETURN 1 // cadeia1 é maior que cadeia2 sem distinção entre maiúsculas e minúsculas
ENDIF
ENDIF

// =========================
// Concatenação de strings (array de strings)
METHOD strConcat( ... ) CLASS Megusta
   LOCAL cResultado := ""
   LOCAL i
   LOCAL nParams := PCount()

   FOR i := 1 TO nParams
      cResultado += HB_PValue(i)
   NEXT

   RETURN cResultado


// StartsWith
METHOD strStartsWith( cString, cPrefix ) CLASS Megusta
   RETURN Left( cString, Len( cPrefix ) ) == cPrefix


// EndsWith
METHOD strEndsWith( cString, cSuffix ) CLASS Megusta
   RETURN Right( cString, Len( cSuffix ) ) == cSuffix


// Includes (contains)
METHOD strIncludes( cString, cSub ) CLASS Megusta
   RETURN At( cSub, cString ) > 0


// Split (retorna array)
METHOD strSplit( cString, cDelimiter ) CLASS Megusta
   LOCAL aResult := {}
   LOCAL nPos
   LOCAL i

   // Se delimitador é vazio, divide em caracteres individuais
   IF Empty( cDelimiter )
      FOR i := 1 TO Len( cString )
         AAdd( aResult, SubStr( cString, i, 1 ) )
      NEXT
      RETURN aResult
   ENDIF

   DO WHILE .T.
      nPos := At( cDelimiter, cString )
      IF nPos == 0
         AAdd( aResult, cString )
         EXIT
      ENDIF

      AAdd( aResult, Left( cString, nPos - 1 ) )
      cString := SubStr( cString, nPos + Len( cDelimiter ) )
   ENDDO

   RETURN aResult


// PadStart
METHOD strPadStart( cString, nLen, cPad ) CLASS Megusta
   LOCAL cFill := Replicate( cPad, nLen )

   RETURN Right( cFill + cString, nLen )


// PadEnd
METHOD strPadEnd( cString, nLen, cPad ) CLASS Megusta
   LOCAL cFill := Replicate( cPad, nLen )

   RETURN Left( cString + cFill, nLen )


// Repeat
METHOD strRepeat( cString, nTimes ) CLASS Megusta
   RETURN Replicate( cString, nTimes )


// Search (indexOf)
METHOD strSearch( cString, cSub ) CLASS Megusta
   LOCAL nPos := At( cSub, cString )
   RETURN iif( nPos > 0, nPos - 1, -1 )  // Java é 0-based


// Trim (ambos lados)
METHOD strTrim( cString ) CLASS Megusta
   RETURN AllTrim( cString )


// TrimStart (LTrim)
METHOD strTrimStart( cString ) CLASS Megusta
   RETURN LTrim( cString )


// TrimEnd (RTrim)
METHOD strTrimEnd( cString ) CLASS Megusta
   RETURN RTrim( cString )


// Slice (substring)
METHOD strSlice( cString, nStart, nEnd ) CLASS Megusta
   // Java é 0-based; Harbour é 1-based
   RETURN SubStr( cString, nStart + 1, nEnd - nStart )
// =========================
/* =========================
   DATE / TIME
   ========================= */

METHOD dateDay() CLASS Megusta
RETURN Day( Date() )

METHOD dateWeekDay() CLASS Megusta
RETURN Dow( Date() ) + 1

METHOD dateMonth() CLASS Megusta
RETURN Month( Date() )

METHOD dateYear() CLASS Megusta
RETURN Year( Date() )

METHOD dateSetWeekDay( nAno, nMes, nDia ) CLASS Megusta
RETURN Dow( STOD( Str(nAno,4) + StrZero(nMes,2) + StrZero(nDia,2) ) )

METHOD dateHour24() CLASS Megusta
RETURN Val( SubStr( Time(),1,2 ) )

METHOD dateMinute() CLASS Megusta
RETURN Val( SubStr( Time(),4,2 ) )

METHOD dateSecond() CLASS Megusta
RETURN Val( SubStr( Time(),7,2 ) )

/* =========================
   ARRAY
   ========================= */

METHOD xArrLength( aLista ) CLASS Megusta
RETURN Len( aLista )

METHOD arrAddAll( aLista, ... ) CLASS Megusta
   FOR i := 1 TO PCount()
      AAdd( aLista, PValue( i ) )
   ENDFOR
RETURN NIL

METHOD arrAdd( aLista, xValor ) CLASS Megusta
   AAdd( aLista, xValor )
RETURN NIL

METHOD arrAddPos( aLista, nPos, xValor ) CLASS Megusta
   AIns( aLista, nPos )
   aLista[nPos] := xValor
RETURN NIL

METHOD arrSet( aLista, nPos, xValor ) CLASS Megusta
   aLista[nPos] := xValor
RETURN NIL

METHOD arrGet( aLista, nPos ) CLASS Megusta
RETURN aLista[nPos]

METHOD arrSize( aLista ) CLASS Megusta
RETURN Len( aLista )

METHOD arrRemove( aLista, nPos ) CLASS Megusta
   ADel( aLista, nPos )
   ASize( aLista, Len(aLista)-1 )
RETURN NIL

METHOD arrClear( aLista ) CLASS Megusta
   ASize( aLista,0 )
RETURN NIL

METHOD arrContains( aLista, xValor ) CLASS Megusta
RETURN ASCan( aLista, xValor ) > 0

METHOD arrIndexOf( aLista, xValor ) CLASS Megusta
RETURN ASCan( aLista, xValor )

METHOD arrLastIndexOf( aLista, xValor ) CLASS Megusta
   LOCAL i
   FOR i := Len(aLista) TO 1 STEP -1
      IF aLista[i] == xValor
         RETURN i
      ENDIF
   NEXT
RETURN 0

/* =========================
   MATH
   ========================= */

METHOD mathInt( cNumero ) CLASS Megusta
RETURN Val( cNumero )

METHOD mathNum( cNumero ) CLASS Megusta
RETURN Val( cNumero )

METHOD mathBool( cValor ) CLASS Megusta
RETURN Upper(cValor) == "TRUE"

METHOD mathFloor( n ) CLASS Megusta
RETURN Int( n )

METHOD mathCeil( n ) CLASS Megusta
RETURN Int(n) + IIF( n > Int(n), 1, 0 )

METHOD mathRound( n ) CLASS Megusta
RETURN Round( n, 0 )

METHOD mathDecimalFormat( nNumero, cMascara ) CLASS Megusta
   LOCAL nDec := 0

   IF At(".", cMascara) > 0
      nDec := Len(cMascara) - At(".", cMascara)
   ENDIF

   RETURN Str( nNumero, 0, nDec )

METHOD mathNumberFormat( nNumero, cLocale, cCountry ) CLASS Megusta
   LOCAL cForm := Str( nNumero, 15, 2 )
   cForm := Trim(cForm)
   cForm := StrTran(cForm, ".", ",")
   RETURN cForm

METHOD mathRandom() CLASS Megusta
RETURN HB_Random()

METHOD mathAbs( n ) CLASS Megusta
RETURN Abs( n )

METHOD mathMax( n1, n2 ) CLASS Megusta
RETURN Max( n1, n2 )

METHOD mathMin( n1, n2 ) CLASS Megusta
RETURN Min( n1, n2 )

METHOD mathPow( base, expo ) CLASS Megusta
RETURN base ^ expo

METHOD mathSqrt( n ) CLASS Megusta
RETURN Sqrt( n )

METHOD mathCbrt( n ) CLASS Megusta
RETURN n ^ (1/3)

METHOD mathSignum( n ) CLASS Megusta
   IF n > 0
      RETURN 1
   ELSEIF n < 0
      RETURN -1
   ENDIF
RETURN 0

/* CONSTANTES */

METHOD mathPI() CLASS Megusta
RETURN 3.141592653589793

/* TRIGONOMETRIA */

METHOD mathConvertToRadians( graus ) CLASS Megusta
RETURN graus * ( ::mathPI() / 180 )

// =========================
//   TRIGONOMETRIA
//   =========================
// Quero implementar manualmente o sin, cos, tan (Série de Taylor) 
// sem precisar de biblioteca externa. Preciso "ensinar" ao CLIPPER 
// o sin, o cos e tan usando aproximações matemáticas.
// Implementações usando séries de Taylor para precisão razoável

#define PI 3.14159265358979323846
#define TWO_PI (2 * PI)

METHOD normalizeAngle(x) CLASS Megusta
   // reduz para [-PI, PI]
   x := x % TWO_PI

   IF x > PI
      x := x - TWO_PI
   ELSEIF x < -PI
      x := x + TWO_PI
   ENDIF

RETURN x

METHOD mathSin(x) CLASS Megusta
   LOCAL term, sum, n

   x := ::normalizeAngle(x)

   term := x
   sum  := x

   FOR n := 1 TO 10
      term := -term * x * x / ((2*n) * (2*n+1))
      sum  += term
   NEXT

RETURN sum

METHOD mathCos(x) CLASS Megusta
   LOCAL term, sum, n

   x := ::normalizeAngle(x)

   term := 1
   sum  := 1

   FOR n := 1 TO 10
      term := -term * x * x / ((2*n-1) * (2*n))
      sum  += term
   NEXT

RETURN sum

METHOD mathTan(x) CLASS Megusta
   LOCAL s, c

   // normaliza para [-PI, PI]
   x := ::normalizeAngle(x)

   // redução para [-PI/2, PI/2]
   IF x > PI/2
      x := x - PI
   ELSEIF x < -PI/2
      x := x + PI
   ENDIF

   // tratamento exato da singularidade
   IF x == PI/2 .OR. x == -PI/2
      RETURN NIL
   ENDIF

   c := ::mathCos(x)
   s := ::mathSin(x)

RETURN s / c

METHOD mathAsin(x) CLASS Megusta
   LOCAL n, term, sum

   sum  := x
   term := x

   FOR n := 1 TO 20
      term := term * ( (2*n - 1)*(2*n - 1) * x * x ) / ( (2*n)*(2*n + 1) )
      sum  += term
   NEXT

RETURN sum

METHOD mathAcos(x) CLASS Megusta
   LOCAL pi
   pi := 3.141592653589793

RETURN pi/2 - ::mathAsin(x)

METHOD mathAtan(x) CLASS Megusta
   LOCAL n, term, sum, xx, sign, pi

   pi := 3.141592653589793

   // Redução de domínio
   IF ABS(x) > 1
      IF x > 0
         RETURN pi/2 - ::mathAtan(1/x)
      ELSE
         RETURN -pi/2 - ::mathAtan(1/x)
      ENDIF
   ENDIF

   sum  := 0
   term := x
   xx   := x * x
   sign := 1

   FOR n := 1 TO 25 STEP 1
      sum  += sign * term / (2*n - 1)
      term *= xx
      sign := -sign
   NEXT

RETURN sum

METHOD mathSinh(x) CLASS Megusta
   LOCAL term := x
   LOCAL sum  := x
   LOCAL n    := 1
   LOCAL maxIter := 20  // ajuste conforme precisão desejada

   DO WHILE n <= maxIter
      term := term * (x * x) / ((2*n) * (2*n + 1))
      sum  := sum + term
      n++
   ENDDO

RETURN sum

METHOD mathCosh(x) CLASS Megusta
   LOCAL term := 1
   LOCAL sum  := 1
   LOCAL n    := 1
   LOCAL maxIter := 20

   DO WHILE n <= maxIter
      term := term * (x * x) / ((2*n - 1) * (2*n))
      sum  := sum + term
      n++
   ENDDO

RETURN sum

METHOD mathTanh(x) CLASS Megusta
   LOCAL s := ::mathSinh(x)
   LOCAL c := ::mathCosh(x)

   IF c == 0
      RETURN 0
   ENDIF

RETURN s / c

METHOD mathAsinh(x) CLASS Megusta
   LOCAL ax, x2, term, sum, n

   ax := ABS(x)

   // Usa Taylor para |x| pequeno
   IF ax < 0.5
      term := x
      sum  := x
      x2   := x * x

      FOR n := 1 TO 10
         term := -term * x2 * (2*n-1) / (2*n*(2*n+1))
         sum  += term
      NEXT

      RETURN sum
   ENDIF

   // Fórmula geral
   RETURN ::mathLog(x + ::mathSqrt(x*x + 1))

METHOD mathAcosh(x) CLASS Megusta
   LOCAL t, term, sum, n

   IF x < 1
      RETURN NIL
   ENDIF

   t := x - 1

   // Série perto de 1
   IF t < 0.5
      term := 1
      sum  := 1

      FOR n := 1 TO 10
         term := term * t
         sum  += term * ( (n=1)/12 - (n=2)*3/160 ) // simplificado
      NEXT

      RETURN ::mathSqrt(2*t) * sum
   ENDIF

   // Fórmula geral
   RETURN ::mathLog(x + ::mathSqrt(x*x - 1))

METHOD mathAtanh(x) CLASS Megusta
   LOCAL term, sum, x2, n

   IF ABS(x) >= 1
      RETURN NIL // fora do domínio
   ENDIF

   // Taylor
   IF ABS(x) < 0.5
      term := x
      sum  := x
      x2   := x * x

      FOR n := 1 TO 20
         term := term * x2
         sum  += term / (2*n + 1)
      NEXT

      RETURN sum
   ENDIF

   // Fórmula log
   RETURN 0.5 * ::mathLog((1+x)/(1-x))

/* =========================
   EXPONENCIAL
   ========================= */

METHOD mathLog( nNumero ) CLASS Megusta
RETURN log( nNumero )

METHOD mathLog10( nNumero ) CLASS Megusta
RETURN ::mathLog( nNumero ) / ::mathLog( 10 )

METHOD mathLog2( nNumero ) CLASS Megusta
RETURN ::mathLog( nNumero ) / ::mathLog( 2 )

METHOD mathExp( nExpoente ) CLASS Megusta
RETURN exp( nExpoente )

METHOD mathLog1p( n ) CLASS Megusta
RETURN ::mathLog( 1 + n )

METHOD mathE() CLASS Megusta
RETURN ::mathExp(1)

METHOD mathLN2() CLASS Megusta
RETURN ::mathLog(2)

METHOD mathLOG2E() CLASS Megusta
RETURN ::mathLog(2) / ::mathLog(::mathExp(1))

METHOD mathLN10() CLASS Megusta
RETURN ::mathLog(10)

METHOD mathLOG10E() CLASS Megusta
RETURN 1 / ::mathLog(10);

METHOD mathSQRT1_2() CLASS Megusta
RETURN ::mathSqrt( 0.5 )

METHOD mathSQRT2() CLASS Megusta
RETURN ::mathSqrt( 2 )

METHOD mathMaxArr( ... ) CLASS Megusta
   LOCAL nMax := -999999999
   LOCAL i
   FOR i := 1 TO PCount()
      IF PValue(i) > nMax
         nMax := PValue(i)
      ENDIF
   NEXT
RETURN nMax

METHOD mathMinArr( ... ) CLASS Megusta
   LOCAL nMin := 999999999
   LOCAL i
   FOR i := 1 TO PCount()
      IF PValue(i) < nMin
         nMin := PValue(i)
      ENDIF
   NEXT
RETURN nMin

Código: Selecionar todos

#include "ouka/Megusta.prg"

PROCEDURE Main()
      LOCAL r
 REQUEST HB_CodePage_UTF8
HB_CdpSelect("UTF8")

      r := Megusta():New()


        CLS
        r:rPrint("Esta eh uma mensagem de exemplo.")

        r:rPrintln("Esta eh uma mensagem de exemplo.")

        r:rPrintln()

        nome := r:rInput("Qual eh o seu nome? ")
        r:rPrintln("Olah, ", nome, "!")

        r:rPrintln()

        conteudo := "Este eh o conteudo que serah salvo no arquivo."
        nomeArquivo := "meu_arquivo.txt"
        r:rSaveFile(nomeArquivo, conteudo)

        r:rPrintln()

        r:rPrintln(r:rOpenFile(nomeArquivo))

        r:rPrintln()
        r:rOpenProgram("c:/java/jdk-23/bin/java.exe -jar /MeuApp/WindowJAR.jar")

        // rOpenFileWeb salva em x0001.txt via PowerShell retorna conteúdo diretamente
        r:rPrintln(r:rOpenFileWeb("https://www.ouka.com.br/meu_arquivo.txt"))


        // strReplace
        original := "Hoje é um lindo dia!"
        substituida := r:strReplace(original, "lindo", "maravilhoso")
        r:rPrintln(substituida) // Saída: "Hoje é um maravilhoso dia!"

        // strLength
        minhaString := "Olá, mundo!"
        tamanho := r:strLength(minhaString)
        r:rPrintln("O tamanho da string é: "+ STR(tamanho)) // Saída: "O tamanho da string é: 12"

        // strSubstring
        original2 := "Isso é uma de exemplo."
        sub := r:strSubstring(original2, 8, 13)
        r:rPrintln(sub) // Saída esperada: "uma d"

        // strCharAt
        minhaString2 := "Olá, mundo!"
        primeiroCaractere := r:strCharAt(minhaString2,0) // Obtém o primeiro caractere 'O'
        quartoCaractere := r:strCharAt(minhaString2, 3) // Obtém o quarto caractere ','

        r:rPrintln("Primeiro caractere: " + primeiroCaractere)
        r:rPrintln("Quarto caractere: " + quartoCaractere)

        // strIndexOf
        minhaString3 := "Isso é um exemplo de indexOf em Java."
        indice := r:strIndexOf(minhaString3, "exemplo")
        r:rPrintln("A substring 'exemplo' começa no índice: " + STR(indice)) // Saída: "A substring 'exemplo' começa no índice: 13"

        // strLastIndexOf
        minhaString4 := "Isso é um exemplo de lastIndexOf em Java. lastIndexOf é útil para encontrar a última ocorrência de uma substring."
        indice2 := r:strLastIndexOf(minhaString4,"lastIndexOf")
        r:rPrintln("A última ocorrência de 'lastIndexOf' começa no índice: " + STR(indice2)) // Saída: "A última ocorrência de 'lastIndexOf' começa no índice: 38"

        // strToLowerCase
        minhaString5 := "Isso É Uma De Exemplo."
        emMinusculas := r:strToLowerCase(minhaString5)
        r:rPrintln(emMinusculas) // Saída: "isso é uma de exemplo."

        // strToUpperCase
        minhaString6 := "Isso É Uma De Exemplo."
        emMaiusculas := r:strToUpperCase(minhaString6)
        r:rPrintln(emMaiusculas) // Saída: "ISSO É UMA DE EXEMPLO."

        // strCompareTo
        string1 := "abacate"
        string2 := "banana"

        resultado := r:strCompareTo(string1, string2)

        IF resultado < 0
                r:rPrintln("string1 é menor que string2")
        ELSEIF resultado == 0
                r:rPrintln("string1 é igual a string2")
        ELSE
                r:rPrintln("string1 é maior que string2")
        ENDIF

        // strCompareToIgnoreCase
        string1_1 := "maçã"
        string2_1 := "MaÇÃ"

        resultado2 := r:strCompareToIgnoreCase(string1_1, string2_1)

        IF resultado2 < 0
                r:rPrintln("string1 é menor que string2 (ignorando a diferença entre maiúsculas e minúsculas)")
        ELSEIF resultado2 == 0
                r:rPrintln("string1 é igual a string2 (ignorando a diferença entre maiúsculas e minúsculas)")
        ELSE
                r:rPrintln("string1 é maior que string2 (ignorando a diferença entre maiúsculas e minúsculas)")
        ENDIF

        // strEquals
        string1_2 := "Olá, mundo!"
        string2_2 := "Olá, mundo!"
        string3_2 := "olá, Mundo!"

        saoIguais1 := r:strEquals(string1_2, string2_2) // Retorna true
        saoIguais2 := r:strEquals(string1_2, string3_2) // Retorna false

        r:rPrintln(saoIguais1)
        r:rPrintln(saoIguais2)
 
        // strEqualsIgnoreCase
        string1_3 := "Olá, mundo!"
        string2_3 := "olá, Mundo!"

        saoIguais := r:strEqualsIgnoreCase(string1_3, string2_3) // Retorna true

        r:rPrintln(saoIguais)

        r:rPrintln()

        WAIT "Press. qualquer tecla para continuar"
        CLS

r:rPrintln(r:strCharAt("Hello", 4))           // o
r:rPrintln(r:strConcat("Hello", " ", "world")) // Hello world
r:rPrintln(r:strStartsWith("Hello", "H"))     // true
r:rPrintln(r:strEndsWith("Hello", "o"))       // true
r:rPrintln(r:strIncludes("Hello", "x"))       // false
r:rPrintln(r:strIndexOf("Hello", "l"))        // 2
r:rPrintln(r:strLastIndexOf("Hello", "l"))    // 3
r:rPrintln(r:strPadStart("Hello", 6, "?"))    // ?Hello
r:rPrintln(r:strPadEnd("Hello", 6, "?"))      // Hello?
r:rPrintln(r:strRepeat("Hello", 3))           // HelloHelloHello
r:rPrintln(r:strReplace("Hello", "llo", "y")) // Hey
r:rPrintln(r:strSearch("Hello", "e"))         // 1
r:rPrintln(r:strSlice("Hello", 1, 3))         // el

v := r:strSplit("Hello", "")          // ['H','e','l','l','o']

FOR i := 1 TO Len(v)
    r:rPrintln(v[i])
NEXT

r:rPrintln(r:strSubstring("Hello", 2, 4))     // ll
r:rPrintln(r:strToLowerCase("Hello"))       // hello
r:rPrintln(r:strToUpperCase("Hello"))       // HELLO
r:rPrintln(r:strTrim(" Hello "))            // Hello
r:rPrintln(r:strTrimStart(" Hello "))       // "Hello "
r:rPrintln(r:strTrimEnd(" Hello "))         // " Hello"

        WAIT "Press. qualquer tecla para continuar"
        CLS

        r:rPrintln()

        Texto := ""

        Dia_do_mes := r:dateDay()
        Dia_da_semana := r:dateWeekDay()
        Mes := r:dateMonth()
        Ano := r:dateYear()

        // ---------------------------------------
        Horas := r:dateHour24()
        Minutos := r:dateMinute()
        Segundos := r:dateSecond()
        // ---------------------------------------
        semana := {"", "Domingo", "Segunda", "Terça", "Quarta", "Quinta", "Sexta", "Sabado"}
        Semana_atual := semana[Dia_da_semana]

        Mes2 := {"Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho", "Agosto", "Setembro", "Outubro", "Novembro", "Dezembro"}
        Mes_atual := Mes2[Mes]

        Texto += Semana_atual + ", " + str(Dia_do_mes) + " de " + Mes_atual + " de " + str(Ano)
        Texto += "\n"
        Texto += "São: " + str(Horas) + " horas, " + str(Minutos) + " minutos e " + str(Segundos) + " segundos."

        r:rPrintln(Texto)

        Texto := ""

        x_dia := 28
        x_mes := 4
        x_ano := 1997
        
        // ---------------------------------------
        Dia_do_mes := x_dia
        Dia_da_semana := r:dateSetWeekDay(x_ano, x_mes, x_dia)
        Mes := x_mes
        Ano := x_ano

        semana := {"", "Domingo", "Segunda", "Terça", "Quarta", "Quinta", "Sexta", "Sabado"}
        Semana_atual := semana[Dia_da_semana]

        Mes2 := {"Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho", "Agosto", "Setembro", "Outubro", "Novembro", "Dezembro"}
        Mes_atual := Mes2[Mes]

        Texto += Semana_atual + ", " + str(Dia_do_mes) + " de " + Mes_atual + " de " + str(Ano)

        r:rPrintln(Texto)

        WAIT "Press. qualquer tecla para continuar"
        CLS

        r:rPrintln()

        // Array usando funções Harbour (arrAdd/arrGet/arrSize)

        frutasx := {}
        r:arrAddAll(frutasx, "Banana", "Melão", "Goiaba", "Morango")

        for i := 1 to r:arrSize(frutasx)
                r:rPrintln(r:arrGet(frutasx, i))
        next

        r:rPrintln()

        frutas1 := {}
        r:arrAdd(frutas1, "Banana")
        r:arrAdd(frutas1, "Melão")
        r:arrAdd(frutas1, "Goiaba")
        r:arrAdd(frutas1, "Morango")

        for i := 1 to r:arrSize(frutas1)
                r:rPrintln(r:arrGet(frutas1, i))
        next

        WAIT "Press. qualquer tecla para continuar"
        CLS

        r:rPrintln()

        frutas2 := {}
        r:arrAdd(frutas2, "Banana")
        r:arrAdd(frutas2, "Melão")
        r:arrAdd(frutas2, "Goiaba")
        r:arrAdd(frutas2, "Morango")
        r:arrAddPos(frutas2, 2, "======")

        for i := 1 to r:arrSize(frutas2)
                r:rPrintln(r:arrGet(frutas2, i))
        next

        r:rPrintln()


        frutas3 := {}
        r:arrAdd(frutas3, "Banana")
        r:arrAdd(frutas3, "Melão")
        r:arrAdd(frutas3, "Goiaba")
        r:arrAdd(frutas3, "Morango")
        r:arrSet(frutas3, 2, "======")

        for i := 1 to r:arrSize(frutas3)
                r:rPrintln(r:arrGet(frutas3, i))
        next

        r:rPrintln()
        WAIT "Press. qualquer tecla para continuar"
        CLS
        frutas4 := {}
        r:arrAdd(frutas4, "Banana")
        r:arrAdd(frutas4, "Melão")
        r:arrAdd(frutas4, "Goiaba")
        r:arrAdd(frutas4, "Morango")
        r:arrRemove(frutas4, 2)

        for i := 1 to r:arrSize(frutas4)
                r:rPrintln(r:arrGet(frutas4, i))
        next

        r:rPrintln()

        frutas5 := {}
        r:arrAdd(frutas5, "Banana")
        r:arrAdd(frutas5, "Melão")
        r:arrAdd(frutas5, "Goiaba")
        r:arrAdd(frutas5, "Morango")
        r:arrClear(frutas5)

        for i := 1 to r:arrSize(frutas5)
                r:rPrintln(r:arrGet(frutas5, i))
        next
        WAIT "Press. qualquer tecla para continuar"
        CLS
        r:rPrintln()

        lista1 := {}
        r:arrAdd(lista1, "Jose")
        r:arrAdd(lista1, "Maria")
        r:rPrintln(r:arrContains(lista1, "Jose"))

        r:rPrintln()

        lista2 := {}
        r:arrAdd(lista2, "Jose")
        r:arrAdd(lista2, "Maria")
        r:arrAdd(lista2, "Joao")

        for i := 1 to r:arrSize(lista2)
                r:rPrintln(r:arrGet(lista2, i))
        next

        r:rPrintln()

        //int indexOf (Object o): retorna a posição de um objeto.

        lista3 := {}
        r:arrAdd(lista3, "Jose")
        r:arrAdd(lista3, "Maria")
        r:arrAdd(lista3, "João")
        r:rPrintln(r:arrIndexOf(lista3, "Maria"))

        r:rPrintln()

        //int lastIndexOf (Object o): retorna o último índice de um objeto.

        lista4 := {}
        r:arrAdd(lista4, "Jose")
        r:arrAdd(lista4, "Maria")
        r:arrAdd(lista4, "João")
        r:arrAdd(lista4, "Maria")
        r:rPrintln(r:arrLastIndexOf(lista4, "Maria"))

        r:rPrintln()

        WAIT "Press. qualquer tecla para continuar"
        CLS
//Funções Matemáticas

//Convertendo para Numérica
//Números Inteiros
//mathint

        // Exemplo simples
        numeroString := "123456"
        numeroLong := r:mathInt(numeroString)
        r:rPrintln("Número convertido: " + str(numeroLong))

        // Tratamento de entrada inválida
        entradaInvalida := "abc"
        resultadoL := r:mathInt(entradaInvalida)
        IF resultadoL == 0 .AND. entradaInvalida != "0"
            r:rPrintln("Erro: A não é um número válido.")
        ELSE
            r:rPrintln("Número convertido: " + str(resultadoL))
        ENDIF

//Números Reais
//mathnum

        // Exemplo simples
        numeroString := "123.456"
        numeroDoubleD := r:mathNum(numeroString)
        r:rPrintln("Número convertido: " + str(numeroDoubleD))

        // Tratamento de entrada inválida
        entradaInvalida := "abc"
        resultadoD := r:mathNum(entradaInvalida)
        IF resultadoD == 0 .AND. entradaInvalida != "0"
            r:rPrintln("Erro: A não é um número válido.")
        ELSE
            r:rPrintln("Número convertido: " + str(resultadoD))
        ENDIF

//Boleanos
//mathbool

        // Exemplos simples
        trueString := "true"
        booleanTrue := r:mathBool(trueString)
        r:rPrint("Valor booleano: ")
        r:rPrintln((booleanTrue))

        falseString := "false"
        booleanFalse := r:mathBool(falseString)
        r:rPrint("Valor booleano: ")
        r:rPrintln((booleanFalse))

        // Tratamento de entrada inválida
        entradaInvalida := "abc"
        resultadoB := r:mathBool(entradaInvalida)
        r:rPrint("Valor booleano: ")
        r:rPrintln((resultadoB))
        // Como "abc" não é "true", o resultado será false

        WAIT "Press. qualquer tecla para continuar"
        CLS

//Arredondando valores
//Math.floor
        numeroOriginal := 0.0
        numeroArredondado := 0.0

        numeroOriginal := 7.8
        numeroArredondado := r:mathFloor(numeroOriginal)

        r:rPrintln("Número original: " + str(numeroOriginal))
        r:rPrintln("Número arredondado para baixo: " + str(numeroArredondado))

//Math.ceil
        numeroOriginal := 7.2
        numeroArredondado := r:mathCeil(numeroOriginal)

        r:rPrintln("Número original: " + str(numeroOriginal))
        r:rPrintln("Número arredondado para cima: " + str(numeroArredondado))
//Math.round
        numeroOriginal := 7.5
        numeroArredondado := r:mathRound(numeroOriginal)

        r:rPrintln("Número original: " + str(numeroOriginal))
        r:rPrintln("Número arredondado: " + str(numeroArredondado))

//Digite um número com 3 casas decimais
//mathDecimalFormat
        numero := 0.0
        numero := 123.456789

        numeroFormatado := r:mathDecimalFormat(numero, "#.###")

        r:rPrintln(numeroFormatado)

//Formatar moeda
//mathNumberFormat
        numero := 1234567.89

        // Formatar o número de acordo com a localidade do Brasil
        numeroFormatadoBrasil := r:mathNumberFormat(numero, "pt","BR")
       
        r:rPrint("Brasil: ")
        r:rPrintln(numeroFormatadoBrasil)

//Funções matemáticas comuns
//Math.random

        // Gerar um número aleatório no intervalo [0.0, 1.0)
        numeroAleatorio := r:mathRandom()

        r:rPrintln("Número aleatório: " + str(numeroAleatorio))

        //double numeroAleatorioNoIntervalo := Math.random() * (max - min), min
        //double numeroAleatorioIntervalo := Math.random() * (10.0 - 5.0), 5.0
        //r:rPrintln("Número aleatório no intervalo: ", numeroAleatorioIntervalo)
//Math.abs

        numeroInteiro := -5
        numeroLongo := -123456789
        numeroFloat := -3.14
        numeroDouble := -2.71828

        // Calcular o valor absoluto para diferentes tipos de números
        absInt :=  r:mathAbs(numeroInteiro)
        absLong :=  r:mathAbs(numeroLongo)
        absFloat :=  r:mathAbs(numeroFloat)
        absDouble := r:mathAbs(numeroDouble)

        r:rPrintln("Valor absoluto de " + str(numeroInteiro) + " := " + str(absInt))
        r:rPrintln("Valor absoluto de " + str(numeroLongo) + " := " + str(absLong))
        r:rPrintln("Valor absoluto de " + str(numeroFloat) + " := " + str(absFloat))
        r:rPrintln("Valor absoluto de " + str(numeroDouble) + " := " + str(absDouble))

//Math.max

        numero3 := 15.5
        numero4 := 12.3

        // Encontrar o máximo entre dois números de ponto flutuante
        maximoDouble := r:mathMax(numero3, numero4)
        r:rPrintln("Máximo entre " + str(numero3) + " e " + str(numero4) + " := " + str(maximoDouble))

        // maximoEntreTres := Math.max(Math.max(numero1, numero2), numero3)
//Math.min

        numero3 := 15.5
        numero4 := 12.3

        // Encontrar o mínimo entre dois números de ponto flutuante
        minimoDouble := r:mathMin(numero3, numero4)
        r:rPrintln("Mínimo entre " + str(numero3) + " e " + str(numero4) + " := " + str(minimoDouble))

       //int minimoEntreTres := Math.min(Math.min(numero1, numero2), numero3)

//Math.max



        // Encontrar o máximo entre dois números de ponto flutuante
        maximoDouble := r:mathMaxArr(15.5, 12.3, 10.8, 14.6)
        r:rPrintln("Máximo entre 15.5, 12.3, 10.8, 14.6 := " + str(maximoDouble))

//Math.min

        // Encontrar o mínimo entre dois números de ponto flutuante
        minimoDouble := r:mathMinArr(15.5, 12.3, 10.8, 14.6)
        r:rPrintln("Mínimo entre 15.5, 12.3, 10.8, 14.6 := " + str(minimoDouble))

//Math.pow
        base := 2.0
        expoente := 3.0

        // Calcular 2^3
        resultado :=  r:mathPow(base, expoente)
        r:rPrintln("Resultado: " + str(resultado))

//Math.sqrt
        numero := 25.0

        // Calcular a raiz quadrada de 25
        raizQuadrada := r:mathSqrt(numero)

        r:rPrintln("Raiz quadrada de " + str(numero) + " := " + str(raizQuadrada))

//Math.SQRT1_2
        // Utilizando a constante Math.SQRT1_2

        //double mathSQRT1_2 := 0.7071067811865476

        raizQuadradaDeUmMeio := r:mathSQRT1_2()

        r:rPrintln("Raiz quadrada de 1/2: " + str(raizQuadradaDeUmMeio))

//Math.SQRT2
        // Utilizando a constante Math.SQRT2

        //double mathSQRT2 := 1.4142135623730951

        raizQuadradaDeDois := r:mathSQRT2()

        r:rPrintln("Raiz quadrada de 2: " + str(raizQuadradaDeDois))


//Math.cbrt
        numero := 27.0

        // Calcular a raiz cúbica de 27
        raizCubica := r:mathCbrt(numero)

        r:rPrintln("Raiz cúbica de " + str(numero) + " := " + str(raizCubica))

//Math.sign
        numero := -5.5

        // Obtendo o sinal do número
        sinal :=  r:mathSignum(numero)

        r:rPrintln("Sinal de " + str(numero) + " := " + str(sinal))

        r:rPrintln()


//Funções trigonométricas
//Math.PI
        // Acesso à constante Math.PI
        pi := r:mathPI()

        // Exibindo o valor de pi
        r:rPrintln("O valor de pi é: ", pi)

        // Exemplo de cálculo usando pi
        raio := 5.0
        area := pi * raio * raio
        r:rPrintln("A área de um círculo com raio " + str(raio) + " é: " + str(area))
/*
function radianos(){
return Math.PI/180
}
*/

        graus := 45.0
        radianos := r:mathConvertToRadians(graus)

        r:rPrintln(str(graus) + " graus é equivalente a " + str(radianos) + " radianos")
 
        // Ângulo em radianos
        anguloEmRadianos := r:mathPI() / 4.0

        WAIT "Press. qualquer tecla para continuar"
        CLS

        // Calculando o seno do ângulo
        senoDoAngulo := r:mathSin(anguloEmRadianos)

        // Exibindo o resultado
        r:rPrintln("O seno de " + str(anguloEmRadianos) + " radianos é: " + str(senoDoAngulo))

//Math.cos
        // Ângulo em radianos
        anguloEmRadianos := r:mathPI() / 3.0

        // Calculando o cosseno do ângulo
        cossenoDoAngulo := r:mathCos(anguloEmRadianos)

        // Exibindo o resultado
        r:rPrintln("O cosseno de " + str(anguloEmRadianos) + " radianos é: " + str(cossenoDoAngulo))

//Math.tan
        // Ângulo em radianos
        anguloEmRadianos := r:mathPI() / 6.0

        // Calculando a tangente do ângulo
        tangenteDoAngulo := r:mathTan(anguloEmRadianos)

        // Exibindo o resultado
        r:rPrintln("A tangente de " + str(anguloEmRadianos) + " radianos é: " + str(tangenteDoAngulo))

//Math.asin
        // Valor para o qual queremos calcular o arco seno
        valor := 0.5

        // Calculando o arco seno do valor
        arcoSeno := r:mathAsin(valor)

        // Exibindo o resultado em radianos
        r:rPrintln("O arco seno de " + str(valor) + " é: " + str(arcoSeno) + " radianos.")

//Math.acos
        // Valor para o qual queremos calcular o arco cosseno
        valor := 0.5

        // Calculando o arco cosseno do valor
        arcoCosseno := r:mathAcos(valor)

        // Exibindo o resultado em radianos
        r:rPrintln("O arco cosseno de " + str(valor) + " é: " + str(arcoCosseno) + " radianos.")

//Math.atan
        // Valor para o qual queremos calcular o arco tangente
        valor := 0.5

        // Calculando o arco tangente do valor
        arcoTangente := r:mathAtan(valor)

        // Exibindo o resultado em radianos
        r:rPrintln("O arco tangente de " + str(valor) + " é: " + str(arcoTangente) + " radianos.")
 
//Math.sinh
        // Valor para o qual queremos calcular o seno hiperbólico
        valor := 2.0

        // Calculando o seno hiperbólico do valor
        senoHiperbolico := r:mathSinh(valor)

        // Exibindo o resultado
        r:rPrintln("O seno hiperbólico de " + str(valor) + " é: " + str(senoHiperbolico))

//Math.cosh
        // Valor para o qual queremos calcular o cosseno hiperbólico
        valor := 2.0

        // Calculando o cosseno hiperbólico do valor
        cossenoHiperbolico := r:mathCosh(valor)

        // Exibindo o resultado
        r:rPrintln("O cosseno hiperbólico de " + str(valor) + " é: " + str(cossenoHiperbolico))

//Math.tanh
        // Valor para o qual queremos calcular a tangente hiperbólica
        valor := 2.0

        // Calculando a tangente hiperbólica do valor
        tangenteHiperbolica := r:mathTanh(valor)

        // Exibindo o resultado
        r:rPrintln("A tangente hiperbólica de " + str(valor) + " é: " + str(tangenteHiperbolica))
 
//Math.asinh
        // Valor para o qual queremos calcular o arco seno hiperbólico
        valor := 2.0

        // Calculando o arco seno hiperbólico do valor
        arcoSenoHiperbolico := r:mathAsinh(valor)

        // Exibindo o resultado
        r:rPrintln("O arco seno hiperbólico de " + str(valor) + " é: " + str(arcoSenoHiperbolico))

        //asinh(x) := ln(x, sqrt(x^2, 1))
//Math.acosh
        // Valor para o qual queremos calcular o arco cosseno hiperbólico
        valor := 2.0

        // Calculando o arco cosseno hiperbólico do valor
        arcoCossenoHiperbolico := r:mathAcosh(valor)

        // Exibindo o resultado
        r:rPrintln("O arco cosseno hiperbólico de " + str(valor) + " é: " + str(arcoCossenoHiperbolico))

        //acosh(x) := ln(x, sqrt(x^2 - 1))
//Math.atanh
        // Valor para o qual queremos calcular o arco tangente hiperbólico
        valor := 0.5

        // Calculando o arco tangente hiperbólico do valor
        arcoTangenteHiperbolico := r:mathAtanh(valor)

        // Exibindo o resultado
        r:rPrintln("O arco tangente hiperbólico de " + str(valor) + " é: " + str(arcoTangenteHiperbolico))

        //atanh(x) := 0.5 * ln((1, x) / (1 - x))

        WAIT "Press. qualquer tecla para continuar"
        CLS

        r:rPrintln()

//Logarítmos

//Math.log
        // Número para o qual queremos calcular o logaritmo natural
        numero := 10.0

        // Calculando o logaritmo natural do número
        logaritmoNatural := r:mathLog(numero)

        // Exibindo o resultado
        r:rPrintln("O logaritmo natural de " + str(numero) + " é: " + str(logaritmoNatural))

//Math.log10
        // Número para o qual queremos calcular o logaritmo na base 10
        numero := 1000.0

        // Calculando o logaritmo na base 10 do número
        logaritmoBase10 := r:mathLog10(numero)

        // Exibindo o resultado
        r:rPrintln("O logaritmo na base 10 de " + str(numero) + " é: " + str(logaritmoBase10))
 
//Math.E
        // Acesso à constante Math.E
        constanteE := r:mathE()

        // Exibindo o valor da constante E
        r:rPrintln("O valor da constante E é: " + str(constanteE))
//Math.LN2
        // Acesso à constante Math.LN2
        LN2 := r:mathLN2()

        // Exibindo o valor do logaritmo natural de 2
        r:rPrintln("O valor do logaritmo natural de 2 é: " + str(LN2))

//Math.LOG2E
        // Acesso à constante Math.LOG2E
        LOG2E := r:mathLOG2E()

        // Exibindo o valor do logaritmo natural de base 2 de e
        r:rPrintln("O valor do logaritmo natural de base 2 de e é: " + str(LOG2E))

//Math.LN10
        // Acesso à constante Math.LN10
        LN10 := r:mathLN10()

        // Exibindo o valor do logaritmo natural de 10
        r:rPrintln("O valor do logaritmo natural de 10 é: " + str(LN10))

//Math.LOG10E
        // Acesso à constante Math.LOG10E
        LOG10E := r:mathLOG10E()

        // Exibindo o valor do logaritmo natural de base 10 de e
        r:rPrintln("O valor do logaritmo natural de base 10 de e é: " + str(LOG10E))
 
//Math.exp
        // Expoente para o qual queremos calcular a exponenciação
        expoente := 2.0

        // Calculando a exponenciação de e elevado ao expoente
        resultado3 := r:mathExp(expoente)

        // Exibindo o resultado
        r:rPrintln("O resultado de e elevado a " + str(expoente) + " é: " + str(resultado3))

//Math.log2
        // Número para o qual queremos calcular o logaritmo de base 2
        numero2 := 8.0

        // Calculando o logaritmo de base 2 do número
        LOG2 := r:mathLog2(numero2)

        // Exibindo o resultado
        r:rPrintln("O logaritmo de base 2 de " + str(numero2) + " é: " + str(LOG2))

        //log2(x) := ln(x) / ln(2)

//Math.log1p
        // Valor para o qual queremos calcular o logaritmo natural de 1 mais um
        valor := 0.5

        // Calculando o logaritmo natural de 1 mais um
        resultado4 := r:mathLog1p(valor)

        // Exibindo o resultado
        r:rPrintln("O logaritmo natural de 1 mais " + str(valor) + " é: " + str(resultado4))

        r:rPrintln("================================")
        r:rPrintln("===============FIM==============")
        r:rPrintln("================================")

RETURN NIL