HueckelWindow

// HueckelWindow.java

import java.awt.*;

public class HueckelWindow extends Frame
{
   Panel dispArea;
   Panel controls;
   Panel matPanel;

   TextField[][] H;
   Matrix inMat, vecMat, eigMat, eigSM;
   MatrixJama hMat, E, V;
   int[][] znum, spnum;                    // Zeilen-Nummerierung, Spalten-Nummerierung
   double[][] eigVec, eigW, eigSpalte, inArr;
   double acc = 0.01;                   // Zahlenformat
   MatrixInt spNumH, spNumV, zNumH, zNumV;
   Label hLab, vLab, eLab;

   Button go;

   GridBagLayout gbl, ingbl, dgbl;
   GridBagConstraints cc, incc, dcc;

   int size;

   Color colBlau, colRot;

   public HueckelWindow(int s)
   {
     super("Hückel-Verfahren");
     size = s;
   }

   public void init()
   {
     znum = new int[size][1];                // für Darstellung der Zeilen-Nummerierung
     for (int i = 0; i < size; i++)
     {
       znum[i][0] = i + 1;
     }

     spnum = new int[1][size];                 // Bestimmung der Anzahl der Spalten
     for (int i = 0; i < size; i++)
     {
       spnum[0][i] = i + 1;
     }

     go = new Button("Go");

     if (size == 4)
     {
       H = new TextField[4][4];
       H[0][0] = new TextField("0", 3);
       H[0][1] = new TextField("-1", 3);
       H[0][2] = new TextField("0", 3);
       H[0][3] = new TextField("0", 3);
       H[1][0] = new TextField("-1", 3);
       H[1][1] = new TextField("0", 3);
       H[1][2] = new TextField("-1", 3);
       H[1][3] = new TextField("0", 3);
       H[2][0] = new TextField("0", 3);
       H[2][1] = new TextField("-1", 3);
       H[2][2] = new TextField("0", 3);
       H[2][3] = new TextField("-1", 3);
       H[3][0] = new TextField("0", 3);
       H[3][1] = new TextField("0", 3);
       H[3][2] = new TextField("-1", 3);
       H[3][3] = new TextField("0", 3);
     }
     else
     {
       H = new TextField[size][size];
       for (int i = 0; i < size; i++)
       {
         for (int j = 0; j < size; j++)
         {
           H[i][j] = new TextField("0", 3);
         }
       }
     }

     hLab = new Label("H");
     hLab.setAlignment(Label.RIGHT);
     vLab = new Label("V");
     vLab.setAlignment(Label.RIGHT);
     eLab = new Label("E");
     eLab.setAlignment(Label.CENTER);

     colBlau = new Color(0, 0, 255);
     colRot = new Color(255, 0, 0);
     zNumH = new MatrixInt(znum);       // Zeilen-Nummerierung der Hückelmatrix
     zNumH.setColor(colBlau);
     zNumV = new MatrixInt(znum);
     zNumV.setColor(colBlau);
     spNumH = new MatrixInt(spnum);
     spNumH.setColor(colBlau);
     spNumV = new MatrixInt(spnum);
     spNumV.setColor(colBlau);

     dispArea = new Panel();      // Display-Bereich für die Matrizen
     controls = new Panel();
     matPanel = new Panel();
     setLayout(new BorderLayout(5, 5));

     add("South", controls);
     add("Center", dispArea);

     ingbl = new GridBagLayout();        // für Hückelmatrix (in für Input)
     incc = new GridBagConstraints();

     matPanel.setLayout(ingbl);        // GridBags für die einzelnen Matrixelemente
     for (int r = 0; r < size; r++)
     {
       for (int c = 0; c < size; c++)
       {
         incc.gridx = c;
         incc.gridy = r;
         ingbl.setConstraints(H[r][c], incc);
         matPanel.add(H[r][c]);
       }
     }

     // Label "H" = Hückelmatrix wird plaziert
     dgbl = new GridBagLayout();
     dcc = new GridBagConstraints();
     dispArea.setLayout(dgbl);
     dcc.fill = GridBagConstraints.BOTH;
     dcc.gridx = 2;
     dcc.gridy = 0;
     dcc.gridwidth = 1;
     dcc.gridheight = 1;
     dgbl.setConstraints(hLab, dcc);
     dispArea.add(hLab);

     // Zeilen-Nummerierung der Hückelmatrix
     dcc.gridx = 2;
     dcc.gridy = 2;
     dcc.gridwidth = 1;
     dcc.gridheight = size;
     dgbl.setConstraints(zNumH, dcc);
     dispArea.add(zNumH);

     // Spalten-Nummerierung der Hückelmatrix
     dcc.gridx = 3;
     dcc.gridy = 1;
     dcc.gridwidth = size;
     dcc.gridheight = 1;
     dgbl.setConstraints(spNumH, dcc);
     dispArea.add(spNumH);

     // Display Hückel-Matrix
     dcc.gridx = 3;
     dcc.gridy = 2;
     dcc.gridwidth = size;
     dcc.gridheight = size;
     dgbl.setConstraints(matPanel, dcc);
     dispArea.add(matPanel);

     inMat = new Matrix(H);             // Input-Labelmatrix;

     inArr = inMat.toDoubleArray();

     hMat = new MatrixJama(inArr);     // JamaMatrix der Inputmatrix
     EigenvalueDecomposition eig = hMat.eig();   // Eigenwert-Bestimmung
     E = eig.getD();                            // Eigenwert-JamaMatrix
     eigW = E.getArray();                        // 2D-Array von Doubles der Eigenwerte
     eigMat = new Matrix(eigW);                  // Eigenwert-Labelmatrix

     System.out.println(" Eigenwerte: ");        // Konsolen-Ausgabe
     E.print(5, 3);

     V = eig.getV();                                // Eigenvektor-JamaMatrix
     System.out.println(" Eigenvektor-Matrix: ");   // Konsolen-Ausgabe
     V.print(5, 3);
     eigVec = V.getArray();                         // 2D-Array von Doubles der Eigenvektoren
     vecMat = new Matrix(eigVec);                   // Eigenvektor-Labelmatrix

     // Label "V" = Eigenvektor-Matrix
     dcc.gridx = 2;
     dcc.gridy = 6 + size;
     dcc.gridwidth = 1;
     dcc.gridheight = 1;
     dgbl.setConstraints(vLab, dcc);
     dispArea.add(vLab);

     // Zeilen-Nummerierung der Eigenvektor-Matrix
     dcc.gridx = 2;
     dcc.gridy = 7 + size;
     dcc.gridwidth = 1;
     dcc.gridheight = size;
     dgbl.setConstraints(zNumV, dcc);
     dispArea.add(zNumV);

     // Spalten-Nummerierung der Vektormatrix
     dcc.gridx = 3;
     dcc.gridy = 6 + size;
     dcc.gridwidth = 1;
     dcc.gridheight = 1;
     dgbl.setConstraints(spNumV, dcc);
     dispArea.add(spNumV);

     // Display Vektormatrix
     dcc.gridx = 3;
     dcc.gridy = 7 + size;
     dcc.gridwidth = 1;
     dcc.gridheight = size;

     vecMat.roundD(acc);
     dgbl.setConstraints(vecMat, dcc);
     dispArea.add(vecMat);

     // Label "E" = Eigenwerte
     dcc.gridx = 3 + size;
     dcc.gridy = 5 + size;
     dcc.gridwidth = 1;
     dcc.gridheight = 1;
     dgbl.setConstraints(eLab, dcc);
     dispArea.add(eLab);

     // Eigenwert-Spalte
     eigSpalte = new double[size][1];
     for (int i = 0; i < size; i++)
     {
       eigSpalte[i][0] = eigW[i][i];
     }

     eigSM = new Matrix(eigSpalte);
     eigSM.setColor(colRot);
     eigSM.roundD(acc);
     dcc.gridx = 3 + size;
     dcc.gridy = 7 + size;
     dcc.gridwidth = 1;
     dcc.gridheight = size;
     dgbl.setConstraints(eigSM, dcc);
     dispArea.add(eigSM);

     // Control-Panel
     gbl = new GridBagLayout();
     controls.setLayout(gbl);

     cc = new GridBagConstraints();

     cc.gridx = 0;
     cc.gridy = 0;
     cc.gridwidth = 2;
     gbl.setConstraints(go, cc);
     controls.add(go);

     validate();
   }

   // Handle events
   public boolean handleEvent(Event evt)
   {
     String minStr, maxStr;
     if (evt.target instanceof Button)
     {
       if (evt.target == go && evt.id == Event.ACTION_EVENT) // When button is clicked
       {
         simulate();
         return true;
       }
     }
     if (evt.id == Event.WINDOW_DESTROY)
     {
       hide();
       dispose();
     }
     return super.handleEvent(evt); // Handle other events as usual
   }

// nach Button go +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

   public void simulate()
   {
     dispArea.remove(vecMat);
     dispArea.remove(eigSM);

     inMat = new Matrix(H);
     inArr = inMat.toDoubleArray();

     hMat = new MatrixJama(inArr); // JamaMatrix der Inputmatrix

     EigenvalueDecomposition eig = hMat.eig(); // Eigenwert-Bestimmung
     E = eig.getD(); // Eigenwert-JamaMatrix
     eigW = E.getArray(); // 2D-Array von Doubles der Eigenwerte
     eigMat = new Matrix(eigW); // Eigenwert-Matrix

     System.out.println(" Eigenwerte: ");
     E.print(5, 3);

     V = eig.getV(); // Eigenvektor-JamaMatrix
     System.out.println(" Eigenvektor-Matrix: ");
     V.print(5, 3);
     eigVec = V.getArray(); // 2D-Array von Doubles der Eigenvektoren
     vecMat = new Matrix(eigVec); // Eigenvektor-Matrix

     // Display Vektormatrix
     dcc.gridx = 3;
     dcc.gridy = 7 + size;
     dcc.gridwidth = 1;
     dcc.gridheight = size;
     vecMat.roundD(acc);
     dgbl.setConstraints(vecMat, dcc);
     dispArea.add(vecMat);

     // Display Eigenwerte als Spalte
     eigSpalte = new double[size][1];
     for (int i = 0; i < size; i++)
     {
       eigSpalte[i][0] = eigW[i][i];
     }

     eigSM = new Matrix(eigSpalte);
     eigSM.setColor(colRot);
     eigSM.roundD(acc);
     dcc.gridx = 3 + size;
     dcc.gridy = 7 + size;
     dcc.gridwidth = 1;
     dcc.gridheight = size;
     dgbl.setConstraints(eigSM, dcc);
     dispArea.add(eigSM);

     validate();
   }
}