Sistemas expertos from Jesus Alejandro Flores Hernandez

/*
Jesus Alejandro Flores Hernandez
Clase para la evaluación de expresiones en notación polca inversa
Revisado en Dic 07 a parti del curso de POO del seg sem 2006
Evalua funciones en polaca inversa es usada por la clse Graficadora
*/
import java.util.StringTokenizer;
import java.util.Stack;
import java.util.EmptyStackException;
public class calcPolaca{
public double resultado;
boolean operador = false;  
  boolean funcion = false;
Stack p;
calcPolaca(String cad){
    StringTokenizer cadena = new StringTokenizer(cad,",");
p = new Stack();
      while (cadena.hasMoreTokens()){
            String token = cadena.nextToken();
if (token=="=")break;
            p.push(token);
            if (func(token)){
               calcularfunc();
            }else{
               if (oper(  token   )){
                  calcularop();
               }
            }  
      }
      resultado = Double.parseDouble((String)(p.pop()));
   }
   private void calcularfunc(){
    String token = (String)(p.pop());
      String x = (String)(p.pop());
      switch (token.charAt(0)){
            case 'S':
               p.push( String.valueOf( Math.sin( Double.parseDouble(x)  )));
               break;
            case 'C':
               p.push( String.valueOf( Math.cos( Double.parseDouble(x) )));
               break;
            case 'T':
               p.push( String.valueOf( Math.tan( Double.parseDouble(x) )));
               break;
            case 'L':
               try {
                  p.push( String.valueOf( Math.log(Double.parseDouble(x))));
                  break;
               }catch (Exception e){
                     System.out.println("error");
               }
            case 'A':
               p.push( String.valueOf( Math.abs( Double.parseDouble(x) )));
               break;
            default :
               System.out.println("incorrecto");
         }
      }
      public boolean func(String ffun){
         switch (ffun.charAt(0)){
            case 'S':
               funcion = true;
               break;
            case 'C':
               funcion = true;
               break;
            case 'A':
               funcion = true;
               break;
            case 'L':
               funcion = true;
               break;
            case 'T':
               funcion = true;
               break;
            default:
               funcion = false;
         }
         return(funcion);
      }
    private void calcularop(){
         String operador = (String)(p.pop());
         String op1 = (String)(p.pop());
         String op2 = (String)(p.pop());
         switch (operador.charAt(0)){
            case '+':
               p.push( String.valueOf (Double.parseDouble(op2)+ Double.parseDouble(op1)) );
               break;
            case '-':
               p.push( String.valueOf (Double.parseDouble(op2) - Double.parseDouble(op1)) );
               break;
            case '*':
               p.push( String.valueOf (Double.parseDouble(op2) * Double.parseDouble(op1)) );
               break;
            case '/':
               p.push( String.valueOf (Double.parseDouble(op2) / Double.parseDouble(op1)) );
               break;
            case '^':
               p.push( String.valueOf (Math.pow (Double.parseDouble(op2),Double.parseDouble(op1))) );
               break;
            default :
               System.out.println("incorrecto");
         }
      }
    public boolean oper(String opr){
         if (opr.length() == 1 ){
            char x = opr.charAt(0);
            switch (x){
               case '+':
                  operador = true;
                  break;
               case '-':
                  operador = true;
                  break;
               case '*':
                  operador = true;
                  break;
               case '/':
                  operador = true;
                  break;
               case '^':
                  operador = true;
                  break;
               default :
                  operador = false;
            }
         }else
            operador = false;
         return(operador);
      }//fin de oper
public static void main(String[] args){
calcPolaca aux = new calcPolaca("10,2,^     ".trim());
         double valor = aux.resultado;
System.out.println(valor);
}
}//fin de la clase polaca

/*
Universidad Autonoma del Carmen
Ciencias de la Informacion
Asignatura: Laboratorio de programación Visual Para Ingenieria
Profesor: Jesus Alejandro Flores Hernández
Alumno: Samuel Santos de La Cuz  Dic 2007
Proyecto--->  Graficadora de funciones en notacion polaca
a partir de calculadora grafica en polaca inversa escrita en C++
por Jesús Alejandro Flores Hernández
*/

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Graficadora{
       public static void main(String args[]){
         new Forma("Graficador de funciones en notacion Polaca");
      }
}

class Forma extends JFrame{
      public JTextField Tlim_inf,Tlim_sup,Texp;
JPanel p;
JComboBox opc;
JButton Bgraficar;
JLabel lim_inf,lim_sup,exp,ejemp;

      areaGrafica DG;
      Forma(String titulo){
         super(titulo);
         setDefaultCloseOperation(EXIT_ON_CLOSE);
         Container frame=this.getContentPane();
         frame.add(Panelprincipal());
         pack();
         show();
      }
      private JPanel Panelprincipal(){
         GridBagLayout gridbag;
         GridBagConstraints gbcon;
         p = new JPanel();
         DG=new areaGrafica();
         oyenteClick oy=new oyenteClick();
         gridbag = new GridBagLayout();
         p.setLayout(gridbag);
         gbcon = new GridBagConstraints();
         Bgraficar = new JButton("Graficar");
         gbcon.gridx =0 ;
         gbcon.gridy = 0;
         Bgraficar.addActionListener(oy);
         p.add(Bgraficar,gbcon);
         lim_inf = new JLabel("Limite Inferior");
         gbcon.gridx = 0;
         gbcon.gridy = 1;
         p.add(lim_inf,gbcon);
         Tlim_inf = new JTextField(8);
Tlim_inf.setText("-10");
         gbcon.gridx = 0;
         gbcon.gridy = 2;
         p.add(Tlim_inf,gbcon);
         lim_sup = new JLabel("Limite Superior");
         gbcon.gridx = 0;
         gbcon.gridy = 3;
         p.add(lim_sup,gbcon);
         Tlim_sup = new JTextField(8);
Tlim_sup.setText("10");
         gbcon.gridx = 0;
         gbcon.gridy = 4;
         p.add(Tlim_sup,gbcon);
   
         exp = new JLabel("Expresión");
         gbcon.gridx = 0;
         gbcon.gridy = 5;
         p.add(exp,gbcon);
   
         Texp = new JTextField(19);
Texp.setText("X,S");
         gbcon.gridx = 0;
         gbcon.gridy = 6;
         p.add(Texp,gbcon);
   
         ejemp = new JLabel("Ejemplos");
         gbcon.gridx = 0;
         gbcon.gridy = 7;
         p.add(ejemp,gbcon);
   
         opc = new JComboBox();
         opc.addItem("X,2,^    = x^2");
         opc.addItem("X,S      = seno(x)");
         opc.addItem("X,2,^,S  = seno(x^2)");
         opc.addItem("X,S,X,*  = seno(x)*x");
         opc.addItem("X,3,^    = x^3");
         opc.addItem("X,S,X,C,*= seno(x)*coseno(x)");
         opc.addItem("X,L      = log x");
         opc.addItem("X,S,A    = abs(sen(x))");
         opc.addItem("X,T    = tan(x)");
         opc.addItem("X,S,A,X,*= abs(sen(x))*x");
         gbcon.gridx = 0;
         gbcon.gridy = 8;
         opc.addActionListener(oy);
         p.add(opc,gbcon);
     
         gbcon.gridx = 2;
         gbcon.gridy= 2;
         gbcon.gridwidth = 20;
         gbcon.gridheight = 20;
         p.add(DG,gbcon);
         return(p);
      }
 
   
      class oyenteClick implements ActionListener{
          public void actionPerformed(ActionEvent evento){
            Object cual = evento.getSource();
       
            if (cual instanceof JButton){
               DG.EvalIntro(Texp,Tlim_inf,Tlim_sup);//------
            }else if (cual instanceof JComboBox){
JComboBox opciones = (JComboBox)(cual);
if(opciones.getSelectedIndex()==6){
Tlim_inf.setText("1");
                   Tlim_sup.setText(" 10");
}else{
Tlim_inf.setText("-10");
                Tlim_sup.setText(" 10");
}
//s.substring
Texp.setText(opciones.getSelectedItem().toString().substring(0,9));
            }//de if
         }//de action performed
      }//de oyenteclick
}

class areaGrafica extends Canvas{
      int AnchoCanvas = 500;
      int AltoCanvas = 500;
      boolean click;
      double valYmax=0.0;
      double valYmin=0.0;
      double li = 0.0;
      double ls = 0.0;
      String texAnt = "";
      String texAct = "";
      areaGrafica(){
         click = false;
         setSize(500,500);
      }
 
      void EvalIntro(JTextField Texp,JTextField Tlim_inf,JTextField Tlim_sup){
         li = Double.parseDouble(Tlim_inf.getText());
         ls = Double.parseDouble(Tlim_sup.getText());
         texAnt = Texp.getText();
         repaint();
         click = true;
      }
 
      public void paint(Graphics g){
         g.drawRect(0,0,499,499);
         if (click){
            int ys;
            int yp;
            calculaMaximoMinimoDeLaFuncion();
          yp = posicionY(0);        
            for (int xi=0; xi<500 i="" p=""> data-blogger-escaped-p="" data-blogger-escaped-xi="">               ys = posicionY(xi+1);
               g.drawLine (xi,yp,xi+1,ys);
               yp=ys;
            }
         }
      }
      void  calculaMaximoMinimoDeLaFuncion(){
         double aux=0;
valYmin=valYmax = valordeY(0);      
for (int i = 0 ; i < 500; i++){      
            aux =  valordeY(i);
            if (aux > valYmax) valYmax=aux;
            if (aux < valYmin) valYmin=aux;
         }
      }                                                                                                                                                                                                                                                                                                                          
      int posicionY (int num){
         double y;
         int posY;
         y = valordeY(num);
         posY = (int)( (y-valYmin) * (AltoCanvas-1) / (valYmax-valYmin) );
         posY = AltoCanvas - posY;
         return( posY );
      }
double valordeY(int num){
      double x,valor;
double delta=(ls-li)/(AnchoCanvas);
         x = li+(delta*num);
         texAct = texAnt.replaceAll("X",String.valueOf(x));
         calcPolaca aux = new calcPolaca(texAct.trim());
         valor = aux.resultado;
         return(valor);
}
}