Proyecto Final

Materia:
Lenguajes Formales y Autómatas

Docente:
Ing. Rolando Gonzales

Estudiantes:
✓ Kevin Vidal Calcina Ríos
✓ Giorgio Leandro Gonzales Bustos
✓ Paul Mauricio Melgar Zabala
✓ Gabriel Ortiz Balcázar
✓ Hans Denker Ortiz
✓ Cristhian Egüez Aguilar

Santa Cruz – Bolivia

Contenido
Definición de Alfabeto .............................................................................................................. 3
Alfabeto ................................................................................................................................ 3
Cadena.................................................................................................................................. 3
Cadena Vacía ........................................................................................................................ 3
Lenguajes .............................................................................................................................. 3
Tipo de Lenguajes ................................................................................................................. 3
Gramática ............................................................................................................................. 4
Autómata .............................................................................................................................. 4
Definición de AFD ..................................................................................................................... 5
Definición.............................................................................................................................. 5
Implementación .................................................................................................................... 7
Gramática ................................................................................................................................. 8
Alfabeto ................................................................................................................................ 8
Axioma.................................................................................................................................. 8
Producciones ........................................................................................................................ 9
Software ................................................................................................................................. 10
Analizador Léxico ................................................................................................................ 10
Token .............................................................................................................................. 10
Función ........................................................................................................................... 12
ProyGraficador .................................................................................................................... 28
FrmGraficador ................................................................................................................. 28
Anexo ..................................................................................................................................... 38
Definición de Alfabeto
Alfabeto
Un alfabeto es un conjunto de símbolos finito y no vacío de elementos llamados símbolos o
letras. Es una agrupación, que se lee con un orden determinado, de las gráficas utilizadas para
representar el lenguaje que sire de sistema de comunicación, un grupo de letras estructurado
bajo un orden especifico aceptado a nivel general en el marco de una lengua

Convencionalmente, utilizados el símbolo ∑ (sumatoria) para designar un alfabeto. Entre los

alfabetos más comunes se incluyen los siguientes:

∑= {0,1}, el alfabeto binario

∑= {a, b, ……. z}, es el conjunto de todas las letras minúsculas

El conjunto de todos los caracteres ASCII

Cadena
Una cadena de caracteres (que también se denomina en ocasiones palabra) es una secuencia
finita de símbolos seleccionados de algún alfabeto.

Una cadena o palabra es una secuencia finita de símbolos que pertenecen a un alfabeto y
comúnmente se denota con la letra.

EJEMPLO: si ∑= {0,1}, entonces ∑1= {0,1}, ∑2= {00, 01, 10, 11}, ∑3= {000, 001, 010, 011, 100,
101, 110, 111}, etc.

Cadena Vacía
La cadena vacía es aquella cadena que presenta cero apariciones de símbolos. Esta cadena,
designada por £, es una cadena que puede construirse en cualquier alfabeto

EJEMPLO: observe que ∑0= {£}, independientemente de cuál sea el alfabeto ∑. Es decir, £ es la
única cadena cuya longitud es 0.

Lenguajes
Un conjunto de cadenas, todas ellas seleccionadas de un ∑*, donde ∑ es un determinado
alfabeto se denomina lenguaje. Ya que estas pueden ser cualquier cadena que cumpla con lo
siguiente, está formada por los símbolos. Los lenguajes habituales pueden interpretarse como
conjuntos de cadenas.

EJEMPLO: Seria el inglés, donde la colección de las palabras correctas inglesas es un conjunto
de cadenas del alfabeto que consta de todas las letras.

EJEMPLO: Es el lenguaje C, o cualquier otro lenguaje de programación, donde los programas

correctos son un subconjunto de las posibles cadenas que pueden formarse a partir del
alfabeto del lenguaje.

Tipo de Lenguajes
LENGUAJES DECLARATIVOS: Es fundamentalmente lenguajes de órdenes, dominados por
Sentencias que expresan “lo que hay que hacer” en vez de “cómo hacerlo”.

LENGUAJES DE ALTO NIVEL: Son los más utilizados como lenguajes de programación permiten
que los algoritmos se expresen en un nivel y estilo de escritura fácilmente legible y
comprensible por otros programadores.
LENGUAJE ENSAMBLADOR: Es el programa en que se realiza la tracción de un programa escrito
en un programa escrito en ensamblador y lo pasa a lenguaje máquina. Directa o no directa de
la traducción en que las instrucciones no son más que instrucciones que ejecuta la
computadora.

LENGUAJE MAQUINA: Es como la maquina interpreta lo que nosotros queremos hacer es una
lectura de 0 y 1 es decir binario.

Gramática
La gramática es un ente formal para especificar, de una manera finita, el conjunto de cadenas
de símbolos que constituyen un lenguaje.

Es un conjunto finito de reglas que describen toda la secuencia de símbolos pertenecidas a un

lenguaje especifico y dos gramáticas que describen el mismo lenguaje que llaman gramáticas
equivalentes.

Autómata
Un autómata es una construcción lógica que recibe una entrada y produce una salida en
función de todo lo recibido hasta ese instante. En el caso de los Procesadores de Lenguaje un
autómata es una construcción si dicha cadena pertenece o no a un determinado lenguaje.
Definición de AFD
Definición
Un Autómata recibe secuencialmente una cadena de símbolos y cambia de estado por cada
símbolo leído o también puede permanecer en el mismo estado. Al final de la lectura el estado
del Autómata nos indica si la cadena es aceptada o mejor dicho pertenece al Lenguaje que
describe nuestra máquina. Si al final de leer todos los símbolos de entrada la máquina está en
alguno de los estados Finales entonces esa cadena es aceptada, si el estado no es final
entonces la cadena no pertenece al lenguaje.

Las partes que componen una Autómata son 5 y se pueden definir:

A = {Q, q0, F, Σ, δ}

Dónde:

Q: Conjunto finitos de estados.

q0: Estado inicial donde q0 ∈ Q. Debe haber uno y sólo un estado inicial.

F: Conjunto de estados finales F ⊆ Q. El estado q0 también puede ser final.

Σ: Alfabeto finitos de entrada.

δ: Función de Transición Q × Σ → Q.

Supongamos que el Autómata se encuentra en el estado qi donde qi ∈ Q, también tenemos el

símbolo a donde a ∈ Σ. Una entrada a causa que el Autómata cambie del estado qi al estado qk.
La función δ, llamada función de transición, describe este cambio de la forma δ(qi, a) → qk de
esta forma obtenemos un nuevo estado. Se entiende por transición como el proceso que hace
un Autómata al cambiar de estado.

En un diagrama de transición existe un nodo por cada estado qi de Q. Los estados finales están´
encerrados en un círculo doble. El estado inicial q0 es apuntado por una flecha que no
proviene de ningún otro estado. Para cada estado qi y un símbolo a, hay exactamente una y
sólo una flecha que inicia en qi y termina en δ(qi, a), es decir en qk, la flecha es etiquetada
como a. Si qk pertenece a F decimos que la entrada es aceptada.

Debe haber exactamente una flecha saliendo de cada estado por cada símbolo a0, a1, a2..., an,
por tanto, todos los estados tienen el mismo número de fechas saliendo de cada uno de ellos.
Con esto garantizamos que nuestro Autómata pueda ser llamado Determinista. No importa el
estado ni el símbolo leído, siempre hay una transición definida.

Para describir por completo una función de transición δ ocupamos una Tabla de Transición. Las
columnas se etiquetan con los símbolos de entrada, la filas son etiquetadas con los estados y
en las intersecciones se colocan los nuevos estados δ(qi, a), suponiendo que qi ∈ Q es la
columna y a ∈ Σ las filas que lo intercepta.

El estado inicial tiene una flecha que apunta a él, los estados finales tienen una flecha que sale
de ellos y los estados que no son finales y no son el inicial no tienen flecha. En caso de que
nuestro estado inicial también sea un estado final, se apuntará con una flecha doble ↔.
Una tabla de transición representa una función δ la cual recibe un símbolo y un estado, si
queremos introducir una cadena ω donde ω ∈ ∗, donde Σ∗ es la 5 cerradura de Σ, 1 en lugar de
un solo símbolo debemos usar δ∗ conocida como Función de Transición Extendida que nos
permite manejar una cadena dado que es una función de Q × Σ∗ y cumple con:

· δ∗(qi, a) → δ(qi, a) donde qi ∈ Q y a ∈ Σ

· δ∗(qi, ε) → δ(qi, a) donde ε ∈ Σ es el elemento vacío.

· δ∗(qi, aw) → δ∗(δ(qi, a),w) donde a ∈ Σ y w ∈ Σ∗

Si evaluamos δ∗ con un estado qi ∈ Q y con un símbolo a ∈ Σ se comporta de la misma forma

que δ.

El primer elemento de Σ∗ generalmente es el elemento vacío ε puede ser el único elemento de

nuestro lenguaje L = {ε} o podemos suponer que ε ∈ (Σ∗− Σ+). El autómata permanece en el
mismo estado al introducir ε, es decir no cambia el estado, se comporta como un símbolo
neutro para δ∗. El elemento ε puede ser aceptado sí y solo sí el estado inicial q0 también
pertenece al conjunto de estados finales q0 ∈ F.
Implementación
Gramática
Alfabeto

Σ= {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, +, -, *, /, ^, ., (, ), x, raíz }

Σ 𝑇 : 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | + | - | * | / | ^ | ( | ) | . | x |raíz

Σ𝑁 : Operador, Digito, Pabierto, Pcerrado, Punto, Número, Decimal, Tipo Número, Expresión

𝐺 = ( Σ 𝑇 , Σ𝑁 , 𝑆, 𝑃 )

Gess = ({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, +, -, *, /, ^, ., (, ), x, raíz},{ Operador, Digito, Pabierto,

Pcerrado, Punto, Número, Decimal, Tipo Número, Expresión}, Expresión, Pess)

Pess = {Número := Digito | Digito Número, Decimal := Número | Numero Punto Numero,
Tipo Número := Decimal | Número, Expresión := Tipo Número Operador Expresión | Operador
Expresión | Tipo Número | Pabierto Expresión Pcerrado Expresión | Pabierto Expresión
Pcerrado | Expresión Operador Expresión, Operador := + | - | * | / | raíz, Digito := 0 | 1 | 2 | 3 | 4 |
5 | 7 | 8 | 9 | x, Pabierto := (, Pcerrado := ), Punto := .}

Axioma

<Operador>:= + | - | * | / | raíz
<Digito> := 0 | 1 | 2 | 3 | 4 | 5 | 7 | 8 | 9 | x
<Pabierto>:= (
<Pcerrado> := )
<Punto>:= .

<Numero>:= <Digito>
<Numero>:= <Digito><Numero>
<Decimal>:= <Numero>
<Decimal>:= <Numero> <Punto> <Numero>
<Tipo Número>:= <Decimal> | <Numero>

<Expresión> := <Tipo Número><Operador><Expresión>

<Expresión> := <Operador><Expresión>
<Expresión> := <Tipo Número>
<Expresión> := <Pabierto> <Expresión> <Pcerrado> <Expresión>
<Expresión> := <Pabierto> <Expresión> <Pcerrado>
<Expresión> := <Expresión> <Operador> <Expresión>
Producciones

<E1> => x^4 Raíz 2 + 1

<E1>:= <Expresión>
<E1>:= <Tipo Número><Operador><Expresión>
<E1>:= <Numero> ^ <Tipo Número><Operador><Expresión>
<E1>:= <Digito> ^ <Número> raíz <Tipo Número><Operador><Expresión>
<E1>:= x ^ <Digito> raíz <Número> + <Tipo Número>
<E1>:= x ^ 4 raíz <Digito> + <Número>
<E1>:= x ^ 4 raíz 2 + <Digito>
<E1>:= x ^ 4 raíz 2 + 1

<E2> => ((2 - 30) * x / x) + 3.5

<E2>:= <Expresión>
<E2>:= <Pabierto> <Expresión> <Pcerrado><Expresión>
<E2>:= ( <Pabierto> <Expresión> <Pcerrado><Expresión> ) <Operador><Expresión>
<E2>:= ( ( <Expresión> <Operador> <Expresión> ) <Operador> <Expresión> ) + <Tipo
Número>
<E2>:= ( ( <Tipo Número> - <Tipo Número> ) * <Expresión> <Operador> <Expresión> ) +
<Decimal>
<E2>:= ( ( <Número> - <Número> ) * <Tipo Número> / <Tipo Número> ) + <Numero>
<Punto> <Numero>
<E2>:= ( ( <Digito> - <Digito> <Número> ) * <Número> / <Número> ) + <Digito> . <Digito>
<E2>:= ( ( 2 - 3 <Digito> ) * <Digito> / <Digito> ) + 3 . 5
<E2>:= ( ( 2 - 3 0 ) * x / x ) + 3 . 5
Software
Analizador Léxico
Token
/*

* To change this license header, choose License Headers in Project Properties.

* To change this template file, choose Tools | Templates

* and open the template in the editor.

*/

package AnalizadorLexico;

/**

* @author rgc

*/

public class Token {

private int tipoToken;

private int tipoOperador;

private int prioridad;

private double valor;

public Token(int tipoToken, int tipoOperador, int prioridad, double valor) {

this.tipoToken = tipoToken; //1=operador 2=perando o numero 3 = parentesis abierto 4=parentesis cerrado

this.tipoOperador = tipoOperador; //1 = + 2 = - 3 = * 4 = / 5 = ^ 6= raiz

this.prioridad = prioridad; // +-=>1,*/=>2,^=>3

this.valor = valor;

public int getTipoToken() {

return tipoToken;

public void setTipoToken(int tipoToken) {

this.tipoToken = tipoToken;

public int getTipoOperador() {

return tipoOperador;
 }

public void setTipoOperador(int tipoOperador) {

this.tipoOperador = tipoOperador;

public int getPrioridad() {

return prioridad;

public void setPrioridad(int prioridad) {

this.prioridad = prioridad;

public double getValor() {

return valor;

public void setValor(double valor) {

this.valor = valor;

}
Función
/*
* To change this license header, choose License Headers in Project Properties.

* To change this template file, choose Tools | Templates

* and open the template in the editor.

*/

package AnalizadorLexico;

import java.util.ArrayList;

import java.util.Stack;

/**

* @author rgc

*/

public class Funcion {

public ArrayList<Token> reconocerToken(String s) throws Exception

ArrayList<Token> listaToken = new ArrayList<Token>();

s = s + "@";//el simbolo significa fin de la cadena

Boolean fin = false;

Boolean error = false;

int estado = 0;

int i = 0;

String aux = "";

while(fin == false && error == false)

switch(estado)

case 0:

if(s.charAt(i)== ' ')

i++;

else

if(esDigito(s.charAt(i)))
{

aux = s.charAt(i)+"";

i++;

estado = 1;

else

if(s.charAt(i)=='+')

i++;

estado = 4;

else

if(s.charAt(i)=='-')

i++;

estado = 5;

else

if(s.charAt(i)=='*')

i++;

estado = 6;

else

if(s.charAt(i)=='/')

i++;

estado = 7;

else

if(s.charAt(i)=='^')

i++;

estado = 8;

else
 if(s.charAt(i)=='(')

i++;

estado = 9;

else

if(s.charAt(i)==')')

i++;

estado = 10;

else

if(s.charAt(i)=='@')

estado = 11;

else

if((s.charAt(i)=='r' || s.charAt(i)=='R') && (s.charAt(i+1)=='a' || s.charAt(i+1)=='A')

&&(s.charAt(i+2)=='i' || s.charAt(i+2)=='I')&& (s.charAt(i+3)=='z' || s.charAt(i+3)=='Z'))

estado = 13;

i+=4;

else

estado = 12;

break;

case 1:

if(esDigito(s.charAt(i)))

aux = aux + s.charAt(i);

i++;

else
 if(s.charAt(i)=='.')

aux = aux + s.charAt(i);

i++;

estado = 2;

else //otro

estado = 3;

break;

case 2:

if(esDigito(s.charAt(i)))

aux = aux + s.charAt(i);

i++;

else

estado = 3;

break;

case 3:

// filicidades es un token numero

//donde esta el numero en aux

Token t1 = new Token(2,0,0,Double.parseDouble(aux));

listaToken.add(t1);

estado = 0;

break;

case 4:

// filicidades es un token

//donde esta el numero en aux

Token t2 = new Token(1,1,1,0);

listaToken.add(t2);

estado = 0;

break;

case 5:

Token t3 = new Token(1,2,1,0);

listaToken.add(t3);
 estado = 0;

break;

case 6:

Token t4 = new Token(1,3,2,0);

listaToken.add(t4);

estado = 0;

break;

case 7:

Token t5 = new Token(1,4,2,0);

listaToken.add(t5);

estado = 0;

break;

case 8://^

Token t6 = new Token(1,5,3,0);

listaToken.add(t6);

estado = 0;

break;

case 9://( es 3

Token t7 = new Token(3,0,0,0);

listaToken.add(t7);

estado = 0;

break;

case 10: //) es tipo 4

Token t8 = new Token(4,0,0,0);

listaToken.add(t8);

estado = 0;

break;

case 11:

fin = true;
 break;

case 13:

Token t10 = new Token(1,6,1,0);

listaToken.add(t10);

estado = 0;

break;

case 12:

error = true;

break;

if(error == true)

throw new Exception("Error en el caracter:"+i + " caracter no esperado");

return listaToken;

public ArrayList<Token> reconocerToken(String s,double valorx) throws Exception

ArrayList<Token> listaToken = new ArrayList<Token>();

s = s + "@";//el simbolo significa fin de la cadena

Boolean fin = false;

Boolean error = false;

int estado = 0;

int i = 0;

String aux = "";

while(fin == false && error == false)

switch(estado)

case 0:
if(s.charAt(i)== ' ')

i++;

else

if(esDigito(s.charAt(i)))

aux = s.charAt(i)+"";

i++;

estado = 1;

else

if(s.charAt(i)=='+')

i++;

estado = 4;

else

if(s.charAt(i)=='-')

i++;

estado = 5;

else

if(s.charAt(i)=='*')

i++;

estado = 6;

else

if(s.charAt(i)=='/')

i++;

estado = 7;

else

if(s.charAt(i)=='^')

{
 i++;

estado = 8;

else

if(s.charAt(i)=='(')

i++;

estado = 9;

else

if(s.charAt(i)==')')

i++;

estado = 10;

else

if(s.charAt(i)=='@')

estado = 11;

else

if(s.charAt(i)=='X'|| s.charAt(i)=='x')

estado = 13;

i++;

else

if((s.charAt(i)=='r' || s.charAt(i)=='R') && (s.charAt(i+1)=='a' || s.charAt(i+1)=='A')

&&(s.charAt(i+2)=='i' || s.charAt(i+2)=='I')&& (s.charAt(i+3)=='z' || s.charAt(i+3)=='Z'))

estado = 14;

i+=4;

else

estado = 12;
 break;

case 1:

if(esDigito(s.charAt(i)))

aux = aux + s.charAt(i);

i++;

else

if(s.charAt(i)=='.')

aux = aux + s.charAt(i);

i++;

estado = 2;

else //otro

estado = 3;

break;

case 2:

if(esDigito(s.charAt(i)))

aux = aux + s.charAt(i);

i++;

else

estado = 3;

break;

case 3:

// filicidades es un token numero

//donde esta el numero en aux

Token t1 = new Token(2,0,0,Double.parseDouble(aux));

listaToken.add(t1);

estado = 0;

break;

case 4:
 // filicidades es un token

//donde esta el numero en aux

Token t2 = new Token(1,1,1,0);

listaToken.add(t2);

estado = 0;

break;

case 5:

Token t3 = new Token(1,2,1,0);

listaToken.add(t3);

estado = 0;

break;

case 6:

Token t4 = new Token(1,3,2,0);

listaToken.add(t4);

estado = 0;

break;

case 7:

Token t5 = new Token(1,4,2,0);

listaToken.add(t5);

estado = 0;

break;

case 8://^

Token t6 = new Token(1,5,3,0);

listaToken.add(t6);

estado = 0;

break;

case 9://( es 3

Token t7 = new Token(3,0,0,0);

listaToken.add(t7);

estado = 0;
 break;

case 10: //) es tipo 4

Token t8 = new Token(4,0,0,0);

listaToken.add(t8);

estado = 0;

break;

case 11:

fin = true;

break;

case 12:

error = true;

break;

case 13://x

Token t9 = new Token(2,0,0,valorx);

listaToken.add(t9);

estado = 0;

break;

case 14://raiz

Token t10 = new Token(1,6,1,0);

listaToken.add(t10);

estado = 0;

break;

if(error == true)

throw new Exception("Error en el caracter:"+i + " caracter no esperado");

return listaToken;

public Boolean esDigito(char x)

return x == '0'||x == '1'||x == '2'||x == '3'||x == '4'||x == '5'||x == '6'||x == '7'||x == '8'||x == '9';

}
public ArrayList<Token> convertirIntijaToPostFija(ArrayList<Token> listaInfija) throws Exception

ArrayList<Token> lista = new ArrayList<Token>();

Stack<Token> pila = new Stack<Token>();

for(int i = 0;i<listaInfija.size();i++)

Token T = listaInfija.get(i);

if(T.getTipoToken()==2)//operando

lista.add(T);

else

if(T.getTipoToken()==3)//pare abierto

pila.push(T);

else

if(T.getTipoToken()==1)//operador

if(pila.isEmpty() || T.getPrioridad()>pila.peek().getPrioridad())

pila.push(T);

else

//desapilar

while(!pila.isEmpty()&&T.getPrioridad()<=pila.peek().getPrioridad())

lista.add(pila.pop());

pila.push(T);

}
 else

//parentesis cerrado

while(!pila.isEmpty()&&pila.peek().getTipoToken()!=3)

lista.add(pila.pop());

if(pila.isEmpty())

throw new Exception("Falta parentesis abierto");

else

pila.pop();//sacar el parentesis abierto de la pila

//lo que sobro en la pila se añade a la lista

while(!pila.isEmpty())

lista.add(pila.pop());

return lista;

//--------------function principal

public double evaluar(String exp) throws Exception

try

ArrayList<Token> listaInfija = reconocerToken(exp);

ArrayList<Token> listaPosFija = convertirIntijaToPostFija(listaInfija);

Stack<Double> pila = new Stack<Double>();

for(int i = 0;i<listaPosFija.size();i++)

Token T = listaPosFija.get(i);
 if(T.getTipoToken()==2)//operando

pila.push(T.getValor());

else

//operador A - B

if(pila.size()>=2)

double b = pila.pop();

double a = pila.pop();

double resultado = calcular(a,b,T.getTipoOperador());

pila.push(resultado);

else

throw new Exception("Expresion mal formada faltan operandos");

if(pila.isEmpty()||pila.size()>1)

throw new Exception("Expresion mal formada faltan operadores u operandos");

else

return pila.pop();

catch(Exception E)

throw E;//el error retorna al programa principal

public double evaluar(String exp,double valorx) throws Exception

try

ArrayList<Token> listaInfija = reconocerToken(exp,valorx);

 ArrayList<Token> listaPosFija = convertirIntijaToPostFija(listaInfija);

Stack<Double> pila = new Stack<Double>();

for(int i = 0;i<listaPosFija.size();i++)

Token T = listaPosFija.get(i);

if(T.getTipoToken()==2)//operando

pila.push(T.getValor());

else

//operador A - B

if(pila.size()>=2)

double b = pila.pop();

double a = pila.pop();

double resultado = calcular(a,b,T.getTipoOperador());

pila.push(resultado);

else

throw new Exception("Expresion mal formada faltan operandos");

if(pila.isEmpty()||pila.size()>1)

throw new Exception("Expresion mal formada faltan operadores u operandos");

else

return pila.pop();

catch(Exception E)

throw E;//el error retorna al programa principal

public double calcular(double a,double b,int op)

 {

switch(op)

case 1: return a + b;

case 2: return a - b;

case 3: return a * b;

case 4: return a / b;

case 5: return Math.pow(a, b);

case 6: return Math.pow(a,1/b);

return 0;

}
ProyGraficador
FrmGraficador
/*

* To change this license header, choose License Headers in Project Properties.

* To change this template file, choose Tools | Templates

* and open the template in the editor.

*/

package proygraficador;

import AnalizadorLexico.Funcion;

import java.awt.Color;

import java.awt.Graphics;

/**

* @author rgc

*/

public class FrmGraficador extends javax.swing.JFrame {

Graphics g;

int centroEjeX;

int centroEjeY;

int altoPlano;

int anchoPlano;

int escala;

/**

* Creates new form FrmGraficador

*/

public FrmGraficador() {

initComponents();

g = panelGrafico.getGraphics();

anchoPlano = panelGrafico.getWidth();

altoPlano = panelGrafico.getHeight();

centroEjeX = anchoPlano/2;

centroEjeY = altoPlano/2;
 escala = 20;

/**

* This method is called from within the constructor to initialize the form.

* WARNING: Do NOT modify this code. The content of this method is always

* regenerated by the Form Editor.

*/

@SuppressWarnings("unchecked")

// <editor-fold defaultstate="collapsed" desc="Generated Code">

private void initComponents() {

jLabel1 = new javax.swing.JLabel();

txtFuncion = new javax.swing.JTextField();

btnGraficar = new javax.swing.JButton();

panelGrafico = new javax.swing.JPanel();

jButton1 = new javax.swing.JButton();

jButton2 = new javax.swing.JButton();

jButton3 = new javax.swing.JButton();

jButton4 = new javax.swing.JButton();

jButton5 = new javax.swing.JButton();

jButton6 = new javax.swing.JButton();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

jLabel1.setText("F(X) =");

txtFuncion.setText("X^2+1");

btnGraficar.setText("Graficar");

btnGraficar.addMouseListener(new java.awt.event.MouseAdapter() {

public void mouseClicked(java.awt.event.MouseEvent evt) {

btnGraficarMouseClicked(evt);

});
javax.swing.GroupLayout panelGraficoLayout = new javax.swing.GroupLayout(panelGrafico);

panelGrafico.setLayout(panelGraficoLayout);

panelGraficoLayout.setHorizontalGroup(

panelGraficoLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGap(0, 616, Short.MAX_VALUE)

);

panelGraficoLayout.setVerticalGroup(

panelGraficoLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGap(0, 291, Short.MAX_VALUE)

);

jButton1.setText("+");

jButton1.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton1ActionPerformed(evt);

});

jButton2.setText("-");

jButton2.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton2ActionPerformed(evt);

});

jButton3.setText("Up");

jButton3.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton3ActionPerformed(evt);

});

jButton4.setText("Down");

jButton4.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton4ActionPerformed(evt);
 }

});

jButton5.setText("Left");

jButton5.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton5ActionPerformed(evt);

});

jButton6.setText("Right");

jButton6.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton6ActionPerformed(evt);

});

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());

getContentPane().setLayout(layout);

layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup()

.addGap(25, 25, 25)

.addComponent(jLabel1)

.addGap(30, 30, 30)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING, false)

.addGroup(layout.createSequentialGroup()

.addComponent(txtFuncion, javax.swing.GroupLayout.PREFERRED_SIZE, 631,

javax.swing.GroupLayout.PREFERRED_SIZE)

.addGap(18, 18, 18)

.addComponent(btnGraficar))

.addGroup(layout.createSequentialGroup()

.addComponent(panelGrafico, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)

.addGap(33, 33, 33)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup()
 .addComponent(jButton1)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)

.addComponent(jButton2))

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING, false)

.addComponent(jButton5, javax.swing.GroupLayout.Alignment.LEADING,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)

.addComponent(jButton3, javax.swing.GroupLayout.Alignment.LEADING,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)

.addComponent(jButton4, javax.swing.GroupLayout.Alignment.LEADING,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))

.addComponent(jButton6))))

.addContainerGap(23, Short.MAX_VALUE))

);

layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup()

.addGap(24, 24, 24)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)

.addComponent(jLabel1)

.addComponent(txtFuncion, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)

.addComponent(btnGraficar))

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup()

.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)

.addComponent(jButton1)

.addComponent(jButton2))

.addGap(18, 18, 18)

.addComponent(jButton3)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)

.addComponent(jButton4)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)

.addComponent(jButton5)

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)

.addComponent(jButton6))

.addComponent(panelGrafico, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))

.addContainerGap(38, Short.MAX_VALUE))
 );

pack();

}// </editor-fold>

public void graficarFuncion()

try

Funcion F = new Funcion();

String exp = txtFuncion.getText();

double x = -40;

while(x<40)

try

double y = F.evaluar(exp, x);

int xpixel = centroEjeX+ (int)(Math.round(x*escala));

int ypixel = centroEjeY - (int)(Math.round(y*escala));

g.drawLine(xpixel,ypixel,xpixel+1,ypixel);

catch(Exception E2)

//nada

x = x + 0.01;

catch(Exception E)

public void graficarCoordenadas()

{
g.setColor(Color.WHITE);

g.fillRect(0,0,anchoPlano, altoPlano);

g.setColor(Color.BLUE);

//DIBUJAR LINEAS CENTRALES

g.drawLine(0,centroEjeY,anchoPlano,centroEjeY);

g.drawLine(centroEjeX,0,centroEjeX,altoPlano);

int x = centroEjeX;

while(x<anchoPlano)

x = x + escala;

g.setColor(Color.RED);

g.drawLine(x,centroEjeY-5, x, centroEjeY+5);

x = centroEjeX;

while(x>0)

x = x - escala;

g.setColor(Color.RED);

g.drawLine(x,centroEjeY-5, x, centroEjeY+5);

int y = centroEjeY;

while(y>0)

y = y - escala;

g.setColor(Color.RED);

g.drawLine(centroEjeX-5,y,centroEjeX+5,y);

y = centroEjeY;

while(y<altoPlano)

y = y + escala;

g.setColor(Color.RED);

g.drawLine(centroEjeX-5,y,centroEjeX+5,y);

}
}

private void btnGraficarMouseClicked(java.awt.event.MouseEvent evt) {

// TODO add your handling code here:

graficar();

private void graficar()

graficarCoordenadas();

graficarFuncion();

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:

escala = escala + 2;

graficar();

private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:

if(escala >=3)

escala = escala - 2;

graficar();

private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:

//arriba

centroEjeY = centroEjeY-2;

graficar();

}
private void jButton4ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:

centroEjeY = centroEjeY+2;

graficar();

private void jButton5ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:

centroEjeX = centroEjeX - 2;

graficar();

private void jButton6ActionPerformed(java.awt.event.ActionEvent evt) {

// TODO add your handling code here:

centroEjeX = centroEjeX + 2;

graficar();

/**

* @param args the command line arguments

*/

public static void main(String args[]) {

/* Set the Nimbus look and feel */

//<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">

/* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.

* For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html

*/

try {

for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {

if ("Nimbus".equals(info.getName())) {

javax.swing.UIManager.setLookAndFeel(info.getClassName());

break;

} catch (ClassNotFoundException ex) {

 java.util.logging.Logger.getLogger(FrmGraficador.class.getName()).log(java.util.logging.Level.SEVERE,
null, ex);

} catch (InstantiationException ex) {

java.util.logging.Logger.getLogger(FrmGraficador.class.getName()).log(java.util.logging.Level.SEVERE,
null, ex);

} catch (IllegalAccessException ex) {

java.util.logging.Logger.getLogger(FrmGraficador.class.getName()).log(java.util.logging.Level.SEVERE,
null, ex);

} catch (javax.swing.UnsupportedLookAndFeelException ex) {

java.util.logging.Logger.getLogger(FrmGraficador.class.getName()).log(java.util.logging.Level.SEVERE,
null, ex);

//</editor-fold>

/* Create and display the form */

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

new FrmGraficador().setVisible(true);

});

// Variables declaration - do not modify

private javax.swing.JButton btnGraficar;

private javax.swing.JButton jButton1;

private javax.swing.JButton jButton2;

private javax.swing.JButton jButton3;

private javax.swing.JButton jButton4;

private javax.swing.JButton jButton5;

private javax.swing.JButton jButton6;

private javax.swing.JLabel jLabel1;

private javax.swing.JPanel panelGrafico;

private javax.swing.JTextField txtFuncion;

// End of variables declaration

}
Anexo
Ilustración 1 Ejecución de la Aplicación