Matrix.java

/*
 *     YAV (Yet another Visualiser)
 *     (c) 2004 by Robin Quast
 *    Version 1.0 (04.03.2004)
 *    
 *  erstellt im Rahmen der Diplomarbeit
 * "Theorie und Java- Realisierung
 *  ausgewählter Algorithmen zur
 *  Bestimmung kürzester Wege in Graphen"
 *
 *  betreut durch Prof. Dr. Lenze
 *  an der Fachhochschule Dortmund
 *  im SS 2003/ WS 2003/2004
 *
 *  @(#)Matrix.java  1.0 04/03/09
 */
import java.*;
import java.util.Vector;
import java.util.Enumeration;
import java.io.*;

/** Diese Klasse dient zur Darstellung MxN Matrizen mit Integer Objekten als
 * Inhalt in den einzelnen Zellen. 
 */

public class Matrix {
  /** Die Matrix wird in einem Array von Objekten verwaltet.
   */
  Object[][] matrix;  
  /** Anzahl der Spalten
   */
  int columns=0;
  /** Anzahl der Zeilen
   */
  int rows=0;
  
  // zeilen=x, column=y, also kante (1->2) => (1,2) also zeile 1 und spalte 2
  /** Konstruktor mit dem eine 0x0 Matrix erzeugt wird
   */
  public Matrix() {
    columns=0;
    rows=0;
    matrix = new Object[rows][columns];
  }
  
  /** Konstruktor mit dem eine rxc Matrix erzeugt wird. Die Inhalte der Matrix sind 
   * undefiniert. Zum Initialisieren der Matrix sollte die Methode init verwendet werden.
   */  
  public Matrix(int r,int c) {
    matrix = new Object[r][c];
    columns=c;
    rows=r;
  }
  
  /** Initialisiert die Matrixelemente mit dem vorgegebenen Wert.
   */
  public void init(int v) {
    for (int i=0;i<getRows();i++) {
      for (int j=0;j<getColumns();j++) {
        setValue(i,j,v);
      }
    }
  }
  
  /** Setzt den Wert v an der Stelle (x,y).
   */
  public boolean setValue(int x, int y,int v) {
    boolean rc=false;
    if ((x<rows&& (y<columns)) {
      matrix[x][y]=new Integer(v);
      rc=true;
    }
    
    return rc;    
  }
  
  /** Liefert den Wert an der Stelle (x,y). Falls diese Stelle existiert.
   * Existiert die Stelle nciht wird Integer.MAX_VALUE zur&uuml;ckgegeben.
   */
  public int getValue(int x,int y) {
    int rc=Integer.MAX_VALUE;
    
    if ((x<rows&& (x>=0&& (y>=0)) {
      if (y<matrix[x].length) {
        rc=((Integer)matrix[x][y]).intValue();
      }
    
    return rc;
  }
  
  /** &auml;ndert die Dimension der Matrix. Wird die Matrix verkleinert, dann 
   * werden die Werte, die ausserhalb der Dimension liegen verworfen.
   */
  public void setDimension(int r,int c) {
    Object [][] tmp_m= new Object [r][c];
    for (int i=0;i<Math.min(r,getRows());i++) {
      for (int j=0;j<Math.min(c,getColumns());j++) {
        tmp_m[i][j]=matrix[i][j];
      }
    }
    matrix=tmp_m;
    columns=c;
    rows=r;
  }
  
  /** Wandelt die Matrix in einen String um. Beispielausgabe:<Br>
   * [0 1 2 3]<br>
   * [0 0 0 4]<br>
   * [1 2 2 3]<br>
   */
  public String toString() {
    String rc="";
    for (int i=0;i<rows;i++) {
      rc+=toString(i);
    }
    return rc;
  }

  /** Wandelt die Zeile i in einen String um. Beispiel <br>
   * [0 1 2 3]<br>
   */
  public String toString(int index) {
    String rc="[ ";
    for (int j=0;j<columns;j++) {
      rc+=matrix[index][j];
      if (j<matrix[index].length-1rc+=",";
      rc+=" ";
    }
    rc+="]\n";  
    return rc;
  }

  /** Gibt die Anzahl der Zeilen zur&auml;ck.
   */
  public int getRows() {
    return rows;
  }
  
  /** Gibt die Anzahl der Spalten zur&auml;ck.
   */
  public int getColumns() {
    return columns;
  }

  /** Gibt die Referenz auf die Matrix zur&uuml;ck.
   */
  public Object[][] getMatrix() {
    return matrix;
  }

  /** Testen der Funktionen.
   */
  public static void main(String[] args) {
    System.out.println("Testfunktionen der Klasse Matrix");
    Matrix m=new Matrix();
    m.setDimension(3,3);
    m.setValue(2,2,7);
    m.setValue(0,1,2);
    System.out.println("m.toString()\n"+m);
  }
}