//Jesus Alejandro Flores Hernandez
//codigo en SCILAB
//Ejemplode perceptron simple
//Probado y revisado 22 sep 2016
//Funcion OR
//Código para reconocer la entradas de la función OR
//
function graficaLinea(miColor)
    for i=1:100
        if w(2)==0 then
            y3(i)=0
        else
            y3(i)=(-w(1)*x2(i)-w(3))/w(2);  
        end
    end
    plot(x2,y3,miColor);
endfunction

nct=4; //tamaño del conjunto de trabajo
y=[-1,-1,1,1;-1,1,-1,1]
x=y';
x1=x(:,1);//Arreglo x1 contiene coordenadas x
y1=x(:,2);//Arreglo y1 contiene coordenadas y
plot(x1,y1,'*');

//pesos iniciales son w1=0 and w2=0, w3 es el umbral
//w=[1;1;0.5];
w=[0;0;0.5];
class_F=[-1;1;1;1]; //salida de la función OR

mfprintf(6,'Perceptron para reconocer la tabla Or \n'); //escribe a consola
mfprintf(6,'Linea roja pesos iniciales\n'); //escribe a consola
mfprintf(6,'Linea verde iteraciones\n'); //escribe a consola
mfprintf(6,'Linea azul pesos finales:\n    x     y     or'); //escribe a consola
disp([x,class_F]);

//muestra las puntos clasificados
for i=1:nct
        if class_F(i)==1 then
            plot(x1(i),y1(i),'gre*');
        else
            plot(x1(i),y1(i),'blu*');  
        end
end
//
x2=linspace(-2,2,100);
for i=1:100
    y2(i)=2*x2(i);
end
//muestra la recta del perceptron con los pesos actuales
for i=1:100
    if w(2)==0 then
        y3(i)=0
    else
        y3(i)=(-w(1)*x2(i)-w(3))/w(2);  
    end
   
end
plot(x2,y3,'r');


//Calculamos la salida del perceptron con los pesos
//actuales para todos los puntos
for i=1:nct
    g(i)=sign(w(2)*y1(i)+w(1)*x1(i)+w(3));
end
//~= operador relacionl es distonto que
//buscamos las salidas que no concuerdan con nuestra
//clasificación
ind = find(class_F ~= g);
iter=1;


while ~isempty(ind) //si es vacio => fin
    mfprintf(6,'iteracion %d salidas que no concuerdad:\n    real    g',iter);
    disp([class_F,g]);
    mfprintf(6,'vector de pesos:\n    w1    w2    w0=U');
    disp(w');
    //operador .* es multiplicación de matrices elemento a elemento
     w(1) = w(1) + (class_F(ind(1))-g(ind(1))).*x1(ind(1));  //
     w(2) = w(2) + (class_F(ind(1))-g(ind(1))).*y1(ind(1));  //
     w(3) = w(3) + (class_F(ind(1))-g(ind(1)));  //
    //calcular la salida del perceptron
    for i=1:nct
         temp(i)=sign(w(2)*y1(i)+w(1)*x1(i)+w(3));
    end
    //buscar salidas que no concuerdan
    ind = find(class_F ~= temp);
    g=temp;

    iter = iter + 1;
    if iter>600 then
        break;
    end
    graficaLinea('g');
end
mfprintf(6,'- - Al final de %d iteraciones\nvector de indices - - -',iter); //escribe a consola
disp(ind);
mfprintf(6,'vector de clasificación / vector salida: \nClass_F  g');
disp([class_F,g]);

mfprintf(6,'vector de pesos:\n    w1    w2    w0=U');
disp(w');

graficaLinea('b');

Comparación: Lenguajes de programación de propósito general UNACAR CA-35

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);
}
}