Megusta (União de várias linguagens)

JorgeLuizGSousa · Fevereiro 20, 2026, 7:50pm

Esta postagem foi sinalizada pela comunidade e está oculta temporariamente.

JorgeLuizGSousa · Fevereiro 20, 2026, 7:51pm

Resultado:

import java.util.ArrayList;
import java.util.List;

import Megusta.Megusta;
public class xMain {
     public static void main(String[] args) {
        Megusta r = new Megusta();
        r.rPrint("Esta eh uma mensagem de exemplo.");

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

        r.rPrintln();

        String nome = r.rInput("Qual eh o seu nome? ");
        r.rPrintln("Olah, " + nome + "!");

        System.out.println();

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

        System.out.println();

        System.out.println(r.rOpenFile(nomeArquivo));

        System.out.println();
        r.rOpenProgram("c:/java/jdk-23/bin/java.exe -jar /MeuApp/WindowJAR.jar");

        // strReplace
        String original = "Hoje é um lindo dia!";
        String substituida = r.strReplace(original, "lindo", "maravilhoso");
        System.out.println(substituida); // Saída: "Hoje é um maravilhoso dia!"

        // strLength
        String minhaString = "Olá, mundo!";
        int tamanho = r.strLength(minhaString);
        System.out.println("O tamanho da string é: " + tamanho); // Saída: "O tamanho da string é: 12"
 
        // strSubstring
        String original2 = "Isso é uma String de exemplo.";
        String sub = r.strSubstring(original2, 8, 13);
        System.out.println(sub); // Saída: "uma S"

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

        System.out.println("Primeiro caractere: " + primeiroCaractere);
        System.out.println("Quarto caractere: " + quartoCaractere);

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

        // strLastIndexOf
        String minhaString4 = "Isso é um exemplo de lastIndexOf em Java. lastIndexOf é útil para encontrar a última ocorrência de uma substring.";
        int indice2 = r.strLastIndexOf(minhaString4,"lastIndexOf");
        System.out.println("A última ocorrência de 'lastIndexOf' começa no índice: " + indice2); // Saída: "A última ocorrência de 'lastIndexOf' começa no índice: 38"
 
        // strToLowerCase
        String minhaString5 = "Isso É Uma String De Exemplo.";
        String emMinusculas = r.strToLowerCase(minhaString5);
        System.out.println(emMinusculas); // Saída: "isso é uma string de exemplo."

        // strToUpperCase
        String minhaString6 = "Isso É Uma String De Exemplo.";
        String emMaiusculas = r.strToUpperCase(minhaString6);
        System.out.println(emMaiusculas); // Saída: "ISSO É UMA STRING DE EXEMPLO."
 
        // strCompareTo
        String string1 = "abacate";
        String string2 = "banana";

        int resultado = r.strCompareTo(string1, string2);

        if (resultado < 0) {
                System.out.println("string1 é menor que string2");
        } else if (resultado == 0) {
                System.out.println("string1 é igual a string2");
        } else {
                System.out.println("string1 é maior que string2");
        }

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

        int resultado2 = r.strCompareToIgnoreCase(string1_1, string2_1);

        if (resultado2 < 0) {
                System.out.println("string1 é menor que string2 (ignorando a diferença entre maiúsculas e minúsculas)");
        } else if (resultado2 == 0) {
                System.out.println("string1 é igual a string2 (ignorando a diferença entre maiúsculas e minúsculas)");
        } else {
                System.out.println("string1 é maior que string2 (ignorando a diferença entre maiúsculas e minúsculas)");
        }

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

        boolean saoIguais1 = r.strEquals(string1_2, string2_2); // Retorna true
        boolean saoIguais2 = r.strEquals(string1_2, string3_2); // Retorna false

        System.out.println(saoIguais1);
        System.out.println(saoIguais2);
 
        // strEqualsIgnoreCase
        String string1_3 = "Olá, mundo!";
        String string2_3 = "olá, Mundo!";

        boolean saoIguais = r.strEqualsIgnoreCase(string1_3, string2_3); // Retorna true

        System.out.println(saoIguais);


        System.out.println();

        String Texto;
        Texto = "";

        int Dia_do_mes = r.dateDay();
        int Dia_da_semana = r.dateWeekDay();
        int Mes = r.dateMouth();
        int Ano = r.dateYear();

        // ---------------------------------------
        int Horas = r.dateHour24();
        int Minutos = r.dateMinute();
        int Segundos = r.dateSecond();
        // ---------------------------------------
        String semana[];
        semana = new String[8];
        semana[0] = "";
        semana[1] = "Domingo";
        semana[2] = "Segunda";
        semana[3] = "Terça";
        semana[4] = "Quarta";
        semana[5] = "Quinta";
        semana[6] = "Sexta";
        semana[7] = "Sabado";
        String Semana_atual = semana[Dia_da_semana];
        //-------------------------
        String Mes2[];
        Mes2 = new String[12];
        Mes2[0] = "Janeiro";
        Mes2[1] = "Fevereiro";
        Mes2[2] = "Março";
        Mes2[3] = "Abril";
        Mes2[4] = "Maio";
        Mes2[5] = "Junho";
        Mes2[6] = "Julho";
        Mes2[7] = "Agosto";
        Mes2[8] = "Setembro";
        Mes2[9] = "Outubro";
        Mes2[10] = "Novembro";
        Mes2[11] = "Desembro";
        String Mes_atual = Mes2[Mes];
        Texto += Semana_atual + ", " + Dia_do_mes + " de " + Mes_atual + " de " + Ano;
        Texto += "\n";
        Texto += "São: " + Horas + " horas, " + Minutos + " minutos e " + Segundos + " segundos.";

        System.out.println(Texto);

        Texto = "";

        int x_dia = 28;
        int x_mes = 4;
        int 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[0] = "";
        semana[1] = "Domingo";
        semana[2] = "Segunda";
        semana[3] = "Terça";
        semana[4] = "Quarta";
        semana[5] = "Quinta";
        semana[6] = "Sexta";
        semana[7] = "Sabado";
        Semana_atual = semana[Dia_da_semana];
        //-------------------------
        Mes2[0] = "Janeiro";
        Mes2[1] = "Fevereiro";
        Mes2[2] = "Março";
        Mes2[3] = "Abril";
        Mes2[4] = "Maio";
        Mes2[5] = "Junho";
        Mes2[6] = "Julho";
        Mes2[7] = "Agosto";
        Mes2[8] = "Setembro";
        Mes2[9] = "Outubro";
        Mes2[10] = "Novembro";
        Mes2[11] = "Desembro";
        Mes_atual = Mes2[Mes];
        Texto += Semana_atual + ", " + Dia_do_mes + " de " + Mes_atual + " de " + Ano;

        System.out.println(Texto);

        System.out.println();

        //ArrayList
        //arrAllAdd(Object o): adiciona à coleção o objeto passado como argumento.

        List<String> frutasx = new ArrayList<>();

        // adiciona itens na lista
        r.arrAddAll(frutasx, "Banana", "Melão", "Goiaba", "Morango");

        // exibe os valores da lista
        for(int i = 0; i < r.arrSize(frutasx); i++){
                System.out.println(r.arrGet(frutasx, i));
        }

        System.out.println();

        //add(Object o): adiciona à coleção o objeto passado como argumento.
        //size(): retorna o tamanho da coleção
        //get(int index): retorna um objeto dada uma posição.

        List<String> frutas1 = new ArrayList<>();

        // adiciona itens na lista
        r.arrAdd(frutas1, "Banana");
        r.arrAdd(frutas1, "Melão");
        r.arrAdd(frutas1, "Goiaba");
        r.arrAdd(frutas1, "Morango");

        // exibe os valores da lista
        for(int i = 0; i < r.arrSize(frutas1); i++){
                System.out.println(r.arrGet(frutas1, i));
        }

        System.out.println();

        //add(int index, Object element): adiciona um objeto dada uma posição.

        List<String> frutas2 = new ArrayList<>();

        // adiciona itens na lista
        r.arrAdd(frutas2, "Banana");
        r.arrAdd(frutas2, "Melão");
        r.arrAdd(frutas2, "Goiaba");
        r.arrAdd(frutas2, "Morango");

        r.arrAdd(frutas2, 1, "======");

        // exibe os valores da lista
        for(int i = 0; i < r.arrSize(frutas2); i++){
                System.out.println(r.arrGet(frutas2, i));
        }

        System.out.println();

        //set(int index, Object element): edita um objeto dada uma posição.

        List<String> frutas3 = new ArrayList<>();

        // adiciona itens na lista
        r.arrAdd(frutas3, "Banana");
        r.arrAdd(frutas3, "Melão");
        r.arrAdd(frutas3, "Goiaba");
        r.arrAdd(frutas3, "Morango");

        r.arrSet(frutas3, 1, "======");

        // exibe os valores da lista
        for(int i = 0; i < r.arrSize(frutas3); i++){
                System.out.println(r.arrGet(frutas3, i));
        }

        System.out.println();

        //remove(int index): remove um objeto dada sua posição.

        List<String> frutas4 = new ArrayList<>();

        // adiciona itens na lista
        r.arrAdd(frutas4, "Banana");
        r.arrAdd(frutas4, "Melão");
        r.arrAdd(frutas4, "Goiaba");
        r.arrAdd(frutas4, "Morango");

        r.arrRemove(frutas4, 1);

        // exibe os valores da lista
        for(int i = 0; i < r.arrSize(frutas4); i++){
                System.out.println(r.arrGet(frutas4, i));
        }

        System.out.println();

        //clear(): apaga todo o conteúdo da coleção.

        List<String> frutas5 = new ArrayList<>();

        // adiciona itens na lista
        r.arrAdd(frutas5, "Banana");
        r.arrAdd(frutas5, "Melão");
        r.arrAdd(frutas5, "Goiaba");
        r.arrAdd(frutas5, "Morango");

        r.arrClear(frutas5);

        // exibe os valores da lista
        for(int i = 0; i < r.arrSize(frutas5); i++){
                System.out.println(r.arrGet(frutas5, i));
        }

        System.out.println();

        //boolean contains(Object o): verifica se o objeto passado como argumento existe na coleção.

        List<String> lista1 = new ArrayList<>();
        r.arrAdd(lista1, "Jose");
        r.arrAdd(lista1, "Maria");
        System.out.println(r.arrContains(lista1, "Jose")); // True

        System.out.println();

        //Object[ ] toArray(): converte os elementos da coleção em um array (rápidos acesso aos elementos).

        List<String> lista2 = new ArrayList<>();
        r.arrAdd(lista2, "Jose");
        r.arrAdd(lista2, "Maria");
        r.arrAdd(lista2, "Joao");
        Object[] elementos2 = r.arrToArray(lista2);
        for(int i=0; i<r.xArrLength(elementos2);i++) {
                System.out.println(elementos2[i]);
        }

        System.out.println();

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

        List<String> lista3 = new ArrayList<>();
        r.arrAdd(lista3, "Jose");
        r.arrAdd(lista3, "Maria");
        r.arrAdd(lista3, "João");
        System.out.println(r.arrIndexOf(lista3, "Maria")); //1

        System.out.println();

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

        List<String> lista4 = new ArrayList<>();
        r.arrAdd(lista4, "Jose");
        r.arrAdd(lista4, "Maria");
        r.arrAdd(lista4, "João");
        r.arrAdd(lista4, "Maria");
        System.out.println(r.arrLastIndexOf(lista4, "Maria")); //3

        System.out.println();

//Funções Matemáticas

//Convertendo String para Numérica
//Números Inteiros
//mathint
        // Exemplo simples
        String numeroString = "123456";
        long numeroLong = r.mathInt(numeroString);
        System.out.println("Número convertido: " + numeroLong);

        // Tratamento de exceção para entrada inválida
        String entradaInvalida = "abc";
        try {
            long resultadoL = r.mathInt(entradaInvalida);
            System.out.println("Número convertido: " + resultadoL);
        } catch (NumberFormatException e) {
            System.out.println("Erro: A string não é um número válido.");
        }

//Números Reais
//mathnum
        // Exemplo simples
        numeroString = "123.456";
        double numeroDoubleD = r.mathNum(numeroString);
        System.out.println("Número convertido: " + numeroDoubleD);

        // Tratamento de exceção para entrada inválida
        entradaInvalida = "abc";
        try {
            double resultadoD = r.mathNum(entradaInvalida);
            System.out.println("Número convertido: " + resultadoD);
        } catch (NumberFormatException e) {
            System.out.println("Erro: A string não é um número válido.");
        }

//Boleanos
//mathbool
        // Exemplos simples
        String trueString = "true";
        boolean booleanTrue = r.mathBool(trueString);
        System.out.println("Valor booleano: " + booleanTrue);

        String falseString = "false";
        boolean booleanFalse = r.mathBool(falseString);
        System.out.println("Valor booleano: " + booleanFalse);

        // Tratamento de entrada inválida
        entradaInvalida = "abc";
        boolean resultadoB = r.mathBool(entradaInvalida);
        System.out.println("Valor booleano: " + resultadoB);
        // Como "abc" não é "true", o resultado será false
//Arredondando valores
//Math.floor
        double numeroOriginal = 0.0;
        double numeroArredondado = 0.0;

        numeroOriginal = 7.8;
        numeroArredondado = r.mathFloor(numeroOriginal);

        System.out.println("Número original: " + numeroOriginal);
        System.out.println("Número arredondado para baixo: " + numeroArredondado);
//Math.ceil
        numeroOriginal = 7.2;
        numeroArredondado = r.mathCeil(numeroOriginal);

        System.out.println("Número original: " + numeroOriginal);
        System.out.println("Número arredondado para cima: " + numeroArredondado);
//Math.round
        numeroOriginal = 7.5;
        numeroArredondado = r.mathRound(numeroOriginal);

        System.out.println("Número original: " + numeroOriginal);
        System.out.println("Número arredondado: " + numeroArredondado);

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

        String numeroFormatado = r.mathDecimalFormat(numero, "#.###");

        System.out.println(numeroFormatado);

//Formatar moeda
//mathNumberFormat
        numero = 1234567.89;

        // Formatar o número de acordo com a localidade do Brasil
        String numeroFormatadoBrasil = r.mathNumberFormat(numero, "pt","BR");
       
        System.out.println("Brasil: " + numeroFormatadoBrasil);

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

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

        System.out.println("Número aleatório: " + numeroAleatorio);

        //double numeroAleatorioNoIntervalo = Math.random() * (max - min) + min;
        //double numeroAleatorioIntervalo = Math.random() * (10.0 - 5.0) + 5.0;
        //System.out.println("Número aleatório no intervalo: " + numeroAleatorioIntervalo);
//Math.abs

        int numeroInteiro = -5;
        long numeroLongo = -123456789L;
        float numeroFloat = -3.14f;
        double numeroDouble = -2.71828;

        // Calcular o valor absoluto para diferentes tipos de números
        int absInt = (int) r.mathAbs(numeroInteiro);
        long absLong = (long) r.mathAbs(numeroLongo);
        float absFloat = (float) r.mathAbs(numeroFloat);
        double absDouble = r.mathAbs(numeroDouble);

        System.out.println("Valor absoluto de " + numeroInteiro + " = " + absInt);
        System.out.println("Valor absoluto de " + numeroLongo + " = " + absLong);
        System.out.println("Valor absoluto de " + numeroFloat + " = " + absFloat);
        System.out.println("Valor absoluto de " + numeroDouble + " = " + absDouble);

//Math.max

        double numero3 = 15.5;
        double numero4 = 12.3;

        // Encontrar o máximo entre dois números de ponto flutuante
        double maximoDouble = r.mathMax(numero3, numero4);
        System.out.println("Máximo entre " + numero3 + " e " + numero4 + " = " + maximoDouble);

        // int 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
        double minimoDouble = r.mathMin(numero3, numero4);
        System.out.println("Mínimo entre " + numero3 + " e " + numero4 + " = " + 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);
        System.out.println("Máximo entre 15.5, 12.3, 10.8, 14.6 = " + 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);
        System.out.println("Mínimo entre 15.5, 12.3, 10.8, 14.6 = " + minimoDouble);

//Math.pow
        double base = 2.0;
        double expoente = 3.0;

        // Calcular 2^3
        resultado = (int) r.mathPow(base, expoente);
        System.out.println("Resultado: " + resultado);

//Math.sqrt
        numero = 25.0;

        // Calcular a raiz quadrada de 25
        double raizQuadrada = r.mathSqrt(numero);

        System.out.println("Raiz quadrada de " + numero + " = " + raizQuadrada);

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

        //double mathSQRT1_2 = 0.7071067811865476;
        
        double raizQuadradaDeUmMeio = r.mathSQRT1_2;

        System.out.println("Raiz quadrada de 1/2: " + raizQuadradaDeUmMeio);

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

        //double mathSQRT2 = 1.4142135623730951;

        double raizQuadradaDeDois = r.mathSQRT2;

        System.out.println("Raiz quadrada de 2: " + raizQuadradaDeDois);

 
//Math.cbrt
        numero = 27.0;

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

        System.out.println("Raiz cúbica de " + numero + " = " + raizCubica);

//Math.sign
        numero = -5.5;

        // Obtendo o sinal do número
        int sinal = (int) r.mathSignum(numero);

        System.out.println("Sinal de " + numero + " = " + sinal);

        System.out.println();

//Funções trigonométricas
//Math.PI
        // Acesso à constante Math.PI
        double pi = r.mathPI;

        // Exibindo o valor de pi
        System.out.println("O valor de pi é: " + pi);

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

        double graus = 45.0;
        double radianos = r.mathConvertToRadians(graus);

        System.out.println(graus + " graus é equivalente a " + radianos + " radianos.");
 
//Math.sin
        // Ângulo em radianos
        double anguloEmRadianos = Math.PI / 4.0;

        // Calculando o seno do ângulo
        double senoDoAngulo = r.mathSin(anguloEmRadianos);

        // Exibindo o resultado
        System.out.println("O seno de " + anguloEmRadianos + " radianos é: " + senoDoAngulo);

//Math.cos
        // Ângulo em radianos
        anguloEmRadianos = Math.PI / 3.0;

        // Calculando o cosseno do ângulo
        double cossenoDoAngulo = r.mathCos(anguloEmRadianos);

        // Exibindo o resultado
        System.out.println("O cosseno de " + anguloEmRadianos + " radianos é: " + cossenoDoAngulo);

//Math.tan
        // Ângulo em radianos
        anguloEmRadianos = Math.PI / 6.0;

        // Calculando a tangente do ângulo
        double tangenteDoAngulo = r.mathTan(anguloEmRadianos);

        // Exibindo o resultado
        System.out.println("A tangente de " + anguloEmRadianos + " radianos é: " + tangenteDoAngulo);
 
//Math.asin
        // Valor para o qual queremos calcular o arco seno
        double valor = 0.5;

        // Calculando o arco seno do valor
        double arcoSeno = r.mathAsin(valor);

        // Exibindo o resultado em radianos
        System.out.println("O arco seno de " + valor + " é: " + arcoSeno + " radianos.");

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

        // Calculando o arco cosseno do valor
        double arcoCosseno = r.mathAcos(valor);

        // Exibindo o resultado em radianos
        System.out.println("O arco cosseno de " + valor + " é: " + arcoCosseno + " radianos.");

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

        // Calculando o arco tangente do valor
        double arcoTangente = r.mathAtan(valor);

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

        // Calculando o seno hiperbólico do valor
        double senoHiperbolico = r.mathSinh(valor);

        // Exibindo o resultado
        System.out.println("O seno hiperbólico de " + valor + " é: " + senoHiperbolico);

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

        // Calculando o cosseno hiperbólico do valor
        double cossenoHiperbolico = r.mathCosh(valor);

        // Exibindo o resultado
        System.out.println("O cosseno hiperbólico de " + valor + " é: " + cossenoHiperbolico);

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

        // Calculando a tangente hiperbólica do valor
        double tangenteHiperbolica = r.mathTanh(valor);

        // Exibindo o resultado
        System.out.println("A tangente hiperbólica de " + valor + " é: " + 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
        double arcoSenoHiperbolico = r.mathAsinh(valor);

        // Exibindo o resultado
        System.out.println("O arco seno hiperbólico de " + valor + " é: " + 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
        double arcoCossenoHiperbolico = r.mathAcosh(valor);

        // Exibindo o resultado
        System.out.println("O arco cosseno hiperbólico de " + valor + " é: " + 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
        double arcoTangenteHiperbolico = r.mathAtanh(valor);

        // Exibindo o resultado
        System.out.println("O arco tangente hiperbólico de " + valor + " é: " + arcoTangenteHiperbolico);

        //atanh(x) = 0.5 * ln((1 + x) / (1 - x))

        System.out.println();

//Logarítmos

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

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

        // Exibindo o resultado
        System.out.println("O logaritmo natural de " + numero + " é: " + 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
        double logaritmoBase10 = r.mathLog10(numero);

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

        // Exibindo o valor da constante E
        System.out.println("O valor da constante E é: " + constanteE);
//Math.LN2
        // Acesso à constante Math.LN2
        double LN2 = r.mathLN2;

        // Exibindo o valor do logaritmo natural de 2
        System.out.println("O valor do logaritmo natural de 2 é: " + LN2);

//Math.LOG2E
        // Acesso à constante Math.LOG2E
        double LOG2E = r.mathLOG2E;

        // Exibindo o valor do logaritmo natural de base 2 de e
        System.out.println("O valor do logaritmo natural de base 2 de e é: " + LOG2E);

//Math.LN10
        // Acesso à constante Math.LN10
        double LN10 = r.mathLN10;

        // Exibindo o valor do logaritmo natural de 10
        System.out.println("O valor do logaritmo natural de 10 é: " + LN10);

//Math.LOG10E
        // Acesso à constante Math.LOG10E
        double LOG10E = r.mathLOG10E;

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

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

        // Exibindo o resultado
        System.out.println("O resultado de e elevado a " + expoente + " é: " + resultado3);

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

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

        // Exibindo o resultado
        System.out.println("O logaritmo de base 2 de " + numero2 + " é: " + 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
        double resultado4 = r.mathLog1p(valor);

        // Exibindo o resultado
        System.out.println("O logaritmo natural de 1 mais " + valor + " é: " + resultado4);
     }
}

Jonathan_Medeiros · Fevereiro 20, 2026, 9:38pm

Não consegui entender o seu objetivo e o que você está buscando aqui no fórum exatamente com relação seu código…

JorgeLuizGSousa · Fevereiro 20, 2026, 9:47pm

União das linguagens de programação Java, Javascript, PHP, Python, Clipper, Rust, C/C++, Assembly e WebAssembly.
A ideia é: ao trocar de linguagem de programação, algumas partes do código não mudam.
De Java para Python, algumas partes do código não mudam, assim como de PHP para Rust.

JorgeLuizGSousa · Fevereiro 20, 2026, 9:49pm

É só um modelo!
Vou usar IA para programar em outras linguagens!

JorgeLuizGSousa · Fevereiro 20, 2026, 9:57pm

Queria saber das pessoas que estão com dúvida no meu código. Assim vou aprimorar. Qualquer dúvida em relação ao meu código? É só falar:
– Estou com dúvida?

davidbuzatto · Fevereiro 20, 2026, 11:41pm

Você poderia mostrar um exemplo em que você engloba Java, Javascript, PHP, Python, Clipper, Rust, C/C++, Assembly e WebAssembly? Na minha cabeça isso não faz o menor sentido, mas quero ver qual é sua ideia.

j-menezes · Fevereiro 21, 2026, 1:41am

Jesus Amado

JorgeLuizGSousa · Fevereiro 21, 2026, 3:14pm

Insiro o seguinte comando:

megusta -javascript exemplo.mg -o exemplo.js

Irá compilar um código javascript
Igual ao TypeScript
Assim como:

Python
C
Clipper
Java
Javascript
PHP
Rust
Assembly
WebAssembly

JorgeLuizGSousa · Fevereiro 21, 2026, 3:16pm

Se não entender? Pode conversar comigo? Isso ajudará a criar um código melhor!

davidbuzatto · Fevereiro 21, 2026, 4:14pm

Eu tenho a impressão que você não sabe muito bem do que está falando. Você quer criar um transpilador “universal” que em vários cenários não vai conseguir transpilar, pq uma linguagem alvo não vai ter uma ou mais funcionalidades da linguagem fonte, fazendo você ter que gerar código a mais para ter essa relação um para um, tornando o código na linguagem alvo difícil (ou praticamente impossível) de manter.

Um exemplo:

Java (linguagem fonte):

public interface A {
    public void x();
}

public class B implements A {

    private int payload;

    public B( int payload ) {
        this.payload = payload;
    }

    @Override
    public void x() {
        System.out.printf( "Payload de B: %d\n", payload );
        System.out.println( "x de B" );
    }

}

public class C implements A {

    private int payload;

    public C( int payload ) {
        this.payload = payload;
    }

    @Override
    public void x() {
        System.out.printf( "Payload de C: %d\n", payload );
        System.out.println( "x de C" );
    }

}

public class Teste {
    public static void main( String[] args ) {
        A[] as = { new B( 42 ), new C( 69 ) };
        for ( A a : as ) {
            a.x();
        }
    }
}

Para esse cenário básico de polimorfismo, teria que gerar algo assim em C (está bem simples, você vai precisar de algo MUITO mais sofisticado para abraçar todos os casos possíveis):

#include <stdlib.h>
#include <stdio.h>

typedef enum ObjType {
    OBJ_TYPE_B,
    OBJ_TYPE_C
} ObjType;

typedef struct A A;

struct A {
    void (*x)( A *a );
    void (*xSub)( void );
    void *obj;
    ObjType objType;    
};

typedef struct B {
    int payload;
} B;

typedef struct C {
    int payload;
} C;

void x( A *a );
void xB( void );
void xC( void );

void x( A *a ) {
    if ( a->objType == OBJ_TYPE_B ) {
        // se precisasse processar algum atributo de B
        B *b = (B*) a->obj;
        printf( "Payload de B: %d\n", b->payload );
    } else if ( a->objType == OBJ_TYPE_C ) {
        // se precisasse processar algum atributo de C
        C *c = (C*) a->obj;
        printf( "Payload de C: %d\n", c->payload );
    }
    a->xSub();
}

void xB( void ) {
    printf( "x de B\n" );
}

void xC( void ) {
    printf( "x de C\n" );
}

int main( void ) {

    B b = { .payload = 42 };
    C c = { .payload = 69 };

    A as[] = {
        {
            .x = x,
            .xSub = xB,
            .obj = &b,
            .objType = OBJ_TYPE_B
        }, {
            .x = x,
            .xSub = xC,
            .obj = &c,
            .objType = OBJ_TYPE_C
        },
    };

    for ( int i = 0; i < 2; i++ ) {
        as[i].x( &as[i] );
    }

    return 0;

}

E isso que estamos falando de apenas UM caso simples de apenas UMA linguagem fonte para UMA linguagem alvo. Acho que vale para vc aprender bastante coisa, mas sinceramente, na prática, sem aplicação. Ninguém vai usar algo pra tentar fazer isso. É mais fácil e menos propenso a erros um especialista nas linguagens envolvidas reescrever.

Edit: meu código em C tá errado inclusive. Um ponteiro para B ou C deveria ser passado para a função do “subtipo”, para então desempacotar o payload e usar. Não vou refazer

JorgeLuizGSousa · Fevereiro 21, 2026, 4:47pm

Quase isso!
Em relação a Orientação a Objeto, só vai usar um tipo de objeto, veja o objeto abaixo!
O código Java abaixo vai ser transpilado pra C, no exemplo acima!

Lampada

Arquivo: Lampada.java

// Lampada.java

// Classe Lampada

public class Lampada {
   // atributos
   public boolean acesa;

   // metodos
   public void ligar() {
      acesa = true;
   }
   public void desligar() {
      acesa = false;
   }
}
/*
Lampada
(from default)
--------------
+ acesa boolean
--------------
+ desligar()
+ ligar()
*/

Arquivo: testando_a_lampada.java

// testando_a_lampada.java

public class testando_a_lampada {
   public static void main (String args[]){

      Lampada lamp = new Lampada();

      lamp.ligar();
      System.out.println("Lampada Criada (Acesa = " + lamp.acesa + ")");
      lamp.desligar();
      System.out.println("Lampada Criada (Acesa = " + lamp.acesa + ")");
   }
}
/*
Resultado:
Lampada Criada (Acesa = true)
Lampada Criada (Acesa = false)
*/

davidbuzatto · Fevereiro 21, 2026, 4:50pm

E você acha, sinceramente, que alguém vai usar algo que o limite na linguagem fonte? Ah, vc não pode fazer assim, tem que fazer assado… Não faz sentido.

Me mostra o “correspondente” em C do que você fez em Java. Sem usar IA, faça você. Se você não entender o que está fazendo, não tem como você saber se tá certo ou errado. Não viaja.

Infelizmente você não tem noção, ou pelo menos não tentou vislumbrar, o tamanho do problema que você está tentando solucionar. Só o tamanho da biblioteca padrão do Java por exemplo é ABSURDO e você teria que cobrir tudo, ou boa parte.

JorgeLuizGSousa · Fevereiro 21, 2026, 4:58pm

Dentro da Tag
<%rMgc

…

%>

Vou colocar o meu código Megusta.
Fora da Tag, uso o código Hospedeiro
Assim fica fácil colocar mais código.

JorgeLuizGSousa · Fevereiro 21, 2026, 5:03pm

O megusta só vai usar um tipo de Objeto.
Se quiser criar a mais, tem que colocar fora da Tag
<%rMg
…
%>

davidbuzatto · Fevereiro 21, 2026, 5:05pm

E outra, preciso complementar. Você tá começando pelo fim. Seu primeiro problema é fazer o parse da linguagem fonte, gerando, por exemplo, uma árvore sintática abstrata, que então vai ser percorrida para gerar o código da linguagem alvo. Enfim, boa sorte. Pelo menos tentando ver pelo lado bom, TypeScript para JavaScript já ta pronto, só usar o transpilador da Microsoft.

JorgeLuizGSousa · Fevereiro 21, 2026, 5:09pm

Enquanto alguém não tiver nenhuma dúvida?
Estarei aqui esplicando?
Vou usar esse tópico para criar um código melhor.

davidbuzatto · Fevereiro 21, 2026, 5:11pm

Boa sorte, Jorge. De coração. Um abraço!

JorgeLuizGSousa · Fevereiro 21, 2026, 5:22pm

Obrigado!
Fique com Deus!

JorgeLuizGSousa · Fevereiro 21, 2026, 7:29pm

Alguém com dúvida?

Megusta (União de várias linguagens)

Cursos de Mobile

Cursos de Programação

Cursos de Front-end

Cursos de DevOps

Cursos de Design & UX

Cursos de Business

Cursos de Data & BI