package maticegrafika;

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

/**
 * <p>Title: Maticova kalkulacka</p>
 * <p>Description: Provadeni operaci s maticemi</p>
 * <p>Copyright: Lukas Stepan (c) 2006</p>
 * <p>Company: FEL CVUT</p>
 * @author Lukas Stepan
 * @version 1.1
 */

class Okno1 extends JFrame implements ActionListener,ItemListener{

  int iA,jA,iB,jB,iC,jC;
  int volba = 0;
  private int iDF = 0;
  JTextField [][]MAs = new JTextField[6][6];
  JTextField [][]MBs = new JTextField[6][6];
  double [][]MAi = new double[6][6];
  double [][]MBi = new double[6][6];
  double [][]MCi = new double[6][6];
  GridBagLayout gbl;
  GridBagConstraints gbc;
  GridBagLayout gbl2;
  GridBagConstraints gbc2;
  Panel stred = new Panel();
  Panel dole = new Panel();
  Choice Operace = new Choice();
  //JComboBox Operace = new JComboBox();
  JTextField b ;
  JLabel Vysledek;
  JTextField Art = new JTextField(2);
  JTextField Ast = new JTextField(2);
  JTextField Brt = new JTextField(2);
  JTextField Bst = new JTextField(2);

  public Okno1 (){

//hlavni okno
    super ("Maticova kalkulacka");
    setSize (530,600);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setVisible(true);
    Container kon = getContentPane(); // vrací kontejner
    kon.setBackground(new Color(100,100,240));

//prava strana a vrch
    Panel prava = new Panel();
    Panel vrch = new Panel();
    JButton exit = new JButton("Exit");
    JButton help = new JButton("Help");
    JButton VytvorMatici = new JButton("Vytvor matici");
    JButton Vypocet = new JButton("Vypocet");
    FlowLayout srf = new FlowLayout();
    BorderLayout srb = new BorderLayout();
    GridLayout gridLayout1 = new GridLayout();
    prava.setLayout(gridLayout1);
    gridLayout1.setRows(10);
    gridLayout1.setVgap(20);
    gridLayout1.setHgap(20);
    kon.setLayout(srf);
    kon.setLayout(srb);
    Operace.addItem("Operace.....");
    Operace.addItem("Scitani");
    Operace.addItem("Odecitani");
    Operace.addItem("Nasobeni");
    Operace.addItem("Transponovani");
    Operace.addItem("Determinant");
    Operace.setBackground(Color.lightGray);
    Operace.addItemListener(this);
    exit.addActionListener(this);
    kon.add(prava,srb.EAST);
    kon.add(vrch,srb.NORTH);
    kon.add(stred,srb.CENTER);
    kon.add(dole,srb.SOUTH);
    prava.add(VytvorMatici);
    prava.add(Vypocet);
    prava.add(Operace);
    prava.add(exit);
    prava.add(help);

//rozmery matice A
    JLabel An = new JLabel("Matice A:  ");
    JLabel As = new JLabel("Sl.");
    vrch.add(An);
    vrch.add(As);
    vrch.add(Ast);
    JLabel Ar = new JLabel("Ra.");
    vrch.add(Ar);
    vrch.add(Art);

//rozmery matice B
    JLabel Bn = new JLabel("       Matice B:  ");
    JLabel Bs = new JLabel("Sl.");
    vrch.add(Bn);
    vrch.add(Bs);
    vrch.add(Bst);
    JLabel Br = new JLabel("Ra.");
    vrch.add(Br);
    vrch.add(Brt);


    gbl = new GridBagLayout();
    gbc = new GridBagConstraints();
    stred.setLayout(gbl);
    gbl2 = new GridBagLayout();
    gbc2 = new GridBagConstraints();
    dole.setLayout(gbl2);

//help
//------------------------------------------------------------------------------
    help.addActionListener(new ActionListener(){
      public void actionPerformed (ActionEvent event){
        JOptionPane.showMessageDialog(null,
        "      Maticova kalkulacka je program,ktery usnadnuje\n"+
        "reseni uloh s maticemi.Operace(scitani,odcitani,\n"+
        "nasobeni,transponovani,determinant) lze provadet\n"+
        "s maticemi do velikosti 5x5.\n"+
        "      Pri provadeni vypoctu s jednou matici je nutne zadat\n"+
        "velikost matice B !!! jako 0x0 !!!\n\n\n"+
        "Autor:   Lukas Stepan     stepal2@fel.cvut.cz\n\n"+
        "                      Maticova kalkulacka v1.1\n"+
        "                    Tento program je freeware.\n"+
        "                                   (C) 2006",
                                    "HELP", JOptionPane.INFORMATION_MESSAGE);
      }});


//vstup matic
//------------------------------------------------------------------------------
    VytvorMatici.addActionListener(new ActionListener(){
      public void actionPerformed (ActionEvent event){
        NulujGBL(stred);
        DejCislo();
        if(iA>0 && iA<6 && jA>0 && jA<6 && iB>=0 && iB<6 && jB>=0 && jB<6){
          VytvorNazev(0,2,"Matice A");
          MaticeA(iA,jA);
          if(iB!=0 || jB!=0){
            VytvorNazev(iA + 1, 2, "Matice B");
            MaticeB(iA, jA, iB, jB);
          }
          setVisible(true);
        }
        else{
        JOptionPane.showMessageDialog(null,"Chybne zadana hodnota,matice muze byt max 5x5",
                                    "ERROR", JOptionPane.ERROR_MESSAGE);
        }
      }});

    Vypocet.addActionListener(new ActionListener(){
      public void actionPerformed (ActionEvent event){

//plneni matice A
//------------------------------------------------------------------------------
        for(int i=0;i<iA;i++){
          for(int j=0;j<jA;j++){
            String t = MAs[i][j].getText();
            try {
              double x = Double.valueOf(t).doubleValue();
              MAi[i][j] = x;
            }
            catch (NumberFormatException e){
              JOptionPane.showMessageDialog(null,"Chybne zadana hodnota,musite"+
                                            " zadat cislo v prvku matice",
                                            "ERROR", JOptionPane.ERROR_MESSAGE);
              return;
            }
          }
        }

//plneni matice B
//------------------------------------------------------------------------------
        for(int i=0;i<iB;i++){
          for(int j=0;j<jB;j++){
            String t = MBs[i][j].getText();
            try {
              double x = Double.valueOf(t).doubleValue();
              MBi[i][j] = x;
            }
            catch (NumberFormatException e){
              JOptionPane.showMessageDialog(null,"Chybne zadana hodnota,musite"+
                                            " zadat cislo v prvku matice",
                                            "ERROR", JOptionPane.ERROR_MESSAGE);
              return;
            }
          }
        }

//operace s maticemi-switch
//------------------------------------------------------------------------------
        switch (volba){
          case 0:
            JOptionPane.showMessageDialog(null,"Vyberte operaci,kterou chcete s matici provest",
                                          "ERROR", JOptionPane.ERROR_MESSAGE);
            break;

      //soucet matic
          case 1:
            if(iA==iB && jA==jB){
              MCi = Scitani(MAi,MBi);
              MaticeC(MCi,iA,jA);
            }
            else{
              JOptionPane.showMessageDialog(null,"Pro soucet matic musi byt"+
                                            " Matice A i Matice B stejneho rozmeru",
                                            "ERROR", JOptionPane.ERROR_MESSAGE);
            }
            break;

      //rozdil matic
          case 2:
            if(iA==iB && jA==jB){
              MCi = Odecitani(MAi,MBi);
              MaticeC(MCi,iA,jA);
            }
            else{
              JOptionPane.showMessageDialog(null,"Pro rozdil matic musi byt"+
                                            " Matice A i Matice B stejneho rozmeru",
                                            "ERROR", JOptionPane.ERROR_MESSAGE);
            }
            break;

      //nasobeni matic
          case 3:
            if(jA==iB){
              MCi = Nasobeni(MAi,MBi);
              MaticeC(MCi,iB,jA);
            }
            else{
              JOptionPane.showMessageDialog(null,"Pro nasobeni matic se musi"+
                                            " sloupce v Matici A rovnat poctu radku v Matici B",
                                            "ERROR",JOptionPane.ERROR_MESSAGE);
            }
            break;

      //transponovani
            case 4:
              MCi = Transponovani(MAi,iA,jA);
              MaticeC(MCi,jA,iA);
              break;

      //determinant
            case 5:
              if(iA==jA){
                double determ = Determinant(MAi,iA);
                NulujGBL(dole);
                gbc2.insets = new Insets(5,5,5,5);
                String t = String.valueOf(determ).toString();
                Vysledek = new JLabel("Determinant Matice je:    "+t);
                gbc2.gridwidth = 1;
                gbl2.setConstraints(Vysledek,gbc2);
                dole.add(Vysledek);
                setVisible(true);
              }
              else{
                JOptionPane.showMessageDialog(null,"Pro vypocet determinantu"+
                                              " matice musi byt pocet radku roven poctu sloupcu",
                                              "ERROR", JOptionPane.ERROR_MESSAGE);
              }
              break;
          }
        }});
    setContentPane(kon);
  }

//scitani
//------------------------------------------------------------------------------
  public double[][] Scitani(double[][] MAi,double[][] MBi){
    for(int i=0;i<iA;i++){
      for(int j=0;j<jA;j++){
        MCi[i][j] = MAi[i][j]+MBi[i][j];
        //System.out.println(MCi[i][j]);
      }
    }
    return MCi;
  }

//odecitani
//------------------------------------------------------------------------------
  public double[][] Odecitani(double[][] MAi,double[][] MBi){
    for(int i=0;i<iA;i++){
      for(int j=0;j<jA;j++){
        MCi[i][j] = MAi[i][j]-MBi[i][j];
        //System.out.println(MCi[i][j]);
      }
    }
    return MCi;
  }

//nasobeni
//------------------------------------------------------------------------------
  public double[][] Nasobeni(double[][] MAi,double[][] MBi){
    for (int i=0;i<iA;i++)
      for (int j=0;j<jB;j++)
        MCi[i][j] = 0;
    for(int i=0;i<iA;i++){
      for(int j=0;j<jB;j++){
        MCi[i][j] = Pocitej(MAi,i,MBi,j);
        //System.out.println("prvek je: "+MCi[i][j]);
      }
    }
    return MCi;
  }

  public double Pocitej(double[][] MAi,int ra,double[][] MBi,int sl){
    double pom = 0;
    for(int i=0;i<MAi[ra].length;i++)
      pom +=MAi[ra][i]*MBi[i][sl];
    return pom;
  }

//transponovani
//------------------------------------------------------------------------------
  public double[][] Transponovani(double MAi[][],int iA,int jA){
    double[][] MCi = new double[jA][iA];
    for(int i=0;i<iA;i++){
      for(int j=0;j<jA;j++){
        MCi[j][i] = MAi[i][j];
      }
    }
    return MCi;
  }

//determinant
//------------------------------------------------------------------------------
  public double Determinant(double MAi[][],int N){
    // D registruje zmeny znamenka determinantu
    int k=0;
    double D = 1;
    double det=0;
    if(N==2)
      det=MAi[0][0]*MAi[1][1]-MAi[0][1]*MAi[1][0];
    else{
      // hlavni cyklus anuluje prvky pod hlavni diagonalou
      for (k=0; k<N; k++)
      {
        // vyber pivotniho prvku
        double pivot = MAi[k][k];
        int index = k;
        for (int i=k+1; i<N; i++)
          if (MAi[i][k] > pivot)
          {
            pivot = MAi[i][k];
            index = i;
          }
        double pom1=0;
        double pom2=0;
        int j=0;
        // vymena pivotniho radku znamena zmenu znamenka determinantu
        if (index != k)
        {
          D *= -1;
          for (j=k; j<N; j++)
            pom1 = MAi[index][j];
          pom2 = MAi[k][j];
          MAi[index][j] = pom2;
          MAi[k][j] = pom1;
        }

        // vynulovani sloupce pod pivotnim prvkem
        for (int i=k+1; i<N; i++)
        {
          double p = MAi[i][k]/MAi[k][k];
          MAi[i][k] = 0;
          for (j=k+1; j<N; j++)
            MAi[i][j] -= p*MAi[k][j];
        }
      }

      // soucin prvku na hlavni diagonale
      double S = 1;
      for (k=0; k<N; k++)
        S *= MAi[k][k];

      det = D*S;
      //det = Math.floor(det);
    }
    return det;
  }
  ;
//prevod vstupnich hodnot na cislo
//------------------------------------------------------------------------------
    void DejCislo(){
      String sA = Ast.getText();
      String rA = Art.getText();
      String sB = Bst.getText();
      String rB = Brt.getText();
      iA=0;jA=0;iB=0;jB=0;
      try {
        iA = Integer.valueOf(rA).intValue();
        jA = Integer.valueOf(sA).intValue();
        iB = Integer.valueOf(rB).intValue();
        jB = Integer.valueOf(sB).intValue();
      }
      catch (NumberFormatException e){
        JOptionPane.showMessageDialog(null,"Chybne zadana hodnota,musite zadat"+
                                      " cislo v parametrech matic",
                                      "ERROR", JOptionPane.ERROR_MESSAGE);
        return;
      }
    }

//velikost matice A
//------------------------------------------------------------------------------
    void MaticeA(int mA,int nA){
      gbc.insets = new Insets(5,5,5,5);
      int raA = 0;
      int slA = 0;
      for(int am=1;am<=mA;am++){
        gbc.gridy = am;
        for(int an=0;an<nA;an++){
          b = new JTextField(3);
          gbc.gridwidth = 1;
          gbl.setConstraints(b,gbc);
          stred.add(b);
          MAs[raA][slA] = b;
          slA++;
        }raA++;slA=0;}}

//velikost matice B
//------------------------------------------------------------------------------
    void MaticeB(int mA,int nA,int mB,int nB){
      int raB = 0;
      int slB = 0;
      for(int bm=mA+2;bm<=mA+mB+1;bm++){
        gbc.gridy = bm;
        for(int bn=0;bn<nB;bn++){
          b = new JTextField(3);
          gbc.gridwidth = 1;
          gbl.setConstraints(b,gbc);
          stred.add(b);
          MBs[raB][slB] = b;
          slB++;
        }raB++;slB=0;}}

//nazev Matice
//------------------------------------------------------------------------------
    void VytvorNazev(int x,int gridwith,String popis){
      gbc.gridy = x;
      JLabel b = new JLabel(popis);
      gbc.gridwidth = gridwith;
      gbl.setConstraints(b,gbc);
      stred.add(b);
    }

//zobrazeni vysledne Matice C
//------------------------------------------------------------------------------
    void MaticeC(double[][] MCi,int iA,int jA){
      NulujGBL(dole);
      gbc2.insets = new Insets(5,5,5,5);
      gbc2.gridy = 0;
      gbc2.gridwidth = 4;
      Vysledek = new JLabel("Vysledna matice je: ");
      gbl2.setConstraints(Vysledek,gbc2);
      dole.add(Vysledek);
      for(int cm=1;cm<=iA;cm++){
        gbc2.gridy = cm;
        for(int cn=0;cn<jA;cn++){
          String t = String.valueOf(MCi[cm-1][cn]).toString();
          Vysledek = new JLabel(t);
          gbc2.gridwidth = 1;
          gbl2.setConstraints(Vysledek,gbc2);
          dole.add(Vysledek);
        }
      }
      setVisible(true);
    }

//premazani GridBagLayout
//------------------------------------------------------------------------------
    void NulujGBL(Panel x){
      x.removeAll();
      x.repaint();
    }

//ukonceni programu
//------------------------------------------------------------------------------
     public void actionPerformed(ActionEvent e) {
       System.exit(0);
    }

//vyber operace s maticemi-switch
//------------------------------------------------------------------------------
    public void itemStateChanged(ItemEvent e) {
      //String s = new String(Operace.getSelectedItem());
      String s = (String) Operace.getSelectedItem();
      if (s.compareTo("Operace") == 0)
        volba = 0;
      if (s.compareTo("Scitani") == 0)
        volba = 1;
      if (s.compareTo("Odecitani") == 0)
        volba = 2;
      if (s.compareTo("Nasobeni") == 0)
        volba = 3;
      if (s.compareTo("Transponovani") == 0)
        volba = 4;
      if (s.compareTo("Determinant") == 0)
        volba = 5;
  }
}


//hlavni metoda
//------------------------------------------------------------------------------
class MaticovaKalkulacka {
  public static void main(String[] args) {
    new Okno1();
  }
}