Forum: Mikrocontroller und Digitale Elektronik "Matritzenmultiplikation" mit Vektoren


von Markus (Gast)


Lesenswert?

Hallo!
Die Überschrift ist leider etwas undeutlich.
Ich habe 2 Matritzen, welche allerdings nicht in einem zweidimensionalen 
Array gespeichert sind, sondern jeweils in der Form (a1,a2,a3,a4,a5, 
b1,b2,b3,b4,b5, c1,...) in einem eindimensionalen Array.
Ich bin nun auf der Suche nach einem Multiplikationsalgorithmus, bei dem 
ich aber nicht den Vektor vorher in eine Matrix umwandeln muss um eine 
"normale" Matritzenmultiplikation (nach dem Standartschma) zu 
implementieren.
Kennt jemand eine Lösung?

von Karl H. (kbuchegg)


Lesenswert?

Markus wrote:
> ich aber nicht den Vektor vorher in eine Matrix umwandeln muss um eine
> "normale" Matritzenmultiplikation (nach dem Standartschma) zu
> implementieren.

D.h. im Klartext du willst nicht das 1D-Array in ein 2D Array 
umpfriemeln.

> Kennt jemand eine Lösung?

Auch ein 2D Array ist doch letztendlich auch nur eine Rechenvorschrift, 
wie man die Koordinaten als Offset zum Beginn der Daten umrechnen muss.
Mehr steckt da nicht dahinter.
Und sowas kannst du auch selber machen. Du weisst ja wieviele Zeilen 
bzw. Spalten es gibt.

In deinem Fall muss berechnet werden

(Kleinbuchstaben kennzeichnen die eine Matrix,
 Grossbuchstaben die andere
 Die Werte für die Ergebnismatrix beginnen mit Erg

  Erg_a1 = a1 * A1 +
           a2 * B1 +
           a3 * C1 +
           a4 * D1 +
           a5 * E1;

  Erg_a2 = a1 * A2 +
           a2 * B2 +
           a3 * C2 +
           a4 * D2 +
           a5 * E2;

  ....

  Erg_b1 = b1 * A1 +
           b2 * B1 +
           b3 * C1 +
           b4 * D1 +
           b5 * E1;

  Erg_b2 = .....

Und jetzt setzt du dich hin, studierst das Muster wer mit wem 
multipliziert wird und schaust dir an mit welcher allgemeinen Formel man 
diese Werte in dem 1D Array aufsuchen kann.
Es hilft auch, wenn du dir den 1D Vektor mal aufschreibst und mit den 
jeweiligen Zeigefingern (rechte Hand, linke Hand) die Werte für die 
Einzelmultiplikationen eines Ergebniswertes aufsuchst. Dann erkennst du 
nämlich sehr schnell, dass da eine sehr einfache Gesetzmässigkeit 
dahintersteckt.

von schneehase (Gast)


Lesenswert?

Um die Umrechnung kommst du Wohl oder Übel nicht vorbei, aber
in C kann man einen 1D Vektor leicht in einen 2D Vektor umwandlen.
Ein kleines Beispiel:
1
uint8_t Vektor_1D[36] = { {a1, a2, a3, a4, a5, a6}, {b1, ...}, ... };
Vektor_1D ist die Address deines Speichers.
Und so kannst du daraus ein 2DArray machen.
1
uint8_t **Vektor_2D;
2
Vektor_2D = Vektor_1D;
Zugriff geht so:
1
for(int i=0; i<6; i++)
2
   for(int k=0; k<6; k++)
3
      Vektor_2D[i][k]=0;
Vola.

von Morin (Gast)


Lesenswert?

Du schreibst den Algorithmus wie in 2D hin, nur dass bei jedem Zugriff 
auf Matrixelemente vorher die entsprechende Adressrechnung durchgeführt 
wird:

Arrayindex = Zeilenindex * Zeilenlänge + Spaltenindex

(wobei die Zeilen- und Spaltenindices ab 0 zählen, genau wie im 
2D-Fall). Diesen Arrayindex benutzt du dann für den Array-Zugriff, 
sowohl beim Lesen der Eingabematrizen als auch beim Schreiben der 
Ausgabematrix.

von Markus (Gast)


Lesenswert?

@schneehase:
Mit den Zeigern in C kenne ich mich nicht so aus.
Danke!
Wie geht eigendlich der umgekehrte Weg, also ein zweidimensionales Array 
in ein eindimensionales verwandeln?

von Karl H. (kbuchegg)


Lesenswert?

Markus wrote:
> @schneehase:
> Mit den Zeigern in C kenne ich mich nicht so aus.
> Danke!
> Wie geht eigendlich der umgekehrte Weg, also ein zweidimensionales Array
> in ein eindimensionales verwandeln?

Psst. Ich verrat dir was:
Es gibt kar keine 2D-Arrays.
Bei einem Array liegen alle Bytes die es ausmachen immer im Speicher 
hintereinander, egal ob 1D, 2D, n-D
Ob das dann als 1D oder 2D oder 3D aufgefasst wird, hängt einzig und 
alleine davon ab, wie die Umrechnung von den angegebenen Indizes zu der 
Bytenummer ab Beginn des Arrays gemacht wird, ist also eine reine 
Berechnungssache beim Zugriff.

Und der Tip Nummer 2:
Mit einem Cast, kannst du den Compiler immer zwingen, irgendwelche Bytes 
im Speicher als genau den von dir gewünschten Datentyp aufzufassen.


Das hier ist zb ein 2D Array mit den Dimensionen 5 und 3.
Die Zahlen in den Feldern geben die Indexnummer jedes ELements an, wenn 
man einfach alle Elemente hintereinander anordnen würde.

  +---+---+---+---+---+
  | 0 | 1 | 2 | 3 | 4 |
  +---+---+---+---+---+
  | 5 | 6 | 7 | 8 | 9 |
  +---+---+---+---+---+
  |10 |11 |12 |13 |14 |
  +---+---+---+---+---+

Im Speicher liegt das dann so vor

  +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
  | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |10 |11 |12 |13 |14 |
  +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

also einfach nur alles hintereinander.

Zurück zur 2D Sicht der Dinge. Um also an das erste Elemnt in der 
zweiten Zeile zu kommen, musst du praktisch gesehen, einfach nur alle 
Elemente der ersten Zeile 'überspringen'. Wieviele das sind weist du 
aber: Das gibt dir die Spalten Dimension ja vor.

  Arrayindex = Zeilenindex * Anzahl_Spalten + Spaltenindex

Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.