Matrixmultiplikation

[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)