Projeto ExpLab
Desenvolvi um interpretador e linguagem de programação nomeada de EXPLAB da qual trata o conteúdo desta página!
Veja abaixo alguns exemplos de gráficos plotados com o ExpLab 2.4.3:
Para abrir os projetos que geram os gráficos acima, entre outros, basta utilizar o botão abrir da barra de ferramentas da IDE e escolher os projetos que desejar abrir. Pode abrir vários projetos de uma vez só!
Introdução
O EXPLAB é um interpretador com suporte a uma linguagem de programação interpretada, também chamada de linguagem EXPLAB. Ela recebeu esse nome porque, inicialmente, foi projetada apenas para suporte a expressões numéricas. Logo após, coloquei o suporte a operações com matrizes nas expressões numéricas. E, então, surgiu a necessidade de oferecer suporte a expressões booleanas que, no futuro seriam (e foram) utilizadas em comandos como: SE (if) COMPARE/CASO (Switch/case), PARA (For), ENQUANTO (While) e FACA/ENQUANTO (Do/While).
A linguagem EXPLAB é CASE INSENSITIVE, ou seja, não diferencia caracteres maiusculos de minusculos (Com exceção, é claro, do que está definido como string). A comparação de strings é case sensitive, mas, se pode utilizar as funções MAIUSCULAS ou MINUSCULAS para comparações case insensitive de strings.
Outro ponto interessante da linguagem é que as expressões, variáveis, chamadas a funções que retornam valores, etc, têm seus resultados mostrados na tela do interpretador. A não ser que a instrução seja finalizada com um ponto e virgula!
Comentários também são suportados pelo explab. Assim como as linguagens C/C++ e Java, o explab suborta comentários de duas formas:
/* comentario */ ignora todos os caracteres, envolvendo também pula linhas ou quaisquer caracteres dentro deste bloco de comentários.
// comentario... ignora todo o restante da linha, a partir da posição onde o comentário foi iniciado.
Como o EXPLAB é uma linguagem orientada a objetos, tem suporte também a atributos como variáveis, métodos como funções, polimorfismo e herança de classes. No entanto, não foi colocado o suporte a modificadores de acesso. Não está difícil de colocar, mas, achei desnecessário. Mas, caso alguém que queira utilizar o software sinta falta desse recurso, por favor, entre em contato comigo solicitando o recurso que eu coloco. Isso porque, caso alguém sinta falta, fica evidente que o recurso tem utilidade, mesmo para esse tipo de linguagem de programação. Meu e-mail é: italoherbert@outlook.com. Podem entrar em contato comigo para tirar dúvidas, fazer críticas, dar sugestões de melhoramento, etc.
Palavras reservadas
As palavras reservadas não podem ser utilizadas como nome de variáveis, funções ou classes. Veja abaixo as palavras reservadas da linguagem EXPLAB:
func var retorne continue pare classe pacote extende construtor novo este super se senao compare caso padrao para faca enquanto tente capture finalize verdade falso string null liste ajuda cd ls script use sair exiba exibaln leialn limpetela lance
Downloads
Notas da versão 2.4.3
Essa versão traz melhor qualidade para os gráficos plotados. Faça o download logo abaixo para testar esta nova versão:
Download: explab-2.4.3.zip - Requer que o JRE ou OpenJDK (também conhecidos apenas por: "O Java") esteja instalado no computador onde se deseje executar o ExpLab.
Para executar o interpretador ExpLab, basta descompactar em qualquer diretório do seu computador o arquivo compactado disponível acima e executar o jar que fica na pasta raiz. Claro, caso você tenha o JRE ou equivalente instalado e configurado.
Executando em versões mais recentes do Java
Para executar o programa padrão (que é a IDE) basta dar dois cliques no arquivo explab-2.4.3.jar se estiver em ambiente Windows, ou, executar o seguinte comando:
java -jar explab-2.4.3.jar
Para executar a linha de comando através da execução da classe principal do arquivo explab.jar, caso já tenha o java instalado, navegue pelo MS-DOS ou ShellScript Linux até a pasta raiz do projeto descompactado e, então, execute o seguinte comando:
java -cp explab-2.4.3.jar italo.explab_cmd.ExpLabCMD
Ou, para versões mais antigas do java, faça:
java -cp lib/italo-libs-1.0.jar;lib/iplot-1.5.jar;explab-2.4.3.jar italo.explab_cmd.ExpLabCMD
Para executar a IDE através da execução da classe principal do arquivo explab.jar, caso já tenha o java instalado, navegue pelo MS-DOS ou Shell Script Linux até a pasta raiz do projeto descompactado e, então, execute o seguinte comando:
java -cp explab-2.4.3.jar italo.explab_ide.ExpLabIDE
Ou, para versões mais antigas do java, faça:
java -cp lib/italo-libs-1.0.jar;lib/iplot-1.5.jar;explab-2.4.3.jar italo.explab_ide.ExpLabIDE
Documentação
Exemplos de utilização do EXPLAB
Veja abaixo um exemplo suportado pela linguagem:
a = [ 1 2 3; 4 5 6 ]^rquad(abs( 2-2*3 )) + (2* ((pot( 2, 4 )*PI^0)*1.0)*3)/4;
b = a( 1,: );
exibaln a;
exibaln b;
Abaixo o resultado da execução das instruções acima no interpretador EXPLAB:
Aqui é necessário ter atenção as regras de precedência! Primeiro, são executadas as subexpressões entre parenteses e, tanto na expressão completa quanto nas subexpressões valem as seguintes regras: O operador % (resto de divisão) tem precedência maior, logo em seguida vem o operador de potenciação ^, depois os de multiplicação * e divisão / para, então, serem realizadas as somas e subtrações. Existe também o operador ** que é utilizado para multiplicação não escalar de matrizes, e ele tem precedência inferior a de todos os outros operadores aritméticos.
Veja abaixo outro exemplo:
b = 9;
i = 2;
a = i++ - 2^(b-=5)*( --i ) + (i++^3);
exibaln a; // exibe -13
exibaln b; // exibe 4
exibaln i; // exibe 3
a = b = c = 10;
a *= b-c;
exibaln a; // exibe 0
exibaln b; // exibe 10
exibaln c; // exibe 10
Os operadores i++ e i-- executam só após a execução da expressão ser executada, logo, retornam para a expressão, seu valor atual, antes do incremento ou decremento. Já os operadores ++i e --i, são executados durante a expressão, sendo a variável alterada imediatamente e seu valor resultante tendo influência no resultado final da expressão. Os operadores +=, -=, *=, /= e %= também são suportados nas expressões e são executados também imediatamente durante a execução da expressão, tendo seus resultados, influência no resultado final da expressão.
Veja abaixo outro exemplo de quatro implementações da função fatorial, três imperativas e outra recursiva.
func fat1( n ) {
fat = 1;
enquanto( n > 0 ) {
fat *= n;
n--;
}
retorne fat;
}
func fat2( n ) {
fat = 1;
enquanto ( n > 0 )
fat *= n--;
retorne fat;
}
func fat3( n ) {
fat = 1;
para ( i=2; i <= n; i++ )
fat *= i;
retorne fat;
}
func fat4( n ) { // recursiva
se n < 1
retorne 1;
retorne n * fat4( n-1 );
}
exiba "Informe um número: ";
leialn num;
exibaln "Fat1="+fat1( num );
exibaln "Fat2="+fat2( num );
exibaln "Fat3="+fat3( num );
exibaln "Fat4="+fat4( num );
O programa acima solicita que o usuário informe um número. Caso o número informado seja, por exemplo, 5, o resultado mostrado pela chamada de cada uma das quatro funções fatorial, é 120.
Exemplo de plotágem 2D
Exemplo 1: Esse exemplo plota o gráfico da função cosseno com x variando no intervalo de -pi a pi e a função seno no mesmo intervalo.
f = novo Func2D( -pi, pi ); // instancia a classe Func2D com os intervalos de X
f.y1 = -2.0; // seta o primeiro intervalo de y
f.y2 = 2.0; // seta o segundo intervalo de y
f.limitarY = verdade; // Com esse atributo setado para verdade, o intervalo
// de y será considerado na construção do gráfico
f.xcompleto = verdade; // Com esse atributo setado para verdade, a função
// é desenhada de acordo com o intervalo de x do
// plano cartesiano, mesmo que este seja maior que os
// intervalos de x da função
f.legenda = "cosseno"; // adiciona uma legenda para a função
f.linha.cor = novo RGB( 0, 0, 255 ); // seta a cor da função no gráfico
f.fun = func( x ) { // define a função que será utilizada para o cálculo
retorne cos( x ); // dos valores de y no plano cartesiano
};
f2 = novo Func2D( -pi, pi );
f2.xcompleto = verdade;
f2.legenda = "seno";
f2.linha.cor = novo RGB( 255, 0, 0 );
f2.fun = func( x ) {
retorne sen( x );
};
pc = novo PC2D(); // instancia a classe PC2D
pc.titulo = "Senos e Cossenos"; // seta o título do plano cartesiano
pc.xrotulo = "Eixo X"; // seta o rótulo do eixo x
pc.yrotulo = "Eixo Y"; // seta o rótulo do eixo y
pc.graficos[] = f; // adiciona o objeto f ao vetor de graficos
pc.graficos[] = f2; // adiciona o objeto f2 ao vetor de graficos
plot( pc ); // plota o gráfico
Veja abaixo o gráfico resultante da execução das instruções acima:
Exemplo de plotagem em 3D
Exemplo 1: Este exemplo desenha uma malha com base na função seno em conjunto com o calculo da distância entre dois pontos da hipotenusa de um triângulo de catetos iguais a "x" e "y". O calculo é feito para todos os vertices da malha.
x = vetesp( -pi, pi, 30 ); // gera 30 valores no intervalo de -pi a pi
y = x; // faz uma cópia dos 30 valores do vetor x
// e armazena em y
xx = xmalhagrade( x, y ); // gera uma matriz com o número de linhas do
// número de elementos gerados para o vetor y.
// O vetor x é repetido em cada
// linha da matriz xx
yy = ymalhagrade( x, y ); // gera uma matriz com o número de colunas
// do número de elementos gerados para o
// vetor x. O vetor y é repetido em cada
// coluna da matriz yy. (Obs: as matrizes
// xx e yy têm a mesma dimensão)
z = sen( sqrt( xx^2 + yy^2 ) ); // matriz z gerada a partir das matrizes xx
// e yy seguindo a fórmula da função que se
// deseje plotar. Isso tem efeito nos vertices
// da malha gerada e representada nas
// matrizes xx e yy
superficie = novo Superficie3D(); // instancia a classe Superficie3D
superficie.somenteMalha = verdade; // configura a superfície para não preencher
// faces, apenas arestas
superficie.setDados( x, y, z ); // seta os vetores x, y e a matriz z.
// Obs: Se poderia utilizar os atributos
// xvetor, yvetor, zmat diretamente, ao invés
// da função setDados!
pc = novo PC3D(); // instancia o objeto da classe PC3D
pc.graficos[] = superficie; // adiciona o objeto superfície ao vetor
// de dados
plot3d( pc ); // plota o gráfico
Veja abaixo o resultado da execução do script acima:
Exemplo 2: Este exemplo gera dois grupos de dados: uma superfície e uma sequência de arestas ligadas por vertices componentes de uma função matemática.
x = vetesp( 2, 4, 10 ); // gera 10 valores no intervalo de 2 a 4
y = vetesp( 1, 3, 10 ); // gera 10 valores no intervalo de 1 a 3
xx = xmalhagrade( x, y ); // gera a matriz x da malha
yy = ymalhagrade( x, y ); // gera a matriz y da malha
z = (xx-3)^2 - (yy-2)^2; // gera a matriz z a partir das matrizes xx e yy
superficie = novo Superficie3D(); // instancia a classe Superficie3D
superficie.xvetor = x; // seta o vetor x
superficie.yvetor = y; // seta o vetor y
superficie.zmat = z; // seta a matriz z
pc = novo PC3D(); // instancia a classe PC3D
pc.graficos[] = superficie; // adiciona o objeto superficie ao vetor de graficos
plot3d( pc ); // plota o gráfico
Veja abaixo o resultado da execução do script acima:
Exemplo 3: Este exemplo desenha um conjunto de segmentos de linhas interligados por vértices formando curvas circulares em 3D. Para tanto, são calculados os valores (x, y e z) dos vértices dos segmentos de linhas interligados.
z = [-5:0.05:5]; // gera dados entre -5 e 5 com incremento de 0,05
// e armazena em z
// Isso funciona de modo parecido (mas não igual) a
// função vetesp (com exceção de a distância entre as
// extremidades do intervalo serem perfeitamente
// divisiveis pelo incremento) - é o caso!
x = cos( 2*pi*z ); // gera um vetor x em função de z
y = sen( 2*pi*z ); // gera um vetor y em função de z
dados = novo Dados3D(); // instancia a classe Dados3D
dados.setDados( x, y, z ); // seta os vetores x, y e z (que têm mesma dimensão)
dados.legenda = "segmentos"; // seta a legenda do gráfico de dados
pc = novo PC3D(); // instancia a classe PC3D
pc.graficos[] = dados; // adiciona o objeto dados ao vetor de graficos
plot3d( pc ); // plota o gráfico
Veja abaixo o resultado da execução do script acima:
E assim concluo essa breve apresentação do EXPLAB! Visite a documentação completa contida na pasta "doc" na raiz do ExpLab. Nela, estão as referências e documentações dos comandos, variáveis, funções e classes nativas, além de documentação sobre estruturas de repetição e condicionais, expressões aritméticas e booleanas, operações com vetores e matrizes, funções, orientação a objetos, plotagem de gráficos em 2D e 3D, e muito mais... Até a próxima!
Façam-me o favor de testar o software e, caso encontrem algum pequeno defeito ou falha, ou mesmo queiram fazer comentários, críticas, sujestões de melhoramentos, etc. Entrem em contato comigo. Meu e-mail é: italoherbert@outlook.com
