myGully.com - Java - Matrix Potenzieren

myGully.com (https://mygully.com/index.php)

- Programmierung (https://mygully.com/forumdisplay.php?f=67)

- - Java - Matrix Potenzieren (https://mygully.com/showthread.php?t=2756551)

Java - Matrix Potenzieren

Hi ich soll Eine gegebene Matrix 15 mal potenzieren.
M^1=M // M^2 = M*M^1 // M^3 = M*M^2 // M^4=M*M^3..... M^15=M*M^14.

Die kodierung für die Multiplikation hab ich schon nur ich komm einfach nich drauf wie ich die 4x4 Matrix 15 mal in der kodierung potenzieren und ausgeben soll. Ich hab grad erst angefangen mit java und hab noch einige Lücken.

Hier noch die Matrix die gegeben ist : 0 1 0 0
0 0 1 0
0 0 0 1
-1 1 -1 3

Code:

import java.util.Scanner;

 

class MatrixPotenz {



   public static void main(String args[]) {

   

      int m, n, p, q, sum = 0, c, d, k;

 

      // Eingabe der Zeilen und Spalten der ersten Matrix

          Scanner in = new Scanner(System.in);

      System.out.println("Geben Sie Bitte die Anzahl der Zeilen und Spalten der ersten Matrix ein");

      m = in.nextInt();

      n = in.nextInt();

 

      int first[][] = new int[m][n];

 

      // Erste Matrix

          System.out.println("Geben Sie die Elemente der ersten Matrix ein");

 

      for ( c = 0 ; c < m ; c++ )

         for ( d = 0 ; d < n ; d++ )

            first[c][d] = in.nextInt();

 

          // Eingabe der Zeilen und Spalten der zweiten Matrix

      System.out.println("Geben Sie die Anzahl der Zeilen und Spalten der zweiten Matrix ein,");

      p = in.nextInt();

      q = in.nextInt();

        

          // Falls die Berechnung unter umständen nicht möglich sein sollte, Meldung !

      if ( n != p )

         System.out.println("Matrizen mit eingegebenen Zahlen können nicht miteinander multipliziert werden.");

      else

                { 

                         int second[][] = new int[p][q];

                         int multiply[][] = new int[m][q];

                                

                        // Erbeute Eingabe falls es nicht Möglich sein sollte / Berechnung im Anschluss

                         System.out.println("Geben Sie die Elemente der zweiten Matrix ein");

         

                        for ( c = 0 ; c < p ; c++ )

                                for ( d = 0 ; d < q ; d++ )

                                   second[c][d] = in.nextInt();

         

                        for ( c = 0 ; c < m ; c++ )

                        {

                                for ( d = 0 ; d < q ; d++ )

                                {   

                                   for ( k = 0 ; k < p ; k++ )

                                   {

                                          sum = sum + first[c][k]*second[k][d];

                                   }

         

                                   multiply[c][d] = sum;

                                   sum = 0;

                                   Math.pow(1,2);

                                }

                        }

                

                        // Ausgabe der Endmatrix

                         System.out.println("Produkt der eingegebenen Matrizen:");

         

                        for ( c = 0 ; c < m ; c++ )

                        {

                                for ( d = 0 ; d < q ; d++ )

                                   System.out.print(multiply[c][d]+"\t");

         

                                System.out.print("\n");

                        }

                }

                  

   }

}

Dann beantworte mal folgende Fragen:
1. Hängt es bei dir am Mathematischen oder nur an Java?
2. Dürft ihr auch etwas fertiges nehmen, oder sollt ihr das selbst programmieren?
3. Sicher, dass die 15 mal potenziert werden soll? Da kommen richtig große Zahlen raus.

1. Ja es liegt an java ich weiß einfach nciht wo ich das ganze anpacken soll, ich soll ne eingabe aufforderung erstellen und dann das eingegebene 15 mal potenzieren ... ka wie ich da hinbekommen soll:cry:

2.Ja wir dürfen au schon fertige Vorlagen nehmen :T

3.und ja sicher soll ganze 15 mal potenziert werden :(

Hi nick01987,

ich habe das eben mal programmiert, ist wirklich nicht schwer.
Allerdings bin ich mir bei einer Sache nicht ganz klar:

Sollest du die gegebene Matrix m 15 mal mit sich selber multiplizieren ( was m^15 entspräche ) oder sollst du die Matrix 15 mal quadrieren ( das entspräche ( ( ( (m^2)^2)^2)...) = m^32768 ) ?

Der genau Wortlaut der Aufgabe lautet : Anschließend sollen die ersten 15 Potenzen von M, also M1=M, M2=M×M1, M3=M×M2, ..., M15 jeweils berechnet und ausgegeben werden.

Ich habs so verstanden das ichs 15 mal mit sich selbst machen muss, also denk ich schon. Bis morgen Abend muss ich das abgeben und das ist die letzete AUfgabe von 4 :(

Sobald du eine Matrix mit einer anderen Matrix (bzw. sich selbst) multiplizieren kannst, hast du ja schon die Lösung für dein Problem ... danach musst du nur noch eine Zählschleife (for) machen und das ganze 15 mal durchlaufen lassen.

Code:

Matrix inputMatrix; // wobei inputMatrix ein Matrix-Object darstellt, wo bereits die eingegebene Matrix drin steht

calcMatrix = inputMatix; // wobei du da wirklich Kopieren musst ... nicht so einfach in Java -.-

for(int i = 0; i < 15; i++) {

calcMatrix = inputMatrix.mult(calcMatrix ); // mult(Matrix) stellt eine Methode dar, welche ein Matrix-Object mit einem anderen multipliziert

}

und wie implementier ich das ganze jez in meinen Code, steh grad ein weng aufm schlauch ?

Wenn fertige Lösungen verwendet werden dürfen, dann kannst ja z.B. zu [Link nur für registrierte und freigeschaltete Mitglieder sichtbar. Jetzt registrieren...] greifen ... (echt traurig dass Java, bei einer so großen (fast schon überladenen) standard Library nicht mal eine Klasse für Matrizen anbietet ...)

wenns in c++ sein darf, könnte ich dir weiterhelfen. hab da mal um den umgang mit dynamischem speicher zu üben ne klasse für quadratische matrizen geschrieben und einfach den multiplikationsoperator überladen.

hmm leider nich, ich würd das schon gern in meine Programmierung übernehmen ... ^^

Ich denke nicht, dass es dir viel bringt, wenn ich dir einfach meinen Code hier poste.
Falls du ihn haben willst, kannst du es ruhig sagen!

Im Endeffekt hast du zwei Möglichkeiten zur Implementierung:
1. Alles in ein paar Methoden
2. Mit Klassen

Da letzteres OOP wäre, würde ich das bevorzugen, da du aber sagst, dass du Anfänger seist,
habe ich das ganze mal nur mit Methoden implementiert.

Ich beschreibe dir einfach mal, was mein Algorithmus macht:

Er bekommt eine Matrix als Eingabe.
Dann erstellt er eine weitere (leere, also mit Nullen, Ergebnismatrix) und eine Kopie der Eingangsmatrix.

Es folgen vier Schleifen, die jeweils ineinander liegen.

Die äußere ist die Anzahl der Potenzen, zählt also einfach hoch.
Die zweite Schleife „geht“ die Matrix ( welche ist egal, da ja alle gleich groß sind ) zeilenweise durch. Die dritte Schleife geht spaltenweise, die vierte wieder Zeilenweise durch. Vor der letzten Schleife wird die aktuelle Zelle der Ergebnismatrix auf Null gesetzt, in der vierten Schleife findet dann die Aufsummierung statt. Dabei werden alle drei Matrizen genutzt.

Es wird wieder in die erste Schleife gesprungen, sobald die Matrix komplett addiert wurde.
Dort wird von der Ergebnismatrix eine Kopie erstellt und der „Kopiematrix“ zugewiesen, dann erfolgt die Ausgabe.

Der Teil mit den Schleifen ist das wichtigste und schwierigste, es war in meinem Kopf und es ist richtig, ich habe es mit einem Taschenrechner nachgerechnet. :D

Die Ausgabe meines Programms habe ich mal angehängt.

Code:

2. Potzenz:

            0             0             1             0 

            0             0             0             1 

           -1             1            -1             3 

           -3             2            -2             8 

3. Potzenz:

            0             0             0             1 

           -1             1            -1             3 

           -3             2            -2             8 

           -8             5            -6            22 

4. Potzenz:

           -1             1            -1             3 

           -3             2            -2             8 

           -8             5            -6            22 

          -22            14           -17            60 

5. Potzenz:

           -3             2            -2             8 

           -8             5            -6            22 

          -22            14           -17            60 

          -60            38           -46           163 

6. Potzenz:

           -8             5            -6            22 

          -22            14           -17            60 

          -60            38           -46           163 

         -163           103          -125           443 

7. Potzenz:

          -22            14           -17            60 

          -60            38           -46           163 

         -163           103          -125           443 

         -443           280          -340          1204 

8. Potzenz:

          -60            38           -46           163 

         -163           103          -125           443 

         -443           280          -340          1204 

        -1204           761          -924          3272 

9. Potzenz:

         -163           103          -125           443 

         -443           280          -340          1204 

        -1204           761          -924          3272 

        -3272          2068         -2511          8892 

10. Potzenz:

         -443           280          -340          1204 

        -1204           761          -924          3272 

        -3272          2068         -2511          8892 

        -8892          5620         -6824         24165 

11. Potzenz:

        -1204           761          -924          3272 

        -3272          2068         -2511          8892 

        -8892          5620         -6824         24165 

       -24165         15273        -18545         65671 

12. Potzenz:

        -3272          2068         -2511          8892 

        -8892          5620         -6824         24165 

       -24165         15273        -18545         65671 

       -65671         41506        -50398        178468 

13. Potzenz:

        -8892          5620         -6824         24165 

       -24165         15273        -18545         65671 

       -65671         41506        -50398        178468 

      -178468        112797       -136962        485006 

14. Potzenz:

       -24165         15273        -18545         65671 

       -65671         41506        -50398        178468 

      -178468        112797       -136962        485006 

      -485006        306538       -372209       1318056 

15. Potzenz:

       -65671         41506        -50398        178468 

      -178468        112797       -136962        485006 

      -485006        306538       -372209       1318056 

     -1318056        833050      -1011518       3581959

--

Wie gesagt: Wenn du den Source möchtest, kann ich ihn gerne posten.

poste ihn bitte, mittlerweile bin ich etwas in zeitdruck und arbeite parallel noch an anderen kleinen Progs die Prüfungsrelevant sind, danke dir jez schon mal :)

Hi nick,

hoffentlich ist es noch nicht zu spät ;D

Code:

package lab.matrixopotenz;



public class MatrixPotenzieren

{



        public static void main(String[] args)

        {

                int[][] input = { { 0, 1, 0, 0 },

                                                  { 0, 0, 1, 0 },

                                                  { 0, 0, 0, 1 },

                                                  {-1, 1,-1, 3 } };

                

                int[][] matrix = MatrixPotenzieren.deepcopy(input);

                

                int[][] result = new int[matrix.length][matrix.length];

                

                

                for( int n = 1; n < 15; n++ )

                {

                        for( int i = 0; i < input.length; i++ )

                                for( int j = 0; j < input.length; j++ )

                                {

                                        result[i][j] = 0;

                                        for( int k = 0; k < input.length; k++ )

                                                result[i][j] += matrix[i][k]*input[k][j];

                                }

                        

                        matrix = MatrixPotenzieren.deepcopy(result);

                        

                        System.out.printf("%d. Potzenz:\n",n+1);

                        MatrixPotenzieren.printM(result);

                }

                

                



        }

        

        public static int[][] deepcopy( int[][] matrix )

        {

                int[][] copy = new int[matrix.length][matrix.length];

                for( int i = 0; i < matrix.length; i++ )

                        for( int j = 0; j < matrix.length; j++ )

                                copy[i][j] = matrix[i][j];

                

                return copy;

        }

        

        public static void printM( int[][] matrix )

        {

                for( int i = 0; i < matrix.length; i++ )

                {

                        for( int j = 0; j < matrix[i].length; j++ )

                                System.out.printf("%13d ",matrix[i][j]);

                        

                        System.out.println();

                }

        }



}

ein großes Danke an dich und die anderen die geholfen haben, dass hat mir eine Menge Zeit erspaart, hab jez wieder ein weng Luft :T