/*
* This method asks to the user for a size to create two matrix
* and are filled with random numbers, after that prints both matrix
* on the console
*/
void startMatrix() {
int squareMatrixSize = 0;
int validateFlag = 1;
// Validation metodology, the matrix size must be greater than 1 and the size must be power of 2
while (validateFlag == 1) {
// while (((squareMatrixSize & (squareMatrixSize - 1)) == 0) || squareMatrixSize < 2) {
printf("\nEnter the size of your square matrix:\n>");
scanf("%d", &squareMatrixSize);
if (squareMatrixSize < 2) {
printf("[ERROR] The matrix smaller size is 2\n");
} else if ((squareMatrixSize & (squareMatrixSize - 1)) != 0) {
printf("[ERROR] The matrix size must be power of two\n");
} else {
validateFlag = 0;
}
}
int created1 = createSquareMatrix(&matrix1, squareMatrixSize);
int created2 = createSquareMatrix(&matrix2, squareMatrixSize);
if (created1 == 1 && created2 == 1) {
fillSquareMatrixWithRandom(&matrix1);
fillSquareMatrixWithRandom(&matrix2);
printf("\n\nMatrix 1: \n\n");
printSquareMatrix(matrix1);
printf("\n\nMatrix 2: \n\n");
printSquareMatrix(matrix2);
} else {
printf("[ERROR] There has been a problem creating the Matrix\n");
}
}
double Matrix::determinant(double** matrix, int size)
{
if (size == 1)
return matrix[0][0];
int minorSize = size - 1;
double**minor = createSquareMatrix(minorSize);
double result = 0;
for (int i = 0; i < size; i++)
{
copyMinor(matrix, minor, minorSize, i);
result += matrix[0][i] * pow(-1, i) * determinant(minor, minorSize);
}
eraseMatrix(minor, minorSize);
return result;
}
/**
* Multiply two matrix and store the result into the result matrix given by parameter
*/
void multiplyCoolMatrix(Matrix matrixA, Matrix matrixB, Matrix* matrixResult) {
int matrixSize = getSize(matrixA);
createSquareMatrix(matrixResult, matrixSize);
if (matrixSize > 2) {
int subMatrixSize = matrixSize / 2;
// Auxiliar variables
Matrix auxMatrixA1 = NULL, auxMatrixB1 = NULL, auxMatrixA2 = NULL, auxMatrixB2 = NULL;
Matrix auxContainer1 = NULL, auxContainer2 = NULL, solutionContainer = NULL;
createSquareMatrix(&solutionContainer, subMatrixSize);
createSquareMatrix(&auxMatrixA1, subMatrixSize);
createSquareMatrix(&auxMatrixB1, subMatrixSize);
createSquareMatrix(&auxMatrixA2, subMatrixSize);
createSquareMatrix(&auxMatrixB2, subMatrixSize);
createSquareMatrix(&auxContainer1, subMatrixSize);
createSquareMatrix(&auxContainer2, subMatrixSize);
int operation1Index = 0;
for(short quadrant = 0; quadrant < 4; quadrant++) {
operation1Index += 4;
copyQuadrant(matrixA, &auxMatrixA1, operations[operation1Index -4]);
copyQuadrant(matrixB, &auxMatrixB1, operations[operation1Index -3]);
multiplyCoolMatrix(auxMatrixA1, auxMatrixB1, &auxContainer1);
copyQuadrant(matrixA, &auxMatrixA2, operations[operation1Index -2]);
copyQuadrant(matrixB, &auxMatrixB2, operations[operation1Index -1]);
multiplyCoolMatrix(auxMatrixA2, auxMatrixB2, &auxContainer2);
sumMatrix(auxContainer1, auxContainer2, &solutionContainer);
assignCuadrant(solutionContainer, matrixResult, quadrant);
}
destroyMatrix(&auxMatrixA1);
destroyMatrix(&auxMatrixB1);
destroyMatrix(&auxMatrixA2);
destroyMatrix(&auxMatrixB2);
destroyMatrix(&auxContainer1);
destroyMatrix(&auxContainer2);
destroyMatrix(&solutionContainer);
} else {
int value1, value2, container = 0;
int matrixSize = getSize(matrixA);
for (int i = 0; i < matrixSize; i++) {
for (int j = 0; j < matrixSize; j++) {
for (int k= 0; k < matrixSize; k++) {
getValue(matrixA, j, k, &value1);
getValue(matrixB, k, i, &value2);
container += value1 * value2;
}
assingValue(matrixResult, j, i, container);
container = 0;
}
}
}
}
