#include"stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include<math.h>
#define M 10
#define N 50

typedef struct matrix
{
	int row;
	int colm;
	int *matr;
} matrix;


void print_matrix(int *matr, int matrow, int matcolm, char *filename);
int *matrix_transponition(int *matr, int matArow, int matAcolm);
int *mult_2_matr(int matrow1, int matcolm1, int *mat1, int matrow2, int matcolm2, int *mat2);
void matrix_multiplication(matrix*array, int number);
int *minor(int *matrix, int size, int index);
int determiant(int *matrix, int size);
void inverse_matrix(int *matrix, int row, int colm, int number);



int main()
{
	int size_of_arr, i = 0, j = 0, k = 0, num_of_digit = 0, colm = 0, row = 0, size_of_digit = 0, size_of_matr = 0, flag = 0, n = 1, c=0, num_act=0;
	size_of_arr = M;
	size_of_digit = M;
	size_of_matr = M;
	char* str = (char*)malloc(N * sizeof(char));
	char **arr = (char**)malloc(size_of_arr * sizeof(char*));
	char* newtext;
	int *digit = (int*)malloc(size_of_digit * sizeof(int));
	int *buffer;
	matrix* arr_matr = (matrix*)malloc(size_of_matr * sizeof(matrix));
	FILE *myfile;
	myfile = fopen("input_file.txt", "r");
	if (myfile != NULL)
	{
		while (fgets(str, N, myfile) != NULL)

		{
			while (str[0] != '\n')
			{
				if (str[strlen(str) - 1] == '\n')
					str[strlen(str) - 1] = '\0';
				flag = 0;
				i = 0;
				newtext = strtok(str, " ");
				while (newtext != NULL)
				{
					arr[i] = newtext;
					i++;
					if (i + 1 == size_of_arr)
					{
						size_of_arr += M;
						arr = (char**)realloc(arr, (size_of_arr) * sizeof(char *));
					}
					newtext = strtok(NULL, " ");
				}
				size_of_arr = i;
				arr[i] = '\0';
				colm = i;
				if (colm != c && c != 0)
				{
					printf("wrong with %d\n", n);
					flag = 1;
					c = 0;
					num_of_digit = 0;
					break;
				}
				c = colm;
				i = 0;
				for (j = 0; j < size_of_arr; j++)
				{
					if (num_of_digit + j == size_of_digit)
					{
						size_of_digit += M;
						digit = (int*)realloc(digit, size_of_digit * sizeof(int));
					}
					digit[num_of_digit + j] = atoi(arr[j]);
				}
				num_of_digit += size_of_arr;
				str[0] = '\0';
				fgets(str, N, myfile);

			}
			if (flag == 0)
			{
				row = num_of_digit / colm;
				if (k == size_of_matr)
				{
					size_of_matr += M;
					arr_matr = (matrix*)realloc(arr_matr, size_of_matr * sizeof(matrix));
				}
				arr_matr[k].row = row;
				arr_matr[k].colm = colm;
				arr_matr[k].matr = (int*)malloc(num_of_digit * sizeof(int));
				for (i = 0; i < num_of_digit; i++)
				{
					arr_matr[k].matr[i] = digit[i];
				}
				n++;
				k++;
				c = 0;
				flag = 1;
				num_of_digit = 0;
				colm = 0;
			}
		}
		fclose(myfile);
		printf("Select an action with a matrix\n 1:Matrix multiplication\n 2:Matrix transponition\n 3:Inverse matrix\n");
		scanf("%d", &num_act);
		switch (num_act)
		{
		case 1:
			matrix_multiplication(arr_matr, k);
			break;
		case 2:
			for (i = 0; i < k; i++)
			{
				char *name_file = "transponition.txt";
				buffer=matrix_transponition(arr_matr[i].matr, arr_matr[i].row, arr_matr[i].colm);
				print_matrix(buffer, arr_matr[i].colm, arr_matr[i].row, name_file);
			}
			break;
		case 3:
			for (i = 0; i < k; i++)
			{
				inverse_matrix(arr_matr[i].matr, arr_matr[i].row, arr_matr[i].colm, i);
			}
			break;
		default:
			printf("Wrong number\n");
			break;
		}
		free(arr);
		free(str);
		free(digit);
	}
	else
		printf("File can not be opened\n");
		system("pause");
	return 0;
}


void print_matrix(int *matr, int matrow, int matcolm, char*filename)
{
	FILE *myfile;
	myfile = fopen(filename, "a");
	if (myfile != NULL)
	{
		int j = 0;
		for (j = 0; j < matrow*matcolm; j++)
		{
			fprintf(myfile, "%d ", matr[j]);
			if ((j + 1) % matcolm == 0)
				fprintf(myfile, "\n");
		}
		fprintf(myfile, "\n");
		fclose(myfile);
	}
	else
		printf("File can not be opened\n");
}


int  *matrix_transponition(int *matr, int matrow, int matcolm)
{

	int *matT = (int *)malloc((matrow*matcolm) * sizeof(int));
	int i, j;

	for (i = 0; i < matrow; i++)
		for (j = 0; j < matcolm; j++)
			matT[i + matrow*j] = matr[i*matcolm + j];
	return matT;
}


int *mult_2_matr(int matrow1, int matcolm1, int *mat1, int matrow2, int matcolm2, int *mat2)
{
	int *res = (int*)malloc((matrow1*matcolm2) * sizeof(int));
	int k = 0, n = 0, j = 0, t = 0, i = 0, sum = 0;
	while (k < matrow1*matcolm2)
	{
		if (n != 0 && (n%matcolm2 == 0))
			j++;
		for (t = 0; t < matcolm2; t++)
		{
			sum = 0;
			for (i = 0; i < matrow2; i++)
			{
				sum += mat1[j*matrow2 + i] * mat2[t + matcolm2*i];
			}
			res[k] = sum;
			n++;
			k++;
		}

	}
	return res;
}

void matrix_multiplication(matrix*array, int number)
{
	char *name_file = "multiplication.txt";
	int i = 0, j=0, buf_row=0, buf_colm=0, flag=0, size_of_buf=0, size_of_result=1;
	int *result;
	buf_row = array[0].row;
	buf_colm = array[0].colm;
	size_of_buf = buf_row*buf_colm;
	int *buffer =(int *)malloc((size_of_buf)*sizeof(int));
	for (j=0; j<buf_row*buf_colm; j++)
	{
		buffer[j] = array[0].matr[j];
	}
	for (i = 1; i < number; i++)
	{
		if (buf_colm == array[i].row)
		{

			result = mult_2_matr(buf_row, buf_colm, buffer, array[i].row, array[i].colm, array[i].matr);
		}
		else
		{
			printf("Fail\n");
			flag = 1;
			break;
		}
		if (flag == 0)
		{
			buf_colm = array[i].colm;
			if (buf_row*buf_colm > size_of_buf)
			{
				size_of_buf = buf_row*buf_colm;
				buffer = (int*)realloc(buffer, size_of_buf * sizeof(int));
			}
			for (j = 0; j<buf_row*buf_colm; j++)
			{
				buffer[j] = result[j];
			}
		}
	}
	if(flag==0)
		print_matrix(result, buf_row, buf_colm, name_file);
	free(buffer);
	free(result);
}


int *minor(int *matrix, int size, int index)
{
	int i = 0, size_of_buf = 0, flag = 0, j = 0, k = 0, size_of_result = 0;
	size_of_buf = size*size - size;
	size_of_result = pow(size - 1, 2);
	int *buf = (int*)malloc(size_of_buf * sizeof(int));
	int *result = (int*)malloc(size_of_result * sizeof(int));
	int index_str_to_delete = index / size;
	int index_elem_to_delete = index - size*index_str_to_delete;

	for (i = 0; i < size*index_str_to_delete; i++)
	{
		buf[i] = matrix[i];
	}
	for (i = index_str_to_delete*size; i<size_of_buf; i++)
		buf[i] = matrix[i + size];

	while (k<size_of_buf)
	{
		if ((k - index) % size == 0)
		{
			k++;
		}
		result[j] = buf[k];
		j++;
		k++;
	}

	free(buf);
	return result;
}

int determiant(int *matrix, int size)
{
	int det = 0, degree = 1, i = 0;
	if (size == 1)
		return matrix[0];
	if (size == 2)
		return matrix[0] * matrix[3] - matrix[2] * matrix[1];
	int *buf;
	for (i = 0; i < size; i++)
	{
		buf = minor(matrix, size, i);
		det = det + (degree*matrix[i] * determiant(buf, size - 1));
		degree = -degree;
	}
	free(buf);
	return det;
}

void inverse_matrix(int *matrix, int row, int colm, int number)
{
	FILE *myfile;
	int det = 0, i = 0, degree = -1, det_m = 0, k = 0;
	int *buf1;
	int *buf2;
	float *inv_matr;
	char *name_file = "inverse matrix.txt";
	if (row != colm)
		printf("Fail with %d\n", number+1);
	else
	{
		inv_matr = (float*)malloc(row*colm * sizeof(float));
		det = determiant(matrix, row);
		if (det == 0)
			printf("Fail with %d\n", number+1);
		else
		{
			buf2 = (int*)malloc(row*colm * sizeof(int));
			for (i = 0; i < row*colm; i++)
			{
				buf1 = minor(matrix, row, i);
				if ((i % row == 0 && row % 2 == 0) || i == 0)
					degree = -degree;
				det_m = degree*determiant(buf1, row - 1);
				buf2[i] = det_m;
				degree = -degree;

			}
			buf2 = matrix_transponition(buf2, row, colm);
			for (i = 0; i < row*colm; i++)
			{
				inv_matr[i] = float(buf2[i]) / det;
			}
			myfile = fopen("inverse matrix.txt", "a");
			for (k = 0; k < row*colm; k++)
			{
				fprintf(myfile, "%g ", inv_matr[k]);
				if ((k +1)% row == 0)
					fprintf(myfile, "\n");
			}
			fprintf(myfile, "\n");
			fclose(myfile);
			free(buf1);
			free(buf2);
		}
	}
}