minor van 4x4 matrix

[kilon666]

Als je niet zoveel van matrices afweet kan het misschien lastig zijn om me te helpen, maar misschien lukt het wel of zijn er andere mensen die me kunnen helpen.

Ik moet van een 4x4 matrix de minor bepalen. Dit is dezelfde matrix waarbij rij i en kolom j van het element a(i,j) wordt verwijderd.
Je houdt dus een matrix met de dimensies 3x3 over.

Aangenomen wordt dat de input waarden de matrix A en de waarden i en j zijn.

Het prototype van de functie is als volgt:
double minor(double a[][4], int i, int j);

Ik weet nu hoe je matrices in moet lezen en moet printen.

Dus:
[cpp]#include <iostream>

using namespace std;

//Definieren van de maximale grootte van de matrix
#define MAX_SIZE 4

//Definieren van het type voor de matrices
typedef double matrix[MAX_SIZE][MAX_SIZE];

//Functie prototype
void lees_matrix(matrix a, int k, int l);
void print_matrix(matrix c, int k,int j);
//double minor(matrix a, int i, int j);

int main()
{
//Declaraties
matrix a;
int rij, kolom;

cout <<"Voer het aantal rijen en kolommen voor de matrix in" << endl;
cin >> rij >> kolom;

if(rij>MAX_SIZE || kolom>MAX_SIZE)
{
cout << "De maximale grootte van de rijen of kolommen wordt overschreden." << endl;
exit(1);
}

lees_matrix(a, rij, kolom);
print_matrix(a, rij, kolom);
// minor(a, rij, kolom);

return 0;
}



/*------------------------------------------------------------*/
//Functie voor het lezen van een matrix
void lees_matrix(matrix a, int k, int l)
{
int rij, kolom;
for (rij=0; rij<k; rij++)
{
cout << "Voer de data in voor rij "<< rij+1 << endl;
for(kolom=0; kolom<l; kolom++)
{
cin >> a[rij][kolom];
}
}
cout << endl;
return;
}



/*------------------------------------------------------------*/
//Functie voor het printen van een matrix
void print_matrix(matrix a, int k,int j)
{
int rij, kolom;
for(rij=0; rij<k; rij++)
{
for(kolom=0; kolom<j; kolom++)
{
cout << a[rij][kolom] << " ";
}
cout << endl;
}
return;
}



/*------------------------------------------------------------*/
//Functie bepalen van een minor
double minor(matrix a, int i, int j)
{
int rij, kolom;

}[/cpp]

Waarbij ik typedef heb gebruikt omdat ik dit prettiger vind werken.
Dit werkt dus, maar er staat dan ook nog niks in de functie voor de minor.
Je moet iets doen met minimaal 2 for loops en met -1 of iets..

Het is niet nodig om classes of pointers te gebruiken.

 

[c er]

Dus als ik het goed begrijp:
Als A een m x n matrix is dan

minor( A,i,j )[r][s] = A[r][s]      voor  r>=1 en r< i   en s>=1 en s< j
minor( A,i,j )[r][s] = A[r][s+1]    voor  r>=1 en r< i   en s>=j en s<=n-1
minor( A,i,j )[r][s] = A[r+1][s]    voor  r>=i en r<=m-1 en s>=1 en s< j
minor( A,i,j )[r][s] = A[r+1][s+1]  voor  r>=i en r<=m-1 en s>=j en s<=n-1

Om je probleem op te lossen kan je inderdaad gebruik maken van een dubbele for loop.
Als het niet lukt kan ik wel evt. wat code posten (voor zover ik het zelf begrijp).

Edit:
Ik zie nu dat n=m=4 ((4x4) matrix)
Het bovenstaande is dan ook geldig.

 

[kilon666]

Ik ga het hiermee doen, maar nu lukt het me niet meer om hier een willekeurige 4x4 matrix in toe voeren

[CPP]#include <iostream>
#include <cmath>
#define n 4
using namespace std;

int det(int A[n][n], int w)
{
int i, j, k, h, d = 0;
int m[n][n] = {0};

if (w == 2)
d = A[0][0]*A[1][1] - A[1][0]*A[0][1];
else
{
d = 0;
for (k = 0 ; k < w ; k++)
{
/* Create minor matrix */
for (i = 1 ; i < w ; i++)
{
h = 0;
for (j = 0; j < w; j++)
{
if (j == k)
continue;
m[i-1][h] = A[j];
h++;
}
}

/* sum of (+/-)cofactor * minor matrix */
d += pow(-1.0, k) * A[0][k] * det(m, w-1);
}
}
return d;
}

int main()
{
int determinant;
int A[n][n] = {{3,-1,-1},{2,-1,1},{1,-3,2}}; //Willekeurige 4x4 matrix

determinant = det(A, n);
cout << determinant;

system("PAUSE");
return 0;
}
[/CPP]

 

[c er]

nu lukt het me niet meer om hier een willekeurige 4x4 matrix in toe voeren

Daar was toch de functie void lees_matrix(matrix a, int k, int l); voor?
Alleen werk je nu met int i.p.v. van double. Dus zou je hem daarop moeten aanpassen iets als void lees_matrix(int a[][n], int k, int l);

Wat gaat er nu fout?