Creative Commons License Foxbond's Repo

/**(c) 2016 Michał (Foxbond) Chraniuk */
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>


void cls(void) {
	system("cls");
}

int random(int min, int max)
{
	int tmp;
	if (max >= min)
		max -= min;
	else
	{
		tmp = min - max;
		min = max;
		max = tmp;
	}
	return max ? (rand() % max + min) : min;
}

int getSize(void) {
	int size;
	printf("Podaj rozmiar macierzy:");
	scanf("%d", &size);
	return size;
}


double** createArray(int size) {
	double **tab;
	tab = (double**)malloc(size*size*sizeof(double));

	for (int i = 0; i < size; i++) {
		tab[i] = (double*)malloc(size*sizeof(double));
	}

	return tab;
}

void readArray(double** tab, int size) {
	int i, j, k, l;
	for (i = 0; i<size; i++)
	{
		for (j = 0; j<size; j++)
		{
			//
			for (k = 0;k <= i;k++) {
				printf("\n");
				if (k == i) {
					for (l = 0;l < j;l++) {
						printf("%10.2f", tab[k][l]);
						//printf("\t");
					}
				}
				else {
					for (l = 0;l < size;l++) {
						printf("%10.2f", tab[k][l]);
						//printf("\t");
					}
				}
			}
			//
			scanf("%f", &tab[i][j]);
			cls();
		}
	}
}

void printArray(double** tab, int size, int precA, int precB) {
	int i, j;
	char temp[20];
	sprintf(temp, "%%%d\.%df\0", precA, precB);

	for (i = 0; i<size; i++)
	{
		for (j = 0; j<size; j++)
		{

			printf(temp, tab[i][j]);
		}
		printf("\n");
	}
}


void fillArray(double** tab, int size, int min, int max) {
	int i, j;
	for (i = 0; i<size; i++)
	{
		for (j = 0; j<size; j++)
		{
			tab[i][j] = (double)random(min, max);
		}
	}
}

double det1(double** tab) {
	return tab[0][0];
}

double det2(double** tab) {
	return (tab[0][0] * tab[1][1] - tab[0][1] * tab[1][0]);
}

double det3(double** t) {
	return (
		t[0][0] * t[1][1] * t[2][2]+
		t[1][0] * t[2][1] * t[0][2]+
		t[2][0] * t[0][1] * t[1][2]-
		t[0][2] * t[1][1] * t[2][0]-
		t[1][2] * t[2][1] * t[0][0]-
		t[2][2] * t[0][1] * t[1][0]);
}

double det(double** tab, int size) {
	int i, j;

	if (size == 1) {
		return det1(tab);
	}
	else if (size == 2) {
		return det2(tab);
	}
	else if (size == 3) {
		return det3(tab);
	}

	//klonowanie
	double** ctab;
	ctab = createArray(size);
	for (i = 0;i < size;i++) {
		for (j = 0;j < size;j++) {
			ctab[i][j] = tab[i][j];
		}
	}
	

	//zerowanie kolumny
	for (i = 1;i < size;i++) {
		double temp = -ctab[i][0] / ctab[0][0];
		
		for (j = 0;j < size;j++) {
			ctab[i][j] = ctab[i][j]+ctab[0][j]*temp;
		}
	}
	
	//wykreslenie
	double** temp;
	temp = createArray(size-1);
	for (i = 0;i < (size - 1);i++) {
		for (j = 0;j < (size - 1);j++) {
			temp[i][j] = ctab[(i + 1)][(j + 1)];
		}
	}
	
	return ctab[0][0]*det(temp, size - 1);
}


double** macierzDopAlgeb(double** tab, int size) {
	int i, j, k, l, m, n;

	double** res;
	res = createArray(size);


	for (i = 0;i < size;i++) {
		for (j = 0;j < size;j++) {
			double** temp;
			temp = createArray(size - 1);
			m = n = 0;
			for (k = 0;k < size;k++) {
				for (l = 0;l < size;l++) {
					if (k == i || l == j) {
						continue;
					}
					temp[m][n++] = tab[k][l];
					if (n == (size - 1)) {
						m++;
						n = 0;
					}
				}
			}

			
			res[i][j] = det(temp, size-1);

			//
			if ((i + j) % 2 == 1) {
				res[i][j] *= -1;
			}
		}
	}

	return res;
}

double** macierzTransp(double** tab, int size) {
	int i, j;

	double** res;
	res = createArray(size);

	for (i = 0;i < size;i++) {
		for (j = 0;j < size;j++) {
			res[j][i] = tab[i][j];
		}
	}

	return res;
}


void zwin(double** tab, int size, double det) {
	int i, j;

	for (i = 0;i < size;i++) {
		for (j = 0;j < size;j++) {
			tab[i][j] /= det;
		}
	}
}



int main() {
	srand(time(NULL));
	int size = getSize();

	double** tab;
	tab = createArray(size);


	//printf("Wypelnij macierz:");
	//readArray(tab, size);

	fillArray(tab, size, -10, 10);
	cls();
	printf("Macierz:\n");
	printArray(tab, size, 15, 0);
	
	double wyznacznik = det(tab, size);
	printf("\nWyznacznik = %.0f\n", wyznacznik);

	if (wyznacznik == 0) {
		printf("Nie istnieje macierz odwrotna gdy wyznacznik jest rowny 0!");
		getch();
		return 0;
	}


	//dopełnienia algebraiczne
	double** tabD;
	tabD = macierzDopAlgeb(tab, size);
	printf("Macierz dopelnien algebraicznych:\n");
	printArray(tabD, size, 15, 0);

	//transponowanie
	double** tabT;
	tabT = macierzTransp(tabD, size);
	printf("Macierz dopelnien algebraicznych transponowana:\n");
	printArray(tabT, size, 15, 0);

	//wymnozenie
	zwin(tabT, size, wyznacznik);
	printf("Macierz odwrotna:\n");
	printArray(tabT, size, 15, 5);


	//for Dev-cpp
	getch();
	//

	return 0;
}

> Back