Methoden Gauß-Jordan-Algorithmus Aufgabe

vico

Neues Mitglied
Hallo Zusammen,

wir haben im Rahmen eines Übungsblattes folgende Aufgabe bekommen:

a) (1P) Schreibe eine Methode void swap(double[][] a, int i, int j), die zwei Elemente in
einem zweidimenionalen double-Array vertauscht, wobei die Elemente selbst wiederrum doubleArrays sind. Es handelt sich also um die Vertauschung zweier Zeilen einer Matrix.
b) (2P) Schreibe eine Methode void divide(double[] a, double divisor), die jedes Element
des übergebenen double-Arrays durch den übergebenen Double-Wert divisor teilt.
c) (2P) Schreibe äquivalent dazu eine weitere Methode double[] multiply(double[] a, double
factor), die jedes Element eines double-Arrays mit dem übergebenen double-Wert factor multipliziert. Im Gegensatz zu divide() soll diese Methoden ein neues double-Array liefern!
d) (2P) Schreibe eine Methode double[] subtract(double[] a, double[] b), die von den Elementen aus dem double-Array a die entsprechenden Elemente aus dem double-Array b abzieht
und ein neues double-Array mit den Ergebnissen zurückliefert (d.h. result = a - b).
Die übergebenen double-Arrays müssen dabei die gleiche Länge besitzen.
1
Innerbetriebliche Leistungsverrechnung
2
Gleichungsverfahren - Verfahren innerbetrieblicher Leistungsverrechnung
Aufgabe 1: Zweidimensionale Arrays
e) (4P) Schreibe eine Methode double[] gaussJordan(double[][] a), welche die Lösungen zu
einem übergebenen LGS mit Hilfe des Gauss-Jordan-Algorihtmus
3
bestimmt. Das LGS wird dabei
als zweidimsionales double-Array übergeben und besitzt bereits die Form:
0
B
@
a
00
a

Das zurückgelieferte double-Array soll die Ergebnisse für die einzelnen Parameter in folgender Form
enthalten: result = fx

g. Besitzt das LGS keine oder unendlich viele Lösungen, so soll das
Ergebnis-Array lediglich ein Element mit dem Wert Double.NaN enthalten.
Für die Implementierung des Gauss-Jordan-Algorithmus sind die Methoden aus den vorherigen Teilaufgaben zu verwenden.
f) (1P) Die folgende Tballe beschreibt den innerbetrieblichen Leistungsaustausch zwischen verschiedenen Kostenstellen einer Firma.
Primäre empfangene empfangene empfangene Summe
Stellenkosten Leistungen Leistungen Leistungen abgegebener
Kraftwerk IT-Abteilung Service Leistungen

Kraftwerk 480.000 EUR - 11.000 Stk. 25.000 h 5.000.000 kW/h
IT-Abteilung 1.200.000 EUR 600.000 kW/h - 3000h 67.800 Stk.
Service 562.000 EUR 50.000 kW/h 200 Stk. - 48.000 h

Leite mittels des Gleichungsverfahrens das entsprechende LGS her um die Verrechnungspreise der
einzelnen Kostenstellen zu berechnen. Bringe es anschließend in die Form, welche in Teilaufgabe e)
angegeben ist und schreibe ein Hauptprogramm (main-Methode), welches mit Hilfe der Methode
gaussJordan die Lösung des LGS bestimmt und anschließend ausgibt


Bisher haben wir folgenden Lösungsansatz:

Java:
package ass07;
import java.util.Scanner;
public class Ass07 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner ass07 = new Scanner(System.in);}
    
    //Vertausche i und k
            //Vorbedingung:  A[i][q]==A[j][q]==0 for 1<=q<j
             void swap (double[][]a, int i, int j){
                  int m = a[0].length - 1;
                  double temp;
                  for(int q=j; q<=m; q++){
                     temp = a[i][q];
                     a[i][q] = a[j][q];
                     a[j][q] = temp;
            
            
                  }}
            // Vorbedingung: A[i][j]!=0, A[i][q]==0 for 1<=q<j
               // post: A[i][j]==1;
             void divide(double[][] A, int i, int j){
                  int m = A[0].length - 1;
                  for(int q=j+1; q<=m; q++) A[i][q] /= A[i][j];
                  A[i][j] = 1;
             
             
        }
             // Multipliziere mit Faktor a
             //Vorbedingung: A[i][j]!=0, A[i][q]==0 for 1<=q<j
             double[] multiply(double[] a, double
                     factor){     
                 Scanner ass07 = new Scanner(System.in);
             System.out.println("Bennen Sie den Faktor: ");
                 factor = ass07.nextInt();
                 int m = A[0].length - 1;
                  double [][] b = factor * m; }
             
             
             // Abziehen Faktor a von b
             // Vorbedingung: 
             
            
                
    
    }
    
    
}
public static void main(String[] args) throws IOException {
    int n, m, i, j, k;
    String line;
    StringTokenizer st;

    // check command line arguments, open input and output files
    if( args.length!=2 ){
       System.out.println("Usage: GaussJordan infile outfile");
       System.exit(1);
    }
    BufferedReader in = new BufferedReader(new FileReader(args[0]));
    PrintWriter out = new PrintWriter(new FileWriter(args[1]));

    // read first line of input file
    line = in.readLine();
    st = new StringTokenizer(line);
    n = Integer.parseInt(st.nextToken());
    m = Integer.parseInt(st.nextToken());

    // declare A to be of size (n+1)x(m+1) and do not use index 0
    double[][] A = new double[n+1][m+1];

    // read next n lines of input file and initialize array A
    for(i=1; i<=n; i++){
       line = in.readLine();
       st = new StringTokenizer(line);
       for(j=1; j<=m; j++){
          A[i][j] = Double.parseDouble(st.nextToken());
       }
    }

    // close input file
    in.close();

    // print array A to output file
    printMatrix(out, A);

    // perform Gauss-Jordan Elimination algorithm
    i = 1;
    j = 1;
    while( i<=n && j<=m ){

       //look for a non-zero entry in col j at or below row i
       k = i;
       while( k<=n && A[k][j]==0 ) k++;

       // if such an entry is found at row k
       if( k<=n ){

          //  if k is not i, then swap row i with row k
          if( k!=i ) {
             swap(A, i, k, j);
             printMatrix(out, A);
          }

          // if A[i][j] is not 1, then divide row i by A[i][j]
          if( A[i][j]!=1 ){
             divide(A, i, j);
             printMatrix(out, A);
          }

          // eliminate all other non-zero entries from col j by subtracting from each
          // row (other than i) an appropriate multiple of row i
          multiply(A, i, j);
          printMatrix(out, A);
          i++;
       }
       j++;
    }

    // print rank to output file
    out.println("rank = " + (i-1));

    // close output file
    out.close();
 }

}

}



HILFE!!! Kann uns jemand weiterhelfen??

Dankeschön :)
 
Zuletzt bearbeitet von einem Moderator:

Flown

Administrator
Mitarbeiter
Kommt das richtige bei den Berechnungen raus?

Ich kann euch jetzt schon mal sagen, dass das was du/ihr fabriziert habt, eher nicht richtig ist laut eurer Aufgabenstellung.

Euer Beispielcode ist syntaktisch nicht einmal richtig, wenn man ihn kopiert. So wird sich das keiner Ansehen in diesem Zustand! Also ein KSKB basteln und dann sehen wir weiter!
 

Neue Themen


Oben