/*

 Applet para aplicar el método Electra.
 El applet permite evaluar como máximo cuatro
 alternativas en base a diez criterios.

 Autor : Víctor Martínez Ortiz.

 El código del applet está basado en las notas de 
 la clase de Diseño de Procesos, impartida por el
 Dr. Enrique Arce Medina de la ESIQIE-IPN.

 Marzo de 2001.

*/

import java.io.*;
import java.awt.*;
import java.util.*;
import java.applet.*;
import java.awt.event.*;

public class AppletElectra extends Applet
{
    // algoritmo
    private int na=0,nc=0;
    private Integer p=new Integer(-1);
    private Integer q=new Integer(-1);
    private Integer mat_cal[][];
    private Integer mat_con[][];
    private Integer mat_dis[][];
    // vectores para tabla de dominancias
    Vector DominaA;
    boolean generarInforme=false;
    Vector DominadaPor;
    // applet
    String archivo="";
    TextArea resultados;
    Button calcular;
    Button ASCII;
    Button LaTeX;
    Button abrir;
    Button guardar;
    TextField celdas[][];
    TextField alternativas[];
    TextField criterios[];
    Checkbox dadoQ;
    Checkbox dadoP;
    TextField valorQ;
    TextField valorP;

    private void parametrosElectra()
    {
        int C=0,A=0;
        String ast="";
        // establece número de criterios y de alternativas
        for (int i=0;i<4;i++)
        {
            ast=alternativas[i].getText();
            if (!ast.equals("*")) A++;
        }
        for (int i=0;i<10;i++)
        {
            ast=criterios[i].getText();
            if (!ast.equals("*")) C++;
        }
        // dimensiona arreglos
        na=A;
        nc=C;
        // dimensiona arreglos
        mat_cal=new Integer[na+1][nc];
        mat_dis=new Integer[na][na];
        mat_con=new Integer[na][na];
        // dimensiona vectores
        DominaA=new Vector();
        DominadaPor=new Vector();
        // agrega vectores vacios al vector "contenedor"
        for (int i=0;i<na;i++)
        {
            DominaA.addElement(new Vector());
            DominadaPor.addElement(new Vector());
        }
        // lee datos de las celdas
        leerCeldas();
    }

    private void algoritmoElectra()
    {
        int i,j,k,g,suma,max;
        try
        {
        // cálculo de matriz de concordancia
        for (i=0;i<na;i++)
        {
            for (j=0;j<na;j++)
            {
                // evita la diagonal
                suma=0;
                if (i!=j)
                {
                    for (k=0;k<nc;k++)
                    {
                        g=0;
                        if(mat_cal[i][k].intValue()>=mat_cal[j][k].intValue())
                        {
                            g=1;
                        }
                        suma+=g*mat_cal[na][k].intValue();
                    }
                }
                mat_con[i][j]=new Integer(suma);
            }
        }
        // cálculo de matriz de discordancia
        for (i=0;i<na;i++)
        {
            for (j=0;j<na;j++)
            {
                mat_dis[i][j]=new Integer(0);
                // evita la diagonal
                if (i!=j)
                {
                    max=mat_cal[j][0].intValue()-mat_cal[i][0].intValue();
                    for (k=1;k<nc;k++)
                    {
                        if((mat_cal[j][k].intValue()-mat_cal[i][k].intValue())>max)
                        {
                            max=mat_cal[j][k].intValue()-mat_cal[i][k].intValue();
                        }
                    }
                    mat_dis[i][j]=new Integer(max);
                    if (max<0) mat_dis[i][j]=new Integer(0);
                }
            }
        }
        // cálculo de p
        suma=0;
        for (i=0;i<na;i++)
        {
            for (j=0;j<na;j++)
            {
                suma+=mat_con[i][j].intValue();
            }
        }
        p=new Integer((int)Math.ceil((double)suma/(double)(na*na-na)));
        //cálculo de q
        suma=0;
        for (i=0;i<na;i++)
        {
            for (j=0;j<na;j++)
            {
                suma+=mat_dis[i][j].intValue();
            }
        }
        q=new Integer((int)Math.ceil((double)suma/(double)(na*na-na)));
        // verifica si q y p se dan o se calculan
        if (dadoP.getState()==true)
            p=Integer.valueOf(valorP.getText());
        if (dadoQ.getState()==true)
            q=Integer.valueOf(valorQ.getText());
        // elabora tabla "Domina a"
        for (i=0;i<na;i++)
        {
            for (j=0;j<na;j++)
            {
                if(i!=j)
                {
                    if (mat_con[i][j].intValue()>=p.intValue())
                    {
                        if (mat_dis[i][j].intValue()<=q.intValue())
                        {
                            // agrega altenativa a la lista (i: domina a j)
                            ((Vector)DominaA.elementAt(i)).addElement(new String("A"+(j+1)));
                        }
                    }
                }
            }
        }
        // elabora tabla "Dominada por"
        for (j=0;j<na;j++)
        {
            for (i=0;i<na;i++)
            {
                if(i!=j)
                {
                    if (mat_con[j][i].intValue()>=p.intValue())
                    {
                        if (mat_dis[j][i].intValue()<=q.intValue())
                        {
                            // agrega alternativa a la lista (i: es dominada por j)
                            ((Vector)DominadaPor.elementAt(i)).addElement(new String("A"+(j+1)));
                        }
                    }
                }
            }
        }
        }
        catch(Exception e)
        {
            resultados.append("\n----------------------------------------------\n");
            resultados.append("ERROR: Algunos de lo datos\n");
            resultados.append("proporcionados son erróneos...\n");
        }
    }

    private void escribeResultados()
    {
        resultados.append("\n----------------------------------------------\n");
        resultados.append("\nAltenativas\n\n");
        for (int i=0;i<na;i++)
            resultados.append("A"+(i+1)+" : "+alternativas[i].getText()+"\n");
        resultados.append("\nCriterios\n\n");
        for (int i=0;i<nc;i++)
            resultados.append("C"+(i+1)+" : "+criterios[i].getText()+"\n");
        resultados.append("\nResultados\n");
        resultados.append("\nMatriz de calificaciones y pesos\n\n");
        for (int i=0;i<na+1;i++)
        {
            if (i==0)
                resultados.append("\t");
            else
                resultados.append("A"+i+"\t");
        }
        resultados.append("Pesos"+"\n");
        for (int j=0;j<nc;j++)
        {
            for (int i=-1;i<na+1;i++)
            {
                if (i==-1)
                    resultados.append("C"+(j+1)+"\t");
                else
                    resultados.append(mat_cal[i][j]+"\t");
            }
            resultados.append("\n");
        }
        resultados.append("\nMatriz de concordancias\n\n");
        for (int i=0;i<na+1;i++)
        {
            if (i==0)
                resultados.append("\t");
            else
                resultados.append("A"+i+"\t");
        }
        resultados.append("\n");
        for (int i=0;i<na;i++)
        {
            for (int j=-1;j<na;j++)
            {
                if (j==-1)
                    resultados.append("A"+(i+1)+"\t");
                else
                    resultados.append(mat_con[i][j]+"\t");
            }
            resultados.append("\n");
        }
        resultados.append("\np = "+p+"\n\n");
        resultados.append("\nMatriz de discordancias\n\n");
        for (int i=0;i<na+1;i++)
        {
            if (i==0)
                resultados.append("\t");
            else
                resultados.append("A"+i+"\t");
        }
        resultados.append("\n");
        for (int i=0;i<na;i++)
        {
            for (int j=-1;j<na;j++)
            {
                if (j==-1)
                    resultados.append("A"+(i+1)+"\t");
                else
                    resultados.append(mat_dis[i][j]+"\t");
            }
            resultados.append("\n");
        }
        resultados.append("\nq = "+q+"\n");
        int k;
        resultados.append("\nDomina a :\n\n");
        k=0;
        Enumeration e1=DominaA.elements();
        while(e1.hasMoreElements())
        {
            resultados.append("A"+(k+1)+" :\t");
            Enumeration e2=((Vector)e1.nextElement()).elements();
            while (e2.hasMoreElements())
                resultados.append((String)e2.nextElement()+"\t");
            k++;
            resultados.append("\n");
        }
        resultados.append("\nDominada por :\n\n");
        k=0;
        Enumeration e3=DominadaPor.elements();
        while(e3.hasMoreElements())
        {
            resultados.append("A"+(k+1)+" :\t");
            Enumeration e4=((Vector)e3.nextElement()).elements();
            while (e4.hasMoreElements())
                resultados.append((String)e4.nextElement()+"\t");
            k++;
            resultados.append("\n");
        }
    }

    public void llenarCeldas()
    {
        // pone en ceros todas las celdas
        for (int i=0;i<10;i++)
        {
            for (int j=0;j<5;j++)
                celdas[i][j].setText(""+0);
        }
        // copia calificaciones
        for (int i=0;i<nc;i++)
        {
            for (int j=0;j<na;j++)
            {
                celdas[i][j].setText(""+mat_cal[j][i].intValue());
            }
        }
        // copia pesos
        for (int i=0;i<nc;i++)
        {
            int j=na;
            celdas[i][4].setText(""+mat_cal[j][i].intValue());
        }
        // carga p y q
        valorP.setText(""+p);
        valorQ.setText(""+q);
        resultados.append("\n----------------------------------------------\n");
        resultados.append("Llenando las celdas con datos\n");
    }

    public void leerCeldas()
    {
        // lee calificaciones
        for (int i=0;i<nc;i++)
        {
            for (int j=0;j<na;j++)
            {
                mat_cal[j][i]=Integer.valueOf(celdas[i][j].getText());
            }
        }
        // lee pesos        
        for (int i=0;i<nc;i++)
            mat_cal[na][i]=Integer.valueOf(celdas[i][4].getText());
        resultados.append("\n----------------------------------------------\n");
        resultados.append("Leyendo datos de las celdas\n");
    }

    public void init()
    {
        Panel panelDescripcion;
        Panel contenedorCeldas;
        Panel etiquetasDescripcion;
        Panel contenedorDescripcion;
        Panel contenedorPQ;
        Panel botones;
        Panel derecho;
        // layout del applet
        setLayout(new FlowLayout(FlowLayout.CENTER,10,10));
        // dimensiona vectores de descripción y altenativas
        alternativas=new TextField[4];
        criterios=new TextField[10];
        for (int i=0;i<4;i++)
            alternativas[i]=new TextField("*",20);
        for (int i=0;i<10;i++)
            criterios[i]=new TextField("*",20);
        // dimensiona matriz de celdas
        celdas=new TextField[10][5];
        for (int f=0;f<10;f++)
            for (int c=0;c<5;c++)
                celdas[f][c]=new TextField("0",6);
        // configura interfaz de usuario
        setBackground(new Color(255,255,255));
        // botones de abrir y cerrar archivos
        guardar=new Button("Guardar datos");
        // agrega manejador
        guardar.addActionListener(new ActionListener()
            {
                public void actionPerformed(ActionEvent e)
                {
                    guardarDatos();
                }
            }
        );
        abrir=new Button("Leer datos");
        // agrega manejador
        abrir.addActionListener(new ActionListener()
            {
                public void actionPerformed(ActionEvent e)
                {
                    abrirDatos();
                }
            }
        );
        //agrega elementos al panel
        contenedorDescripcion=new Panel(new GridLayout(16,1));
        etiquetasDescripcion=new Panel(new GridLayout(16,1));
        etiquetasDescripcion.add(new Label());
        contenedorDescripcion.add(new Label("Alternativas"));
        for (int i=0;i<4;i++)
        {
            etiquetasDescripcion.add(new Label("A"+(i+1)+" : ",Label.LEFT));
            contenedorDescripcion.add(alternativas[i]);
        }
        etiquetasDescripcion.add(new Label());
        contenedorDescripcion.add(new Label("Criterios"));
        for (int j=0;j<10;j++)
        {
            etiquetasDescripcion.add(new Label("C"+(j+1)+" : ",Label.LEFT));
            contenedorDescripcion.add(criterios[j]);
        }
        panelDescripcion=new Panel(new BorderLayout());
        panelDescripcion.add(BorderLayout.WEST,etiquetasDescripcion);
        panelDescripcion.add(BorderLayout.CENTER,contenedorDescripcion);
        // agrega celdas
        contenedorCeldas=new Panel(new GridLayout(11,6));
        // inserta celda invisible
        contenedorCeldas.add(new Label());
        // inserta primera fila
        for (int f=1;f<=4;f++)
            contenedorCeldas.add(new Label("A"+f,Label.CENTER));
        contenedorCeldas.add(new Label("Pesos"));
        int k=1;
        for (int f=1;f<=10;f++)
            for (int c=0;c<6;c++)
                if (c==0)
                    contenedorCeldas.add(new Label("C"+(f),Label.CENTER));
                else
                    contenedorCeldas.add(celdas[f-1][c-1]);
        dadoQ=new Checkbox("q = ",false);
        // agrega manejador
        dadoQ.addItemListener(new ItemListener()
            {
                public void itemStateChanged(ItemEvent e)
                {
                    if(dadoQ.getState()==false)
                        valorQ.setEnabled(false);
                    else
                        valorQ.setEnabled(true);
                }
            }
        );
        dadoP=new Checkbox("p = ",false);
        // agrega manejador
        dadoP.addItemListener(new ItemListener()
            {
                public void itemStateChanged(ItemEvent e)
                {
                    if(dadoP.getState()==false)
                        valorP.setEnabled(false);
                    else
                        valorP.setEnabled(true);
                }
            }
        );
        calcular=new Button("Evaluar alternativas");
        // agrega manejador
        calcular.addActionListener( new ActionListener()
            {
                public void actionPerformed(ActionEvent e)
                {
                    evaluaAlternativas();
                }
            }
        );
        // espacio para resultados
        resultados=new TextArea("",13,80,TextArea.SCROLLBARS_BOTH);
        resultados.setFont(new Font("Courier New",Font.PLAIN,12));
        // botones de exportación de resultados
        ASCII=new Button("Informe en ASCII");
        // agrega manejador
        ASCII.addActionListener(new ActionListener()
            {
                public void actionPerformed(ActionEvent e)
                {
                    informeASCII();
                }
            }
        );
        LaTeX=new Button("Informe en LaTeX");
        // agrega manejador
        LaTeX.addActionListener(new ActionListener()
            {
                public void actionPerformed(ActionEvent e)
                {
                    informeLaTeX();
                }
            }
        );
        // contenedor PQ
        valorQ=new TextField();
        valorQ.setEnabled(false);
        valorP=new TextField();
        valorP.setEnabled(false);
        contenedorPQ=new Panel(new GridLayout(1,5,5,0));
        contenedorPQ.add(new Label(""));
        contenedorPQ.add(dadoP);
        contenedorPQ.add(valorP);
        contenedorPQ.add(dadoQ);
        contenedorPQ.add(valorQ);
        // panel de botones
        botones=new Panel(new GridLayout(1,5,0,0));
        botones.add(abrir);
        botones.add(guardar);
        botones.add(calcular);
        botones.add(ASCII);
        botones.add(LaTeX);
        // panel del lado derecho
        derecho=new Panel(new BorderLayout(0,10));
        derecho.add(BorderLayout.CENTER,contenedorCeldas);
        derecho.add(BorderLayout.SOUTH,contenedorPQ);
        // agrega elementos al layout principal
        add(panelDescripcion);
        add(derecho);
        add(botones);
        add(resultados);
        // carga los datos del ejemplo
        cargarEjemplo();
    }

    private void evaluaAlternativas()
    {
        parametrosElectra();
        algoritmoElectra();
        escribeResultados();
        generarInforme=true;
        // carga p y q
        valorP.setText(""+p);
        valorQ.setText(""+q);
    }

    private void guardarDatos()
    {
        // lee datos de las celdas y carga en la memoria
        parametrosElectra();
        // lee nombre del archivo con diálogo
        Frame marco=new Frame();
        FileDialog guardar=new FileDialog(marco,"Guardar en archivo local",FileDialog.SAVE);
        try
        {
            guardar.setFile(archivo);
            guardar.show();
        }
        catch(Exception e)
        {
            resultados.append("\n----------------------------------------------\n");
            resultados.append("El applet no tiene permiso para abrir\n");
            resultados.append("archivos en su sistema...\n");
        }
        //archivo=guardar.getDirectory()+guardar.getFile();
        archivo=guardar.getFile();
        marco.dispose();
        guardar.dispose();
        // acccion ante la cancelación de usuario
        if (archivo==null)
        {
            resultados.append("\n----------------------------------------------\n");
            resultados.append("Se canceló el proceso de almacenamiento\n");
            archivo="";
            return;
        }
        // guarda datos en archivo
        try
        {
            DataOutputStream salida=
                new DataOutputStream(
                    new BufferedOutputStream(
                        new FileOutputStream(archivo)));
            // escribe datos
            salida.writeInt(p.intValue());
            salida.writeInt(q.intValue());
            salida.writeInt(na);
            salida.writeInt(nc);
            // escribe calificaciones
            for (int i=0;i<na;i++)
            {
                for (int j=0;j<nc;j++)
                {
                    salida.writeInt(mat_cal[i][j].intValue());
                }
            }
            // escribe pesos
            for (int j=0;j<nc;j++)
            {
                salida.writeInt(mat_cal[na][j].intValue());
            }
            // guarda descripciones
            for (int i=0;i<na;i++)
                salida.writeUTF(alternativas[i].getText());
            for (int i=0;i<nc;i++)
                salida.writeUTF(criterios[i].getText());
            salida.close();
            resultados.append("\n----------------------------------------------\n");
            resultados.append("Se guardaron los datos en el archivo "+archivo+"\n");
        }
        catch(IOException e)
        {
            resultados.append("\n----------------------------------------------\n");
            resultados.append("Error en el proceso de escritura\n");
        }
    }

    private void abrirDatos()
    {
        // lee nombre del archivo con diálogo
        Frame marco=new Frame();
        FileDialog abrir=new FileDialog(marco,"Abrir en archivo local",FileDialog.LOAD);
        try
        {
            abrir.show();
        }
        catch(Exception e)
        {
            resultados.append("\n----------------------------------------------\n");
            resultados.append("El applet no tiene permiso para guardar\n");
            resultados.append("archivos en su sistema...\n");
        }
        // archivo=abrir.getDirectory()+abrir.getFile();
        archivo=abrir.getFile();
        marco.dispose();
        abrir.dispose();
        if (archivo==null)
        {
            resultados.append("\n----------------------------------------------\n");
            resultados.append("Se canceló el proceso de lectura\n");
            archivo="";
            return;
        }
        // guarda datos en archivo
        try
        {
            DataInputStream entrada=
                new DataInputStream(
                    new BufferedInputStream(
                        new FileInputStream(archivo)));
            // escribe datos
            p=new Integer(entrada.readInt());
            q=new Integer(entrada.readInt());
            na=entrada.readInt();
            nc=entrada.readInt();
            // pone en cero todas las celdas
            for (int i=0;i<4;i++)
            {
                for (int j=0;j<10;j++)
                    celdas[j][i].setText(""+0);
            }
            // escribe calificaciones
            for (int i=0;i<na;i++)
            {
                for (int j=0;j<nc;j++)
                    celdas[j][i].setText(""+entrada.readInt());
            }
            // escribe pesos
            for (int j=0;j<nc;j++)
                celdas[j][4].setText(""+entrada.readInt());
            // inicializa celdas de descripción
            for (int i=0;i<4;i++)
                alternativas[i].setText("*");
            for (int i=0;i<10;i++)
                criterios[i].setText("*");
            // escribe nombre de las alternativas
            for (int i=0;i<na;i++)
                alternativas[i].setText(entrada.readUTF());
            for (int i=0;i<nc;i++)
                criterios[i].setText(entrada.readUTF());
            entrada.close();
            resultados.append("\n----------------------------------------------\n");
            resultados.append("Se leyeron datos del archivo "+archivo+"\n");
        }
        catch(IOException e)
        {
            resultados.append("\n----------------------------------------------\n");
            resultados.append("Error en el proceso de lectura\n");
        }
    }

    private void cargarEjemplo()
    {
        // carga descripción
        for (int i=0;i<4;i++)
            alternativas[i].setText("Alternativa "+(i+1));
        for (int i=0;i<4;i++)
            criterios[i].setText("Criterio "+(i+1));
        // carga celdas
        celdas[0][0].setText(""+0);
        celdas[0][1].setText(""+1);
        celdas[0][2].setText(""+4);
        celdas[0][3].setText(""+4);
        celdas[0][4].setText(""+2);
        celdas[1][0].setText(""+2);
        celdas[1][1].setText(""+2);
        celdas[1][2].setText(""+3);
        celdas[1][3].setText(""+5);
        celdas[1][4].setText(""+3);
        celdas[2][0].setText(""+1);
        celdas[2][1].setText(""+3);
        celdas[2][2].setText(""+2);
        celdas[2][3].setText(""+4);
        celdas[2][4].setText(""+4);
        celdas[3][0].setText(""+4);
        celdas[3][1].setText(""+4);
        celdas[3][2].setText(""+2);
        celdas[3][3].setText(""+3);
        celdas[3][4].setText(""+5);
    }

    private void informeASCII()
    {
        String archivoASCII="";
        // verifica que exista que reportar
        if (generarInforme==false)
        {
            resultados.append("\n----------------------------------------------\n");
            resultados.append("No hay nada que reportar\n");
            return;
        }
        // lee nombre del archivo con diálogo
        Frame marco=new Frame();
        FileDialog guardar=new FileDialog(marco,"Exportar informe ASCII",FileDialog.SAVE);
        try
        {
            guardar.setFile(archivoASCII);
            guardar.show();
        }
        catch(Exception e)
        {
            resultados.append("\n----------------------------------------------\n");
            resultados.append("El applet no tiene permiso para abrir\n");
            resultados.append("archivos en su sistema...\n");
        }
        //archivo=guardar.getDirectory()+guardar.getFile();*************
        archivoASCII=guardar.getFile();
        marco.dispose();
        guardar.dispose();
        // acccion ante la cancelación de usuario
        if (archivoASCII==null)
        {
            resultados.append("\n----------------------------------------------\n");
            resultados.append("Se canceló la generación del informe\n");
            return;
        }
        // guarda datos en archivo
        try
        {
            DataOutputStream salidaASCII=
                new DataOutputStream(
                    new BufferedOutputStream(
                        new FileOutputStream(archivoASCII)));
            salidaASCII.writeBytes("\nAltenativas\n\n");
            for (int i=0;i<na;i++)
                salidaASCII.writeBytes("A"+(i+1)+" : "+alternativas[i].getText()+"\n");
            salidaASCII.writeBytes("\nCriterios\n\n");
            for (int i=0;i<nc;i++)
                salidaASCII.writeBytes("C"+(i+1)+" : "+criterios[i].getText()+"\n");
            salidaASCII.writeBytes("\nMatriz de calificaciones y pesos\n\n");
            for (int i=0;i<na+1;i++)
            {
                if (i==0)
                    salidaASCII.writeBytes("\t");
                else
                    salidaASCII.writeBytes("A"+i+"\t");
            }
            salidaASCII.writeBytes("Pesos"+"\n");
            for (int j=0;j<nc;j++)
            {
                for (int i=-1;i<na+1;i++)
                {
                    if (i==-1)
                        salidaASCII.writeBytes("C"+(j+1)+"\t");
                    else
                        salidaASCII.writeBytes(mat_cal[i][j]+"\t");
                }
                salidaASCII.writeBytes("\n");
            }
            salidaASCII.writeBytes("\nMatriz de concordancias\n\n");
            for (int i=0;i<na+1;i++)
            {
                if (i==0)
                    salidaASCII.writeBytes("\t");
                else
                    salidaASCII.writeBytes("A"+i+"\t");
            }
            salidaASCII.writeBytes("\n");
            for (int i=0;i<na;i++)
            {
                for (int j=-1;j<na;j++)
                {
                    if (j==-1)
                        salidaASCII.writeBytes("A"+(i+1)+"\t");
                    else
                        salidaASCII.writeBytes(mat_con[i][j]+"\t");
                }
                salidaASCII.writeBytes("\n");
            }
            salidaASCII.writeBytes("\np = "+p+"\n\n");
            salidaASCII.writeBytes("\nMatriz de discordancias\n\n");
            for (int i=0;i<na+1;i++)
            {
                if (i==0)
                    salidaASCII.writeBytes("\t");
                else
                    salidaASCII.writeBytes("A"+i+"\t");
            }
            salidaASCII.writeBytes("\n");
            for (int i=0;i<na;i++)
            {
                for (int j=-1;j<na;j++)
                {
                    if (j==-1)
                        salidaASCII.writeBytes("A"+(i+1)+"\t");
                    else
                        salidaASCII.writeBytes(mat_dis[i][j]+"\t");
                }
                salidaASCII.writeBytes("\n");
            }
            salidaASCII.writeBytes("\nq = "+q+"\n");
            int k;
            salidaASCII.writeBytes("\nDomina a :\n\n");
            k=0;
            Enumeration e1=DominaA.elements();
            while(e1.hasMoreElements())
            {
                salidaASCII.writeBytes("A"+(k+1)+" :\t");
                Enumeration e2=((Vector)e1.nextElement()).elements();
                while (e2.hasMoreElements())
                    salidaASCII.writeBytes((String)e2.nextElement()+"\t");
                k++;
                salidaASCII.writeBytes("\n");
            }
            salidaASCII.writeBytes("\nDominada por :\n\n");
            k=0;
            Enumeration e3=DominadaPor.elements();
            while(e3.hasMoreElements())
            {
                salidaASCII.writeBytes("A"+(k+1)+" :\t");
                Enumeration e4=((Vector)e3.nextElement()).elements();
                while (e4.hasMoreElements())
                    salidaASCII.writeBytes((String)e4.nextElement()+"\t");
                k++;
                salidaASCII.writeBytes("\n");
            }
            salidaASCII.close();
            resultados.append("\n----------------------------------------------\n");
            resultados.append("Se generó reporte en ASCII\n");
        }
        catch(IOException e)
        {
            resultados.append("\n----------------------------------------------\n");
            resultados.append("Error en el proceso de escritura\n");
        }
    }

    private void informeLaTeX()
    {
        String archivoLaTeX="";
        // verifica que exista que reportar
        if (generarInforme==false)
        {
            resultados.append("\n----------------------------------------------\n");
            resultados.append("No hay nada que reportar\n");
            return;
        }
        String esp="\\hspace{20pt}";
        // lee nombre del archivo con diálogo
        Frame marco=new Frame();
        FileDialog guardar=new FileDialog(marco,"Exportar informe LaTeX",FileDialog.SAVE);
        try
        {
            guardar.setFile(archivoLaTeX);
            guardar.show();
        }
        catch(Exception e)
        {
            resultados.append("\n----------------------------------------------\n");
            resultados.append("El applet no tiene permiso para abrir\n");
            resultados.append("archivos en su sistema...\n");
        }
        //archivo=guardar.getDirectory()+guardar.getFile();*************
        archivoLaTeX=guardar.getFile();
        marco.dispose();
        guardar.dispose();
        // acccion ante la cancelación de usuario
        if (archivoLaTeX==null)
        {
            resultados.append("\n----------------------------------------------\n");
            resultados.append("Se canceló la generación del informe\n");
            return;
        }
        // guarda datos en archivo
        try
        {
            DataOutputStream salidaLaTeX=
                new DataOutputStream(
                    new BufferedOutputStream(
                        new FileOutputStream(archivoLaTeX)));
            // escribe preámbulo de LaTeX
            salidaLaTeX.writeBytes("\\documentclass[letterpaper,10pt]{report}\n");
            salidaLaTeX.writeBytes("\\usepackage[spanish, activeacute]{babel}\n");
            salidaLaTeX.writeBytes("\\usepackage[latin1]{inputenc}\n");
            salidaLaTeX.writeBytes("\\begin{document}\n");
            salidaLaTeX.writeBytes("{\\Huge M'etodo Electra}\n"); //'
            // describe las alternativas
            salidaLaTeX.writeBytes("\\section*{Altenativas}\n");
            salidaLaTeX.writeBytes("\\begin{description}\n");
            for (int i=0;i<na;i++)
                salidaLaTeX.writeBytes("\\item[A"+(i+1)+" :]{"+alternativas[i].getText()+"}\n");
            salidaLaTeX.writeBytes("\\end{description}\n");
            // describe a los criterios
            salidaLaTeX.writeBytes("\\section*{Criterios}\n");
            salidaLaTeX.writeBytes("\\begin{description}\n");
            for (int i=0;i<nc;i++)
                salidaLaTeX.writeBytes("\\item[C"+(i+1)+" :]{"+criterios[i].getText()+"}\n");
            salidaLaTeX.writeBytes("\\end{description}\n");
            // matriz de calificaciones y pesos
            salidaLaTeX.writeBytes("\\section*{Matriz de calificaciones y pesos}\n");
            salidaLaTeX.writeBytes("\\begin{tabular}{");
            for (int i=0;i<na+2;i++)
                salidaLaTeX.writeBytes("r");
            salidaLaTeX.writeBytes("}\n\\hline\n");
            for (int i=0;i<na+1;i++)
            {
                if (i==0)
                    salidaLaTeX.writeBytes("&");
                else
                    salidaLaTeX.writeBytes("A"+i+"&");
            }
            salidaLaTeX.writeBytes("Pesos"+"\\\\\n");
            for (int j=0;j<nc;j++)
            {
                for (int i=-1;i<na+1;i++)
                {
                    if (i==-1)
                        salidaLaTeX.writeBytes("C"+(j+1)+"&");
                    else if(i==na)
                        salidaLaTeX.writeBytes(mat_cal[i][j]+"\\\\");
                    else
                        salidaLaTeX.writeBytes(mat_cal[i][j]+"&");
                }
                salidaLaTeX.writeBytes("\n");
            }
            salidaLaTeX.writeBytes("\\hline\n\\end{tabular}\n");
            // matriz de concordancias
            salidaLaTeX.writeBytes("\\section*{Matriz de concordancias}\n");
            salidaLaTeX.writeBytes("\\begin{tabular}{");
            for (int i=0;i<na+1;i++)
                            salidaLaTeX.writeBytes("}\n\\hline\n");
            for (int i=0;i<na+1;i++)
            {
                if (i==0)
                    salidaLaTeX.writeBytes("&");
                else if(i==na)
                    salidaLaTeX.writeBytes("A"+i+"\\\\\n");
                else
                    salidaLaTeX.writeBytes("A"+i+"&");
            }
            for (int i=0;i<na;i++)
            {
                for (int j=-1;j<na;j++)
                {
                    if (j==-1)
                        salidaLaTeX.writeBytes("A"+(i+1)+"&");
                    else if(j==na-1)
                        salidaLaTeX.writeBytes(mat_con[i][j]+"\\\\\n");
                    else
                        salidaLaTeX.writeBytes(mat_con[i][j]+"&");
                }
            }
            salidaLaTeX.writeBytes("\\hline\n\\end{tabular}\n");
            // escribe valor de p
            salidaLaTeX.writeBytes("\\begin{description}\n");
            salidaLaTeX.writeBytes("\\item[p = ]{"+p+"}\n");
            salidaLaTeX.writeBytes("\\end{description}\n");
            // matriz de discordancias
            salidaLaTeX.writeBytes("\\section*{Matriz de discordancias}\n");
            salidaLaTeX.writeBytes("\\begin{tabular}{");
            for (int i=0;i<na+1;i++)
                salidaLaTeX.writeBytes("r");
            salidaLaTeX.writeBytes("}\n\\hline\n");
            for (int i=0;i<na+1;i++)
            {
                if (i==0)
                    salidaLaTeX.writeBytes("&");
                else if (i==na)
                    salidaLaTeX.writeBytes("A"+i+"\\\\\n");
                else
                    salidaLaTeX.writeBytes("A"+i+"&");
            }
            for (int i=0;i<na;i++)
            {
                for (int j=-1;j<na;j++)
                {
                    if (j==-1)
                        salidaLaTeX.writeBytes("A"+(i+1)+"&");
                    else if(j==na-1)
                        salidaLaTeX.writeBytes(mat_dis[i][j]+"\\\\\n");
                    else
                        salidaLaTeX.writeBytes(mat_dis[i][j]+"&");
                }
            }
            salidaLaTeX.writeBytes("\\hline\n\\end{tabular}\n");
            // escribe valor de q
            salidaLaTeX.writeBytes("\\begin{description}\n");
            salidaLaTeX.writeBytes("\\item[q = ]{"+q+"}\n");
            salidaLaTeX.writeBytes("\\end{description}\n");
            // tabla "domina a"
            int k;
            salidaLaTeX.writeBytes("\\section*{Domina a :}\n");
            k=0;
            Enumeration e1=DominaA.elements();
            salidaLaTeX.writeBytes("\\begin{description}\n");
            while(e1.hasMoreElements())
            {
                salidaLaTeX.writeBytes("\\item[A"+(k+1)+" : ]{");
                Enumeration e2=((Vector)e1.nextElement()).elements();
                while (e2.hasMoreElements())
                    salidaLaTeX.writeBytes((String)e2.nextElement()+esp);
                k++;
                salidaLaTeX.writeBytes("}\n");
            }
            salidaLaTeX.writeBytes("\\end{description}\n");
            // tabla "dominada por"
            salidaLaTeX.writeBytes("\\section*{Dominada por :}\n");
            k=0;
            Enumeration e3=DominadaPor.elements();
            salidaLaTeX.writeBytes("\\begin{description}\n");
            while(e3.hasMoreElements())
            {
                salidaLaTeX.writeBytes("\\item[A"+(k+1)+" : ]{");
                Enumeration e4=((Vector)e3.nextElement()).elements();
                while (e4.hasMoreElements())
                    salidaLaTeX.writeBytes((String)e4.nextElement()+esp);
                k++;
                salidaLaTeX.writeBytes("}\n");
            }
            salidaLaTeX.writeBytes("\\end{description}\n");
            // finaliza documento LaTeX
            salidaLaTeX.writeBytes("\\end{document}");
            salidaLaTeX.close();
            resultados.append("\n----------------------------------------------\n");
            resultados.append("Se generó informe en formato para LaTeX\n");
        }
        catch(IOException e)
        {
            resultados.append("\n----------------------------------------------\n");
            resultados.append("Error en el proceso de escritura\n");
        }
    }
}

Regresar a Electra