Matrix-Vektor-Multiplikation

[Puppilein]

Hallo!
Kann mir vllt jemand sagen welchen Quellcode man für einen Matrix-Vektors-Multiplikation benutzt?
Habe eine 4x4 Matrix und eine 1x4 Matrix, also halt der Vektor und möchte diese multiplizieren, weiß nur leider nicht wie das geht und werde aus sämtlichen Erklärungen nicht schlau.

Danke im Vorraus!

LG

 

[Gucky]

Das funktioniert sowieso nicht, da die beiden inneren Zahlen gleich sein müssen.
Du könntest eine 4x4 und eine 4x1 Matrix multiplizieren.

Wie wird das denn "zu Fuß" gemacht? Guck dir dazu mal das Falksche Schema an.

 

[husox123]

Das was ich vorhin geschrieben habe, war falsch. Deswegen nehme ich es raus. Sorry

das was unten steht ist ein 4x1 matrix.

(4x4) x (4x1)


...........| 1
...........| 2
...........| 3
...........| 4
------.-|-----------------
1 1 1 1| 10
1 1 1 1| 10
1 1 1 1| 10
1 1 1 1| 10

 

[husox123]

Also du musst 3 Arrays definieren.

1. vierMalvier [4][4]
2. einMalVier [4]

da das ergebnis von der multiplikation 4x1 Matrix ist

3. ergebnis [4]


Du musst nur noch den Multiplikation-Regel anwenden und alles in eine verschachtelte for-Schleife packen.

 

[husox123]

Also du musst 3 Arrays definieren.

1. vierMalvier [4][4]
2. einMalVier [4]

da das ergebnis von der multiplikation 4x1 Matrix ist

3. ergebnis [4]


Du musst nur noch den Multiplikation-Regel anwenden und alles in eine verschachtelte for-Schleife packen.

2. nicht einMalvier sondern vierMaleins

 

[Puppilein]

for(int i = 0; i < mat1.length; i++)
{ 
    for(int j = 0; j < mat2[0].length; j++)
    {
        for(int k = 0; k < mat1[0].length; k++)
        {
            mat3[i][j] += mat1[i][k] * mat2[k][j];
        }
    }

}

Habe das gefunden, kann man das irgendwie mit meiner Frage vergleichen?
Dann irgendwie anstatt der Matrix halt einen Vektor?
Bin echt kompletter Einsteiger, ein fertiger Quellcode würde mir als Erklärung echt helfen, das mit den einzelnen Erklärungen mit arrays etc. versteh ich nicht ganz...

Und ja am Anfang hatte ich einfach einen Dreher, ist natürlich eine 4x1 Matrix und nicht umgekehrt

Danke für alle bisherigen Antworten!

 

[Gucky]

Einen fertigen Quellcode wirst du nur in der Jobbörse finden. Und da kostet der Geld.
Versuch etwas und wir werden dir helfen.

Vielleicht solltest du mit etwas Einfacherem anfangen. Fakultätsberechnungen oder auch den Binomialkoeffizient, bevor du dich an Matrizen heranwagst.

 

[Puppilein]

Danke aber ich mach das ja nicht aus Spaß, schreibe Klausur und habe Hausaufgaben die sich damit beschäftigen, muss es also zwangsläufig wissen. Bin leider nicht so die leuchte in Informatik, studiere das auch nicht, ist aber leider ein Modul das ich belegen muss.
Deswegen die Frage hängt das was ich vorher gepostet habe mit meinem Thema zusammen? Also mein geposteter Quellcode

 

[Gucky]

Ja klar hängt das zusammen. Aber trotzdem bringt das nichts, so anzufangen.
Du fängst auch als Mathematiker nicht mit der kumulierten Biomialverteilung an sondern mit dreistufigen Bernoullie Wahrscheinlichkeitsbäumen.

 

[husox123]

Den Ansatz habe ich dir geschrieben. Versuch einfach damit etwas anzufangen. Dann helfe ich weiter.

 

[Puppilein]

Was meinst du mit multiplikationsregeln? Bzw wie soll ich die darauf anwenden. Es handelt sich übrigens um eine symmetrische Matrix, Entschuldigung das habe ich vergessen.

Also ich brauche eine Schleife die die Matrix erstellt von quasi dem "ersten Kästchen" bis zum Matrixende, und das selbe für den Vektor und dann noch für den Ergebnisvektor.
Und halt eine "Formel" für die Multiplikation?

 

[husox123]

Also, die ganz normale Multiplikation eben. Es funktioniert wie oben.

Du musst dir nur noch eine schleife ausdenken, die dir es ausrechnet. Es bietet sich zwei for-schleifen an.

for(;;)
{
    for(;;)
    {}
}

Und beider Zuweisung:
Wenn es von der Tastatur eingelesen wird, dann mit eine schleife.

sonst ohne Schleife: Einfach zuweisen

 

[Puppilein]

for(int i = 0; i < mat1.length; i++)
{ 
    for(int j = 0; j < vek1.length; j++)
    {
     
    }
 
}

In etwa so? Und dann brauch ich noch eine Formel die mir das multipliziert?

 

[husox123]

for(int i = 0; i < mat1.length; i++)
{ 
    for(int j = 0; j < vek1.length; j++)
    {
     
    }
 
}

In etwa so? Und dann brauch ich noch eine Formel die mir das multipliziert?

Genau.

nur noch die Rechnung . Du kannst einen Zwischenspeicher benutzen. ist aber nicht not wendig.
Nur dann wenn du innerhalb der gleichen Schleife ausgeben möchtest.

Sonst brachst du für die Ausgabe auch eine Schleife. Da du als Ergebnis 4x1 Matrix hast. Braucht dann nur for( ; ; ).

 

[stg]

[OT]
@husox:
Du hast dich da in deinem Bildchen verrechnet
(in der letzen Zeile vom Ergebnis sollte es 14 statt 13 heißen...)
[/OT]

 

[husox123]

ooh, Sorry und danke. Und korrigiert.

 

[Puppilein]

Aber for was?

Einen neuen Vektor als Ergebnisvektor bzw matrix?

{ for(int j=0 ; j < vek2.lenght; j++)

}

Aber der sagt ja noch lange nicht dass ich das multipliziere, ich brauche doch noch irgendwo eine Multiplikation oder?

 

[husox123]

Aber for was?

Einen neuen Vektor als Ergebnisvektor bzw matrix?

{ for(int j=0 ; j < vek2.lenght; j++)

}

Aber der sagt ja noch lange nicht dass ich das multipliziere, ich brauche doch noch irgendwo eine Multiplikation oder?

Richtig. In die verschachtelte Schleife muss du jetzt deine Multiplikation reinpacken.
Die Länge deines Arrays(Ergebnis) wird nicht anders als die Länge deines Vektors(4x1) sein.

 

[Puppilein]

for(int i = 0; i < mat1.length; i++)
{ 
    for(int j = 0; j < vek1.length; j++)
    {
        for(int j = 0; j < vek2.length; j++)
        {
            vek2[i][j] = mat1[][] * vek1[][];
        }
    }
 
}

??
Weiß nicht was in die eckigen Klammern reinkommt

 

[husox123]

for(int i = 0; i < mat1.length; i++)
{ 
    for(int j = 0; j < vek1.length; j++)
    {
        for(int j = 0; j < vek2.length; j++)
        {
            vek2[i][j] = mat1[][] * vek1[][];
        }
    }
 
}

??
Weiß nicht was in die eckigen Klammern reinkommt

nur zwei schleifen für die rechnung.

eine frage : ist die Zweite kein Vektor? wenn ja dann vek1


vek2[j]= mat1[][] * vek1[]

also

for(int i = 0; i< vek1.length; i++)
    {
        for(int j = 0; j < vek2.length; j++)
        {
            vek2[i] += mat1[i][j] * vek1[j];
        }
    }

 

[Puppilein]

Wo ist denn beim letzten Code die Matrix hin? Brauche ja die Matrix und den Vektor und als Ergebnis habe ich wieder einen vektor

 

[husox123]

Wo ist denn beim letzten Code die Matrix hin? Brauche ja die Matrix und den Vektor und als Ergebnis habe ich wieder einen vektor

ja, wenn du 4x4 Matrix mit 4x1 Vektor multiplizierst, kommt ein Vektor raus.

 

[Puppilein]

Ja das ist mir klar
Wollte nur fragen wo bei deinem letzten Code die Matrix ist, also bei dem hier:

for(int i = 0; i< vek1.length; i++)
    {
        for(int j = 0; j < vek2.length; j++)
        {
            vek2[i] += mat1[i][j] * vek1[j];
        }
    }

Da ist ja jetzt nur der Vektor und der Ergebnisvektor oder? Aber wo ist die Matrix
Und warum ist es bei dem einen Vektor int i und bei dem anderen int j ?

 

[husox123]

Ja das ist mir klar
Wollte nur fragen wo bei deinem letzten Code die Matrix ist, also bei dem hier:

for(int i = 0; i< vek1.length; i++)
    {
        for(int j = 0; j < vek2.length; j++)
        {
            vek2[i] += mat1[i][j] * vek1[j];
        }
    }

Da ist ja jetzt nur der Vektor und der Ergebnisvektor oder? Aber wo ist die Matrix
Und warum ist es bei dem einen Vektor int i und bei dem anderen int j ?

So jetzt:

Du hast ein;
4x4 Matrix mat1[4][4];
4x1 Vektor vek1[4];

und wenn mann die beiden multipliziert hat man als Ergebnis ein Vektor.

Ergebnis vek2[4];


vek2 += mat1[j] * vek1[j]; hier mit sage ich ihm.

ich bin in der zweiten for schleife.
........................................................
i für 0 und j startet von 0 geht bis 3;
vek2[0] = vek2[0] + mat1[0][0] * vek1[0];
vek2[0] = vek2[0] + mat1[0][1] * vek1[1];
vek2[0] = vek2[0] + mat1[0][2] * vek1[2];
vek2[0] = vek2[0] + mat1[0][3] * vek1[3];
........................................................
i für 1 und j startet von 0 geht bis 3;
vek2[1] = vek2[1] + mat1[1][0] * vek1[0];
vek2[1] = vek2[1] + mat1[1][1] * vek1[1];
vek2[1] = vek2[1] + mat1[1][2] * vek1[2];
vek2[1] = vek2[1] + mat1[1][3] * vek1[3];
........................................................
i für 2 und j startet von 0 geht bis 3;
vek2[2] = vek2[2] + mat1[2][0] * vek1[0];
vek2[2] = vek2[2] + mat1[2][1] * vek1[1];
vek2[2] = vek2[2] + mat1[2][2] * vek1[2];
vek2[2] = vek2[2] + mat1[2][3] * vek1[3];
........................................................
i für 3 und j startet von 0 geht bis 3;
vek2[3] = vek2[3] + mat1[3][0] * vek1[0];
vek2[3] = vek2[3] + mat1[3][1] * vek1[1];
vek2[3] = vek2[3] + mat1[3][2] * vek1[2];
vek2[3] = vek2[3] + mat1[3][3] * vek1[3];
........................................................

so, deswegen i, weil man 4 mal rechnen muss und das Ergebnis in das selbe Array speichert bwz. summieren muss.

Das alles erledigt die beiden for-Schleifen. Mann muss leider wissen, wie die for-Schleife arbeitet, und die Arrays kennen, damit man weis, wo man die i oder j setzt.

 

[Puppilein]

Okay also ist nicht das mit der matrixschleife der letztendliche richtige Code

for(int i = 0; i < mat1.length; i++)
         { 
         for(int j = 0; j < vek1.length; j++)
        {
        for(int j = 0; j < vek2.length; j++)
        {
            vek2[i] = mat1[i][j] * vek1[j];
        }
    }
 
}

Sondern der hier:

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

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

{  
          vek2[i] += mat1[i][j] * vek1[j];      
}   

}

Vielen Dank

 

[husox123]

Genau. bitte