Matrixmultiplikation

[DirkB]

Count_Omega schrieb:

Darf ich * bei arrays nich verwenden?

Du musst zwischem dem Array (bzw. der Adresse eines (vom ersten) Element) und einem Element vom Array unterscheiden.

Der * ist bei einem Array der Dereferenzierungsoperator.

Wenn Ma oder Mb jeweils 2D-int-Arrays oder
wenn Ma oder Mb Zeiger auf 1D-Zeiger_auf_int-Arrays sind, dann ist Ma[i][j] bzw. Mb[j][k] ein int.
Und bei int ist * die Multiplikation.

Demnach sind bei dir Ma und Mb keine 2D-Arrays.

Zeige den ganzen Code!

[Count_Omega]

[code="cpp"]
#include <iostream>
#define size 1000

using namespace std;

void matrixmult(*Ma[size][size], * Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb);

int main(int argc, char **argv)

{
int z = 1000;
int z1 = 1000;
int z2 = 1000;

int m1[1000][1000];
int m2[1000][1000];
matrixmult(*m1, *m2, z, z1, z2);
}

int ma[size][size];
int mab[size][size];
void matrixmult( *Ma[size][size], *Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb)
{
int Em[1000][1000] = { 0 };
for (int i = 0; i< zeilenmc; ++i)
{
for (int j = 0; j < zeilenmb; ++j)
{

for (int k = 0; k < spaltenmc; ++k)
{

Em[i][k] = Ma[i][j] * Mb[j][k];
}
}

}
std::cout << Em[zeilenmc][spaltenmc] << endl;
}

[Andromeda]

Count_Omega schrieb:

#include <iostream>
#define size 1000

using namespace std;

void matrixmult(*Ma[size][size], * Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb);

int main(int argc, char **argv)

{
	int z = 1000;
	int z1 = 1000;
	int z2 = 1000;

	int m1[1000][1000];
	int m2[1000][1000];
	matrixmult(*m1, *m2, z, z1, z2);
}

int ma[size][size];
int mab[size][size];
void matrixmult( *Ma[size][size],  *Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb)
{
	int Em[1000][1000] = { 0 };
	for (int i = 0; i< zeilenmc; ++i)
	{
		for (int j = 0; j < zeilenmb; ++j)
		{

			for (int k = 0; k < spaltenmc; ++k)
			{
				
				Em[i][k] = Ma[i][j] * Mb[j][k];
			}
		}

	}
	std::cout << Em[zeilenmc][spaltenmc] << endl;
}

// Die Funktion sollte so anfangen
void matrixmult(int Ma[][size], int Mb[][size] ....
// oder so
void matrixmult(int (*Ma)[size], int (*Mb)[size] ...
// aber nicht so
void matrixmult( *Ma[size][size],  *Mb[size][size] ....
...
// und sollte so aufgerufen werden
matrixmult(m1, m2, ...
// aber nicht so
matrixmult(*m1, *m2, ...

ausserdem sollte Em[i][k] = Ma[i][j] * Mb[j][k]; sinnigerweise Em[i][k] += (Ma[i][j] * Mb[j][k]); heissen.

[Swordfish]

Um. Welche Sprache?

[DirkB]

Count_Omega schrieb:

std::cout << Em[zeilenmc][spaltenmc] << endl;

Das gibt das Element (und nur dieses eine Element) Em[1000][1000] des Arrays Em aus. (bei deinen Parametern)
Nach deiner Definition existiert das Element aber gar nicht.

[Count_Omega]

Ich habe den Code nochmals überprüft und jetzt kompiliert es. Beim Ausführen bekomme ich jedoch den error Speicherzugriffsfehler (Speicherabzug geschrieben).
Dies liegt vermutlich an den Arrraygrenzen; wenn ich diese dynamisch festlegen will funktioniert es nicht.

#include <iostream>
#define size 100

using namespace std;

void matrixmult(int Ma[size][size],int Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb);

int main(int argc, char **argv)

{
	int z = 100;
	int z1 = 100;
	int z2 = 100;

	int m1[100][100];
	int m2[100][100];
	matrixmult(m1, m2, z, z1, z2);
}

void matrixmult(int Ma[size][size], int Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb)
{
	int Em[100][100] = { 0 };
	for (int i = 0; i< zeilenmc; ++i)
	{
		for (int j = 0; j < zeilenmb; ++j)
		{

			for (int k = 0; k < spaltenmc; ++k)
			{

				Em[i][k] = Ma[i][j] * Mb[j][k];
			}
		}

	}
	std::cout << Em[zeilenmc][spaltenmc] << endl;
}

[unskilled]

Count_Omega schrieb:

#include <iostream>
#define size 100
//?

using namespace std;

void matrixmult(int Ma[size][size],int Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb);

//int main(int argc, char **argv)
int main()
{
	int z = 100;
	int z1 = 100;
	int z2 = 100;

	int m1[100][100];
	int m2[100][100];
	matrixmult(m1, m2, z, z1, z2);
}

void matrixmult(int Ma[size][size], int Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb)
{
	int Em[100][100] = { 0 };
	for (int i = 0; i< zeilenmc; ++i)
	{
		for (int j = 0; j < zeilenmb; ++j)
		{

			for (int k = 0; k < spaltenmc; ++k)
			{
				
				Em[i][k] = Ma[i][j] * Mb[j][k];
//ist auch noch immer falsch.
			}
		}

	}
	std::cout << Em[zeilenmc][spaltenmc] << endl;
}

Beim Ausführen bekomme ich jedoch den Fehler Speicherzugriffsfehler (Speicherabzug geschrieben).

DirkB schrieb:

Count_Omega schrieb:

std::cout << Em[zeilenmc][spaltenmc] << endl;

Das gibt das Element (und nur dieses eine Element) Em[1000][1000] des Arrays Em aus. (bei deinen Parametern)
Nach deiner Definition existiert das Element aber gar nicht.

scheinst ein bisschen auf kriegsfuß mit lesen zu stehen?

[Count_Omega]

ist es dann richtig mit

...
Em[i][k] += Ma[i][j] * Mb[j][k];
...
for (int l = 0; l > size; ++l)
	{
		for (int m = 0; m > size; ++m)
		{
			std::cout << Em[l][m] << endl;
		}
	}

[wob]

Nein. Denn < und > solltest du besser nicht verwechseln (2x).

Du kannst nicht einfach irgendwelche Zeichen wie *, +, <, =, > raten, sondern musst überlegen, welches jeweils passt! (ok, du kannst schon raten, aber dann ist es Glückssache, ob es richtig wird)

[Count_Omega]

Hat sich erledigt, fuktioniert. Trotzdem vielen Dank. Code:

#include <iostream>
#define size 100

using namespace std;

void matrixmult(int Ma[size][size],int Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb);

int main(int argc, char **argv)

{
	int z = 100;
	int z1 = 100;
	int z2 = 100;

	int m1[100][100];
	int m2[100][100];
	matrixmult(m1, m2, z, z1, z2);
}

void matrixmult(int Ma[size][size], int Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb)
{
	int Em[100][100] = { 0 };
	for (int i = 0; i< zeilenmc; ++i)
	{
		for (int j = 0; j < zeilenmb; ++j)
		{

			for (int k = 0; k < spaltenmc; ++k)
			{

				Em[i][k] = Ma[i][j] * Mb[j][k];
			}
		}

	}
	for (int l = 0; l < size; ++l)
	{
		for (int m = 0; m < size; ++m)
		{
			std::cout << Em[l][m] << endl;
		}
	}
}

Die Matrizen müssen noch gefüllt werden,aber das ist nebensächlich.

[Andromeda]

Count_Omega schrieb:

Hat sich erledigt, fuktioniert.

Em[i][k] = Ma[i][j] * Mb[j][k];

Wetten nicht? Matrizenmultiplikation geht anders.

[Count_Omega]

Ist eine zufallige Arrayfüllung so zulässsig?

...
m1[size][size];
srand((unsigned)time(NULL));

	for (int i = 1; i < 100; i++)
	{
		for (int j = 1; i < 100; j++)
		{
			m1[i][j] = rand() % 100;

		}
	}

[Count_Omega]

Es scheint zu funktionieren:

#include <iostream>
#include <ctime>
#include <cstdlib>
#define size 10

using namespace std;

void matrixmult(int Ma[size][size],int Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb);

int main(int argc, char **argv)

{
	int z = 10;
	int z1 = 10;
	int z2 = 10;

	int m1[10][10];
	int m2[10][10];

	srand((unsigned)time(NULL));

	for (int i = 1; i < 10; i++)
	{
		for (int j = 1; j < 10; j++)
		{
			m1[i][j] = rand() % 10;

		}
	}
	srand((unsigned)time(NULL));
	for (int i = 1; i < 10; i++)
	{
		for (int j = 1; j < 10; j++)
		{
			m2[i][j] = rand() % 10;

		}
	}

	matrixmult(m1, m2, z, z1, z2);
}

void matrixmult(int Ma[size][size], int Mb[size][size], int zeilenmc, int spaltenmc, int zeilenmb)
{
	int Em[10][10] = { 0 };
	for (int i = 0; i< zeilenmc; ++i)
	{
		for (int j = 0; j < zeilenmb; ++j)
		{

			for (int k = 0; k < spaltenmc; ++k)
			{

				Em[i][k] += Ma[i][j] * Mb[j][k];
			}
		}

	}
	std::cout << "Endmatrix: " << "[";
	for (int l = 0; l < size; ++l)
	{
		for (int m = 0; m < size; ++m)
		{
			std::cout <<  Em[l][m] << " " ;
		}
	}
	std::cout << "]" << endl;
}

Ist die Matrixfüllung wirklich zufällig?

[wob]

Liest du eigentlich zu irgendeiner Funktion, die du benutzt, auch mal die Dokumentation?

Preisfrage: wie oft soll man srand in einem Programm aufrufen?

Versuch doch mal als ersten Test, irgendeine Matrix mit $\mathbb{1}$ zu multiplizieren.

(abgesehen davon, dass du hier im C++-Forum postest und du somit besser std::random_device und/oder std::mt19937 nutzen solltest - was hier aber aufgrund der anderen Dinge ziemlich irrelevant ist)